added event notification to segments and rbsegments cache

src/Splitio/Constants/Constants.cs

@@ -65,5 +65,7 @@ public static class ApiVersions
     public static class EventMetadataKeys
     {
         public static string Flags => "flags";
+        public static string Segments => "segments";
+        public static string RuleBasedSegments => "ruleBasedSegments";
     }
 }

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

@@ -1,5 +1,7 @@
-using Splitio.Domain;
+using Splitio.Constants;
+using Splitio.Domain;
 using Splitio.Services.Cache.Interfaces;
+using Splitio.Services.Common;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading.Tasks;
@@ -10,12 +12,15 @@ public class InMemoryRuleBasedSegmentCache : IRuleBasedSegmentCache
     {
         private readonly ConcurrentDictionary<string, RuleBasedSegment> _cache;
         private long _changeNumber;
+        private readonly IEventsManager<SdkEvent, SdkInternalEvent, EventMetadata> _eventsManager;
 
         public InMemoryRuleBasedSegmentCache(ConcurrentDictionary<string, RuleBasedSegment> cache,
+            IEventsManager<SdkEvent, SdkInternalEvent, EventMetadata> eventsManger,
             long changeNumber = -1)
         {
             _cache = cache;
             _changeNumber = changeNumber;
+            _eventsManager = eventsManger;
         }
 
         #region Sync Methods
@@ -45,17 +50,22 @@ public long GetChangeNumber()
         // Producer
         public void Update(List<RuleBasedSegment> toAdd, List<string> toRemove, long till)
         {
+            List<string> toNotify = new List<string>();
             foreach (var rbSegment in toAdd)
             {
                 _cache.AddOrUpdate(rbSegment.Name, rbSegment, (key, oldValue) => rbSegment);
+                toNotify.Add(rbSegment.Name);
             }
 
             foreach (var name in toRemove)
             {
                 _cache.TryRemove(name, out var _);
+                toNotify.Add(name);
             }
 
             SetChangeNumber(till);
+            _eventsManager.NotifyInternalEvent(SdkInternalEvent.RuleBasedSegmentsUpdated,
+                new EventMetadata(new Dictionary<string, object> { { EventMetadataKeys.RuleBasedSegments, toNotify } }));
         }
 
         public void SetChangeNumber(long changeNumber)

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

@@ -1,5 +1,7 @@
-using Splitio.Domain;
+using Splitio.Constants;
+using Splitio.Domain;
 using Splitio.Services.Cache.Interfaces;
+using Splitio.Services.Common;
 using Splitio.Services.Logger;
 using Splitio.Services.Shared.Classes;
 using System.Collections.Concurrent;
@@ -13,10 +15,12 @@ public class InMemorySegmentCache : ISegmentCache
         private readonly ISplitLogger _log = WrapperAdapter.Instance().GetLogger(typeof(InMemorySegmentCache));
 
         private readonly ConcurrentDictionary<string, Segment> _segments;
+        private readonly IEventsManager<SdkEvent, SdkInternalEvent, EventMetadata> _eventsManager;
 
-        public InMemorySegmentCache(ConcurrentDictionary<string, Segment> segments)
+        public InMemorySegmentCache(ConcurrentDictionary<string, Segment> segments, IEventsManager<SdkEvent, SdkInternalEvent, EventMetadata> eventsManger)
         {
             _segments = segments;
+            _eventsManager = eventsManger;
         }
 
         #region Methods Sync
@@ -31,13 +35,17 @@ public void AddToSegment(string segmentName, List<string> segmentKeys)
             }
 
             segment.AddKeys(segmentKeys);
+            _eventsManager.NotifyInternalEvent(SdkInternalEvent.SegmentsUpdated,
+                new EventMetadata(new Dictionary<string, object> { { EventMetadataKeys.Segments, segmentName } }));
         }
 
         public void RemoveFromSegment(string segmentName, List<string> segmentKeys)
         {
             if (_segments.TryGetValue(segmentName, out Segment segment))
             {
                 segment.RemoveKeys(segmentKeys);
+                _eventsManager.NotifyInternalEvent(SdkInternalEvent.SegmentsUpdated,
+                    new EventMetadata(new Dictionary<string, object> { { EventMetadataKeys.Segments, segmentName } }));
             }
         }
 

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

@@ -20,12 +20,12 @@ public class InMemorySplitCache : IFeatureFlagCache
         private readonly ConcurrentDictionary<string, ParsedSplit> _featureFlags;
         private readonly ConcurrentDictionary<string, int> _trafficTypes;
         private readonly ConcurrentDictionary<string, HashSet<string>> _flagSets;
-        private readonly EventsManager<SdkEvent, SdkInternalEvent, EventMetadata> _eventsManager;
+        private readonly IEventsManager<SdkEvent, SdkInternalEvent, EventMetadata> _eventsManager;
 
         private long _changeNumber;
 
         public InMemorySplitCache(ConcurrentDictionary<string, ParsedSplit> featureFlags,
-            IFlagSetsFilter flagSetsFilter, EventsManager<SdkEvent, SdkInternalEvent, EventMetadata> eventsManger,
+            IFlagSetsFilter flagSetsFilter, IEventsManager<SdkEvent, SdkInternalEvent, EventMetadata> eventsManger,
             long changeNumber = -1)
         {
             _featureFlags = featureFlags;
@@ -74,14 +74,13 @@ public void Update(List<ParsedSplit> toAdd, List<string> toRemove, long till)
                 {
                     DecreaseTrafficTypeCount(removedSplit);
                     RemoveFromFlagSets(removedSplit.name, removedSplit.Sets);
+                    eventsFlags.Add(featureFlagName);
                 }
             }
 
             SetChangeNumber(till);
             _eventsManager.NotifyInternalEvent(SdkInternalEvent.FlagsUpdated, 
-                new EventMetadata(new Dictionary<string, object> { { EventMetadataKeys.Flags, eventsFlags } }),
-            Splitio.Util.Helper.GetSdkEventIfApplicable(SdkInternalEvent.FlagsUpdated,
-                _eventsManager));
+                new EventMetadata(new Dictionary<string, object> { { EventMetadataKeys.Flags, eventsFlags } }));
         }
 
         public void SetChangeNumber(long changeNumber)
@@ -154,9 +153,7 @@ public void Kill(long changeNumber, string splitName, string defaultTreatment)
 
             _featureFlags.AddOrUpdate(featureFlag.name, featureFlag, (key, oldValue) => featureFlag);
             _eventsManager.NotifyInternalEvent(SdkInternalEvent.FlagKilledNotification,
-                new EventMetadata(new Dictionary<string, object> { { EventMetadataKeys.Flags, new List<string> { { featureFlag.name } } } }),
-            Splitio.Util.Helper.GetSdkEventIfApplicable(SdkInternalEvent.FlagKilledNotification,
-                _eventsManager));
+                new EventMetadata(new Dictionary<string, object> { { EventMetadataKeys.Flags, new List<string> { { featureFlag.name } } } }));
 
         }
 

src/Splitio/Services/Client/Classes/JSONFileClient.cs

@@ -35,8 +35,9 @@ public JSONFileClient(string splitsFilePath,
             IRuleBasedSegmentCache ruleBasedSegmentCache = null
             ) : base("localhost", fallbackTreatmentCalculator)
         {
-            _segmentCache = segmentCacheInstance ?? new InMemorySegmentCache(new ConcurrentDictionary<string, Segment>());
-            var rbsCache = ruleBasedSegmentCache ?? new InMemoryRuleBasedSegmentCache(new ConcurrentDictionary<string, RuleBasedSegment>());
+            var eventsManager = new EventsManager<SdkEvent, SdkInternalEvent, EventMetadata>(new EventsManagerConfig(), new EventDelivery<SdkEvent, EventMetadata>());
+            _segmentCache = segmentCacheInstance ?? new InMemorySegmentCache(new ConcurrentDictionary<string, Segment>(), eventsManager);
+            var rbsCache = ruleBasedSegmentCache ?? new InMemoryRuleBasedSegmentCache(new ConcurrentDictionary<string, RuleBasedSegment>(), eventsManager);
 
             var segmentFetcher = new JSONFileSegmentFetcher(segmentsFilePath, _segmentCache);
             var splitChangeFetcher = new JSONFileSplitChangeFetcher(splitsFilePath);
@@ -54,8 +55,6 @@ public JSONFileClient(string splitsFilePath,
             }
 
             BuildFlagSetsFilter(new HashSet<string>());
-            var eventsManager = new EventsManager<SdkEvent, SdkInternalEvent, EventMetadata>(new EventsManagerConfig());
-
             _featureFlagCache = featureFlagCacheInstance ?? new InMemorySplitCache(new ConcurrentDictionary<string, ParsedSplit>(parsedSplits), _flagSetsFilter, eventsManager);
             _impressionsLog = impressionsLog;
             _eventsLog = eventsLog;

src/Splitio/Services/Client/Classes/LocalhostClient.cs

@@ -47,7 +47,7 @@ public LocalhostClient(ConfigurationOptions configurationOptions, FallbackTreatm
 
             BuildFlagSetsFilter(new HashSet<string>());
 
-            var eventsManager = new EventsManager<SdkEvent, SdkInternalEvent, EventMetadata>(new EventsManagerConfig());
+            var eventsManager = new EventsManager<SdkEvent, SdkInternalEvent, EventMetadata>(new EventsManagerConfig(), new EventDelivery<SdkEvent, EventMetadata>());
             var splits = _localhostFileService.ParseSplitFile(_fullPath);
             _featureFlagCache = new InMemorySplitCache(splits, _flagSetsFilter, eventsManager);
 

src/Splitio/Services/Client/Classes/SelfRefreshingClient.cs

@@ -92,7 +92,7 @@ public SelfRefreshingClient(string apiKey, ConfigurationOptions config,
         #region Private Methods
         private void BuildEventsManager()
         {
-            _eventsManager = new EventsManager<SdkEvent, SdkInternalEvent, EventMetadata>(new EventsManagerConfig());
+            _eventsManager = new EventsManager<SdkEvent, SdkInternalEvent, EventMetadata>(new EventsManagerConfig(), new EventDelivery<SdkEvent, EventMetadata>());
         }
         private void BuildSplitCache()
         {
@@ -101,12 +101,12 @@ private void BuildSplitCache()
 
         private void BuildSegmentCache()
         {
-            _segmentCache = new InMemorySegmentCache(new ConcurrentDictionary<string, Segment>(_config.ConcurrencyLevel, InitialCapacity));
+            _segmentCache = new InMemorySegmentCache(new ConcurrentDictionary<string, Segment>(_config.ConcurrencyLevel, InitialCapacity), _eventsManager);
         }
 
         private void BuildRuleBasedSegmentCache()
         {
-            _ruleBasedSegmentCache = new InMemoryRuleBasedSegmentCache(new ConcurrentDictionary<string, RuleBasedSegment>(_config.ConcurrencyLevel, InitialCapacity));
+            _ruleBasedSegmentCache = new InMemoryRuleBasedSegmentCache(new ConcurrentDictionary<string, RuleBasedSegment>(_config.ConcurrencyLevel, InitialCapacity), _eventsManager);
         }
 
         private void BuildTelemetryStorage()

src/Splitio/Services/Client/Classes/SplitClient.cs

@@ -64,6 +64,10 @@ public abstract class SplitClient : ISplitClient
         protected IClientExtensionService _clientExtensionService;
         protected IFlagSetsFilter _flagSetsFilter;
 
+        public event EventHandler<EventMetadata> SdkReady;
+        public event EventHandler<EventMetadata> SdkUpdate;
+        public event EventHandler<EventMetadata> SdkTimedOut;
+
         protected SplitClient(string apikey, FallbackTreatmentCalculator fallbackTreatmentCalculator)
         {
             ApiKey = apikey;

src/Splitio/Services/Client/Interfaces/ISplitClient.cs

@@ -1,10 +1,15 @@
 using Splitio.Domain;
+using System;
 using System.Collections.Generic;
 
 namespace Splitio.Services.Client.Interfaces
 {
     public interface ISplitClient : ISplitClientAsync
     {
+        event EventHandler<EventMetadata> SdkReady;
+        event EventHandler<EventMetadata> SdkUpdate;
+        event EventHandler<EventMetadata> SdkTimedOut;
+
         /// <summary>
         /// Returns the treatment to show this key for this feature flag.
         /// The set of treatments for a feature flag can be configured on the Split user interface.

src/Splitio/Services/Common/EventDelivery.cs

@@ -8,14 +8,14 @@ public class EventDelivery<E, M> : IEventDelivery<E, M>
     {
         private readonly ISplitLogger _logger = WrapperAdapter.Instance().GetLogger("EventDelivery");
 
-        public virtual void Deliver(E sdkEvent, M eventMetadata, EventHandler<M> handler)
+        public virtual void Deliver(E sdkEvent, M eventMetadata, Action<M> handler)
         {
             if (handler != null)
             {
                 _logger.Debug($"EventDelivery: Triggering handle for Sdk Event {sdkEvent}");
                 try
                 {
-                    handler(this, eventMetadata);
+                    handler.Invoke(eventMetadata);
                 }
                 catch (Exception e)
                 {