Feature/sdk update event

.harness/pipeline.yaml

@@ -268,7 +268,7 @@ pipeline:
                           -CommitSha "<+codebase.commitSha>" `
                           -SonarProjectKey "dotnet-client" `
                           -SonarToken "<+secrets.getValue('sonarqube-token')>" `
-                          -SonarUrl "https://sonar.harness.io/"
+                          -SonarUrl "https://sonar.harness.io"
               - parallel:
                   - step:
                       type: Run

CHANGES.txt

@@ -1,5 +1,11 @@
 CHANGES
 
+7.13.0 (Feb 2, 2026)
+- Fixed impressions properties format in redis mode.
+- Added the ability to listen to different events triggered by the SDK. Read more in our docs.
+   - SDK_UPDATE notify when a flag or user segment has changed
+   - SDK_READY notify when the SDK is ready to evaluate
+
 7.12.0 (Sep 30, 2025)
 - Added new configuration for Fallback Treatments, which allows setting a treatment value and optional config to be returned in place of "control", either globally or by flag. Read more in our docs.
 - Added a maximum size payload when posting unique keys telemetry in batches

NOTICE.txt

@@ -0,0 +1,5 @@
+Harness Feature Management .NET SDK Copyright 2024-2026 Harness Inc.
+
+This product includes software developed at Harness Inc. (https://harness.io/).
+
+This product includes software originally developed by Split Software, Inc. (https://www.split.io/). Copyright 2015-2024 Split Software, Inc.

Splitio.Redis/Services/Cache/Classes/RedisImpressionsCache.cs

@@ -78,12 +78,13 @@ public async Task RecordImpressionsCountAsync(Dictionary<string, int> impression
             }
         }
 
-        private RedisValue[] GetImpressions(IList<KeyImpression> items)
+        // public for tests
+        public RedisValue[] GetImpressions(IList<KeyImpression> items)
         {
-            var impressions = items.Select(item => JsonConvertWrapper.SerializeObject(new
+            var impressions = items.Select(item => JsonConvertWrapper.SerializeObjectIgnoreNullValue(new
             {
                 m = new { s = SdkVersion, i = MachineIp, n = MachineName },
-                i = new { k = item.keyName, b = item.bucketingKey, f = item.feature, t = item.treatment, r = item.label, c = item.changeNumber, m = item.time, pt = item.previousTime }
+                i = new { k = item.keyName, b = item.bucketingKey, f = item.feature, t = item.treatment, r = item.label, c = item.changeNumber, m = item.time, pt = item.previousTime, properties = item.properties }
             }));
 
             return impressions

Splitio.Redis/Services/Client/Classes/RedisClient.cs

@@ -28,15 +28,14 @@ public class RedisClient : SplitClient
         private IImpressionsCache _impressionsCache;
         private ConnectionPoolManager _connectionPoolManager;
         private IFeatureFlagCacheConsumer _featureFlagCacheConsumer;
-        private readonly new FallbackTreatmentCalculator _fallbackTreatmentCalculator;
 
-        public RedisClient(ConfigurationOptions config, string apiKey, FallbackTreatmentCalculator fallbackTreatmentCalculator) : base(apiKey, fallbackTreatmentCalculator)
+        public RedisClient(ConfigurationOptions config, string apiKey) : base(apiKey)
         {
             _config = new RedisConfig();
-            _fallbackTreatmentCalculator = fallbackTreatmentCalculator;
 
             ReadConfig(config);
 
+            BuildFallbackCalculator(_config.FallbackTreatments);
             BuildRedisCache();
             BuildTreatmentLog(config.ImpressionListener);
 
@@ -77,6 +76,7 @@ private void ReadConfig(ConfigurationOptions config)
             _config.FlagSetsInvalid = baseConfig.FlagSetsInvalid;
             _config.Mode = config.Mode;
             _config.FromCacheAdapterConfig(config.CacheAdapterConfig);
+            _config.FallbackTreatments = baseConfig.FallbackTreatments;
         }
 
         private void BuildRedisCache()

Splitio.Redis/Splitio.Redis.csproj

@@ -7,7 +7,7 @@
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
     <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
     <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
-    <Version>7.12.0</Version>
+    <Version>7.13.0-rc1</Version>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>SplitioRedis.snk</AssemblyOriginatorKeyFile>
     <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>

src/Splitio/Constants/Constants.cs

@@ -1,7 +1,7 @@
 namespace Splitio.Constants
 {
     public static class Push
-    {        
+    {
         public static string ControlPri => "control_pri";
         public static string ControlSec => "control_sec";
         public static string OccupancyPrefix => "[?occupancy=metrics.publishers]";

src/Splitio/Domain/BaseConfig.cs

@@ -11,6 +11,7 @@ public class BaseConfig
         public ImpressionsMode ImpressionsMode { get; set; }
         public HashSet<string> FlagSetsFilter { get; set; }
         public int FlagSetsInvalid { get; set; }
+        public FallbackTreatmentsConfiguration FallbackTreatments { get; set; }
 
         // Bloom Filter
         public int BfExpectedElements { get; set; }

src/Splitio/Domain/EventManagerConfigData.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace Splitio.Domain
+{
+    public class EventManagerConfigData<E, I>
+    {
+        public Dictionary<E, HashSet<I>> RequireAll { get; protected set ; }
+        public Dictionary<E, HashSet<I>> RequireAny { get; protected set; }
+        public Dictionary<E, HashSet<E>> Prerequisites { get; protected set; }
+        public Dictionary<E, HashSet<E>> SuppressedBy { get; protected set; }
+        public Dictionary<E, int> ExecutionLimits { get; protected set; }
+        public HashSet<E> EvaluationOrder { get; protected set; }
+    }
+}

src/Splitio/Domain/EventMetadata.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+
+namespace Splitio.Domain
+{
+    public class EventMetadata
+    {
+        private readonly List<string> _names;
+        private readonly SdkEventType _type;
+
+        public EventMetadata(SdkEventType type, List<string> names) 
+        {
+            _type = type;
+            _names = names;
+        }
+
+        public List<string> GetNames() { return _names; }
+
+        public SdkEventType GetEventType() { return _type; }
+    }
+}

src/Splitio/Domain/EventsManagerConfig.cs

@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Splitio.Domain
+{
+    public class EventsManagerConfig : EventManagerConfigData<SdkEvent, SdkInternalEvent>
+    {
+        public EventsManagerConfig()
+        {
+            RequireAll = new Dictionary<SdkEvent, HashSet<SdkInternalEvent>>
+            {
+                {
+                    SdkEvent.SdkReady, new HashSet<SdkInternalEvent>
+                    {
+                        SdkInternalEvent.SdkReady
+                    }
+                }
+            };
+
+            Prerequisites = new Dictionary<SdkEvent, HashSet<SdkEvent>>
+            {
+                {
+                    SdkEvent.SdkUpdate, new HashSet<SdkEvent>
+                    {
+                        SdkEvent.SdkReady
+                    }
+                }
+            };
+
+            RequireAny = new Dictionary<SdkEvent, HashSet<SdkInternalEvent>>
+            {
+                { SdkEvent.SdkUpdate, new HashSet<SdkInternalEvent>
+                    {
+                        SdkInternalEvent.RuleBasedSegmentsUpdated,
+                        SdkInternalEvent.FlagsUpdated,
+                        SdkInternalEvent.FlagKilledNotification,
+                        SdkInternalEvent.SegmentsUpdated
+                    }
+                }
+            };
+
+            SuppressedBy = new Dictionary<SdkEvent, HashSet<SdkEvent>>();
+
+            ExecutionLimits = new Dictionary<SdkEvent, int>
+            {
+                { SdkEvent.SdkReady, 1 },
+                { SdkEvent.SdkUpdate, -1 }
+            };
+
+            HashSet<SdkEvent> sortedEvents = new HashSet<SdkEvent>();
+            foreach (SdkEvent sdkEvent in new List<SdkEvent> { SdkEvent.SdkReady, SdkEvent.SdkUpdate }) 
+            {
+                sortedEvents = DFSRecursive(sdkEvent, sortedEvents);
+            }
+
+            EvaluationOrder = sortedEvents;
+        }
+
+        private HashSet<SdkEvent> DFSRecursive(SdkEvent sdkEvent, HashSet<SdkEvent> added)
+        {
+            if (added.Contains(sdkEvent)) return added;
+
+            foreach (SdkEvent dependentEvent in GetDependencies(sdkEvent))
+            {
+                added = DFSRecursive(dependentEvent, added);
+            }
+
+            added.Add(sdkEvent);
+
+            return added;
+        }
+
+        private HashSet<SdkEvent> GetDependencies(SdkEvent sdkEvent)
+        {
+            HashSet<SdkEvent> dependencies = new HashSet<SdkEvent>();
+            foreach (KeyValuePair<SdkEvent, HashSet<SdkEvent>> prerequisitesEvent in Prerequisites.Where(x => x.Key.Equals(sdkEvent)))
+            {
+                foreach (var prereqEvent in prerequisitesEvent.Value)
+                {
+                    dependencies.Add(prereqEvent);
+                }
+            }
+
+            foreach (KeyValuePair<SdkEvent, HashSet<SdkEvent>> suppressedEvent in SuppressedBy.Where(x => x.Value.Contains(sdkEvent)))
+            {
+                dependencies.Add(suppressedEvent.Key);
+            }
+
+            return dependencies;
+        }
+    }
+}

src/Splitio/Domain/SdkEvent.cs

@@ -0,0 +1,9 @@
+
+namespace Splitio.Domain
+{
+    public enum SdkEvent
+    {
+        SdkUpdate,
+        SdkReady
+    }
+}

src/Splitio/Domain/SdkEventNotification.cs

@@ -0,0 +1,16 @@
+using Splitio.Domain;
+
+namespace Splitio.Services.EventSource.Workers
+{
+    public class SdkEventNotification
+    {
+        public SdkInternalEvent SdkInternalEvent { get; set; }
+        public EventMetadata EventMetadata { get; set; }
+
+        public SdkEventNotification(SdkInternalEvent sdkInternalEvent, EventMetadata eventMetadata)
+        {
+            SdkInternalEvent = sdkInternalEvent;
+            EventMetadata = eventMetadata;
+        }
+    }
+}

src/Splitio/Domain/SdkEventType.cs

@@ -0,0 +1,9 @@
+
+namespace Splitio.Domain
+{
+    public enum SdkEventType
+    {
+        SegmentsUpdate,
+        FlagsUpdate
+    }
+}

src/Splitio/Domain/SdkInternalEvent.cs

@@ -0,0 +1,13 @@
+
+namespace Splitio.Domain
+{
+    public enum SdkInternalEvent
+    {
+        FlagsUpdated,
+        FlagKilledNotification,
+        RuleBasedSegmentsUpdated,
+        SegmentsUpdated,
+        LargeSegmentsUpdated,
+        SdkReady
+    }
+}

src/Splitio/Services/Cache/Classes/InMemoryReadinessGatesCache.cs

@@ -1,12 +1,21 @@
-using Splitio.Services.Cache.Interfaces;
+using Splitio.Domain;
+using Splitio.Services.Cache.Interfaces;
+using Splitio.Services.Tasks;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace Splitio.Services.Client.Classes
 {
     public class InMemoryReadinessGatesCache : IStatusManager
     {
         private readonly CountdownEvent _sdkReady = new CountdownEvent(1);
         private readonly CountdownEvent _sdkDestroyed = new CountdownEvent(1);
+        private readonly IInternalEventsTask _internalEventsTask;
+
+        public InMemoryReadinessGatesCache(IInternalEventsTask internalEventsTask)
+        {
+            _internalEventsTask = internalEventsTask;
+        }
 
         public bool IsReady()
         {
@@ -18,9 +27,10 @@ public bool WaitUntilReady(int milliseconds)
             return _sdkReady.Wait(milliseconds);
         }
 
-        public void SetReady()
+        public async Task SetReadyAsync()
         {
             _sdkReady.Signal();
+            await _internalEventsTask.AddToQueue(SdkInternalEvent.SdkReady, null);
         }
 
         public void SetDestroy()

src/Splitio/Services/Cache/Classes/InMemoryRuleBasedSegmentCache.cs

@@ -1,5 +1,8 @@
 using Splitio.Domain;
 using Splitio.Services.Cache.Interfaces;
+using Splitio.Services.Logger;
+using Splitio.Services.Shared.Classes;
+using Splitio.Services.Tasks;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading.Tasks;
@@ -10,12 +13,16 @@ public class InMemoryRuleBasedSegmentCache : IRuleBasedSegmentCache
     {
         private readonly ConcurrentDictionary<string, RuleBasedSegment> _cache;
         private long _changeNumber;
+        private readonly IInternalEventsTask _internalEventsTask;
+        private readonly ISplitLogger _log = WrapperAdapter.Instance().GetLogger(typeof(InMemoryRuleBasedSegmentCache));
 
         public InMemoryRuleBasedSegmentCache(ConcurrentDictionary<string, RuleBasedSegment> cache,
+            IInternalEventsTask internalEventsTask,
             long changeNumber = -1)
         {
             _cache = cache;
             _changeNumber = changeNumber;
+            _internalEventsTask = internalEventsTask;
         }
 
         #region Sync Methods
@@ -56,6 +63,15 @@ public void Update(List<RuleBasedSegment> toAdd, List<string> toRemove, long til
             }
 
             SetChangeNumber(till);
+            if (toAdd.Count > 0 || toRemove.Count > 0)
+            {
+                Task task = new Task(() =>
+                {
+                    _internalEventsTask.AddToQueue(SdkInternalEvent.RuleBasedSegmentsUpdated,
+                    new EventMetadata(SdkEventType.SegmentsUpdate, new List<string>())).ContinueWith(OnAddToQueueFailed, TaskContinuationOptions.OnlyOnFaulted);
+                });
+                task.Start();
+            }
         }
 
         public void SetChangeNumber(long changeNumber)
@@ -75,5 +91,10 @@ public Task<RuleBasedSegment> GetAsync(string name)
             return Task.FromResult(Get(name));
         }
         #endregion
+
+        public void OnAddToQueueFailed(Task task)
+        {
+            _log.Error($"Failed to add internal event to queue: {task.Exception.Message}");
+        }
     }
 }