feat(notification-center): Adds LogEvent notification (#188)

Author: mfahadahmed

OptimizelySDK.Tests/EventTests/BatchEventProcessorTest.cs

@@ -30,6 +30,8 @@ class BatchEventProcessorTest
         private BatchEventProcessor EventProcessor;
         private Mock<IEventDispatcher> EventDispatcherMock;
         private TestEventDispatcher TestEventDispatcher;
+        private NotificationCenter NotificationCenter = new NotificationCenter();
+        private Mock<TestNotificationCallbacks> NotificationCallbackMock;
 
         [SetUp]
         public void Setup()
@@ -41,6 +43,12 @@ public void Setup()
 
             eventQueue = new BlockingCollection<object>(100);
             EventDispatcherMock = new Mock<IEventDispatcher>();
+
+            NotificationCallbackMock = new Mock<TestNotificationCallbacks>();
+            NotificationCallbackMock.Setup(nc => nc.TestLogEventCallback(It.IsAny<LogEvent>()));
+
+            NotificationCenter.AddNotification(NotificationCenter.NotificationType.LogEvent,
+                NotificationCallbackMock.Object.TestLogEventCallback);
         }
 
         [TearDown]
@@ -202,7 +210,21 @@ public void TestStopAndStart()
 
             Assert.True(countdownEvent.Wait(TimeSpan.FromMilliseconds(MAX_DURATION_MS * 3)), "Exceeded timeout waiting for notification.");
         }
-        
+
+        [Test]
+        public void TestNotificationCenter()
+        {
+            var countdownEvent = new CountdownEvent(1);
+            NotificationCenter.AddNotification(NotificationCenter.NotificationType.LogEvent, logEvent => countdownEvent.Signal());
+            SetEventProcessor(EventDispatcherMock.Object);
+
+            UserEvent userEvent = BuildConversionEvent(EventName);
+            EventProcessor.Process(userEvent);
+            
+            EventProcessor.Stop();
+            Assert.True(countdownEvent.Wait(TimeSpan.FromMilliseconds(MAX_DURATION_MS * 3)), "Exceeded timeout waiting for notification.");
+        }
+
         [Test]
         public void TestCloseTimeout()
         {
@@ -226,6 +248,7 @@ private void SetEventProcessor(IEventDispatcher eventDispatcher)
                 .WithFlushInterval(TimeSpan.FromMilliseconds(MAX_DURATION_MS))
                 .WithTimeoutInterval(TimeSpan.FromMilliseconds(TIMEOUT_INTERVAL_MS))
                 .WithLogger(LoggerMock.Object)
+                .WithNotificationCenter(NotificationCenter)
                 .Build();
         }
 

OptimizelySDK.Tests/EventTests/CanonicalEvent.cs

@@ -11,6 +11,7 @@ public class CanonicalEvent
         private string VariationId;
         private string EventName;
         private string VisitorId;
+
         private UserAttributes Attributes;
         private EventTags Tags;
 
@@ -20,6 +21,7 @@ public CanonicalEvent(string experimentId, string variationId, string eventName,
             VariationId = variationId;
             EventName = eventName;
             VisitorId = visitorId;
+
             Attributes = attributes ?? new UserAttributes();
             Tags = tags ?? new EventTags();
         }

OptimizelySDK.Tests/NotificationTests/NotificationCenterTests.cs

@@ -82,6 +82,10 @@ public void TestAddMultipleNotificationListeners()
             // Verify that notifications of other types will also gets added successfully.
             NotificationCenter.AddNotification(NotificationType.OptimizelyConfigUpdate, TestNotificationCallbacks.TestConfigUpdateCallback);
             Assert.AreEqual(4, NotificationCenter.NotificationsCount);
+
+            // Verify that notifications of other types will also gets added successfully.
+            NotificationCenter.AddNotification(NotificationType.LogEvent, TestNotificationCallbacks.TestLogEventCallback);
+            Assert.AreEqual(5, NotificationCenter.NotificationsCount);
         }
 
         [Test]
@@ -179,12 +183,12 @@ public void TestSendNotifications()
             notificationCallbackMock.Setup(nc => nc.TestAnotherActivateCallback(It.IsAny<Experiment>(),
                 It.IsAny<string>(), It.IsAny<UserAttributes>(), It.IsAny<Variation>(), It.IsAny<LogEvent>()));
 
+            notificationCallbackMock.Setup(nc => nc.TestLogEventCallback(It.IsAny<LogEvent>()));
 
             // Adding decision notifications.
             NotificationCenter.AddNotification(NotificationTypeActivate, notificationCallbackMock.Object.TestActivateCallback);
             NotificationCenter.AddNotification(NotificationTypeActivate, notificationCallbackMock.Object.TestAnotherActivateCallback);
 
-
             // Adding track notifications.
             NotificationCenter.AddNotification(NotificationTypeTrack, notificationCallbackMock.Object.TestTrackCallback);
 
@@ -202,8 +206,14 @@ public void TestSendNotifications()
             notificationCallbackMock.Verify(nc => nc.TestTrackCallback(It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<UserAttributes>(), It.IsAny<EventTags>(), It.IsAny<LogEvent>()), Times.Never);
 
+            // Add logEvent Notification.
+            NotificationCenter.AddNotification(NotificationType.LogEvent, notificationCallbackMock.Object.TestLogEventCallback);
 
+            // Fire logEvent Notification.
+            NotificationCenter.SendNotifications(NotificationType.LogEvent, logEventMocker.Object);
 
+            // Verify that registered notifications of logEvent type are called.
+            notificationCallbackMock.Verify(nc => nc.TestLogEventCallback(It.IsAny<LogEvent>()), Times.Once);
 
             // Verify that after clearing notifications, SendNotification should not call any notification
             // which were previously registered. 
@@ -253,7 +263,12 @@ public virtual void TestAnotherTrackCallback(string eventKey, string userId, Use
         public virtual void TestDecisionCallback(string type, string userId, UserAttributes userAttributes,
             Dictionary<string, object> decisionInfo) {
         }
-        public virtual void TestConfigUpdateCallback() { }
+
+        public virtual void TestConfigUpdateCallback() {
+        }
+
+        public virtual void TestLogEventCallback(LogEvent logEvent) {
+        }
     }
     #endregion // Test Notification callbacks class.
 }

OptimizelySDK/Event/BatchEventProcessor.cs

@@ -24,6 +24,7 @@
 using OptimizelySDK.ErrorHandler;
 using System.Linq;
 using OptimizelySDK.Event.Dispatcher;
+using OptimizelySDK.Notifications;
 
 namespace OptimizelySDK.Event
 {
@@ -56,6 +57,7 @@ public class BatchEventProcessor: EventProcessor, IDisposable
 
         protected ILogger Logger { get; set; }
         protected IErrorHandler ErrorHandler { get; set; }
+        public NotificationCenter NotificationCenter { get; set; }
 
         private readonly object mutex = new object();
 
@@ -155,7 +157,9 @@ private void FlushQueue()
 
 
             LogEvent logEvent = EventFactory.CreateLogEvent(toProcessBatch.ToArray(), Logger);
-            
+
+            NotificationCenter?.SendNotifications(NotificationCenter.NotificationType.LogEvent, logEvent);
+
             try
             {
                 EventDispatcher?.DispatchEvent(logEvent);
@@ -259,6 +263,7 @@ public class Builder
             private TimeSpan? TimeoutInterval;
             private IErrorHandler ErrorHandler;
             private ILogger Logger;
+            private NotificationCenter NotificationCenter;
 
             public Builder WithEventQueue(BlockingCollection<object> eventQueue)
             {
@@ -302,6 +307,13 @@ public Builder WithLogger(ILogger logger = null)
                 return this;
             }
 
+            public Builder WithNotificationCenter(NotificationCenter notificationCenter)
+            {
+                NotificationCenter = notificationCenter;
+
+                return this;
+            }
+
             public Builder WithTimeoutInterval(TimeSpan timeout)
             {
                 TimeoutInterval = timeout;
@@ -330,7 +342,8 @@ public BatchEventProcessor Build(bool start)
                 batchEventProcessor.ErrorHandler = ErrorHandler;
                 batchEventProcessor.EventDispatcher = EventDispatcher;
                 batchEventProcessor.EventQueue = EventQueue;
-                
+                batchEventProcessor.NotificationCenter = NotificationCenter;
+
                 batchEventProcessor.BatchSize = BatchSize ?? BatchEventProcessor.DEFAULT_BATCH_SIZE;
                 batchEventProcessor.FlushInterval = FlushInterval ?? BatchEventProcessor.DEFAULT_FLUSH_INTERVAL;
                 batchEventProcessor.TimeoutInterval = TimeoutInterval ?? BatchEventProcessor.DEFAULT_TIMEOUT_INTERVAL;

OptimizelySDK/Notifications/NotificationCenter.cs

@@ -36,7 +36,8 @@ public enum NotificationType
             Activate,   // Activate called.
             Track,      // Track called.
             Decision,    // A decision is made in the system. i.e. user activation, feature access or feature-variable value retrieval.
-            OptimizelyConfigUpdate // When datafile is updated using HttpProjectConfigManager.
+            OptimizelyConfigUpdate, // When datafile is updated using HttpProjectConfigManager.
+            LogEvent    // LogEvent notification sends on flushing batch-event. // When datafile is updated using HttpProjectConfigManager.
         };
 
         /// <summary>
@@ -76,6 +77,12 @@ public delegate void TrackCallback(string eventKey, string userId, UserAttribute
         /// </summary>
         public delegate void OptimizelyConfigUpdateCallback();
 
+        /// <summary>
+        /// Delegate for batch-event flushing.
+        /// </summary>
+        /// <param name="logEvent">The log event</param>
+        public delegate void LogEventCallback(LogEvent logEvent);
+
         private ILogger Logger;
 
         // Notification Id represeting number of notifications.
@@ -158,6 +165,13 @@ public int AddNotification(NotificationType notificationType, DecisionCallback d
             return AddNotification(notificationType, (object)decisionCallback);
         }
 
+        /// <summary>
+        /// Add a notification callback of config-update type to the notification center.
+        /// </summary>
+        /// <param name="notificationType">Notification type</param>
+        /// <param name="optimizelyConfigUpdate">Callback function to call when event gets triggered</param>
+        /// <returns>0 for invalid notification type, -1 for adding existing notification
+        /// or the notification id of newly added notification.</returns>
         public int AddNotification(NotificationType notificationType, OptimizelyConfigUpdateCallback optimizelyConfigUpdate)
         {
             if (!IsNotificationTypeValid(notificationType, NotificationType.OptimizelyConfigUpdate))
@@ -166,6 +180,21 @@ public int AddNotification(NotificationType notificationType, OptimizelyConfigUp
             return AddNotification(notificationType, (object)optimizelyConfigUpdate);
         }
 
+        /// <summary>
+        /// Add a notification callback of logEvent type to the notification center.
+        /// </summary>
+        /// <param name="notificationType">Notification type</param>
+        /// <param name="logEventCallback">Callback function to call when event gets triggered</param>
+        /// <returns>0 for invalid notification type, -1 for adding existing notification
+        /// or the notification id of newly added notification.</returns>
+        public int AddNotification(NotificationType notificationType, LogEventCallback logEventCallback)
+        {
+            if (!IsNotificationTypeValid(notificationType, NotificationType.LogEvent))
+                return 0;
+
+            return AddNotification(notificationType, (object)logEventCallback);
+        }
+
         /// <summary>
         /// Validate notification type.
         /// </summary>