Feature/health tracking (#4)

* Health tracking

* Added Clickstream Health Tracking

* Added verbosity level for health tracking

* Added tracker DTO and handle verbosity level

* Added Tracker.md file

* Minor code changes and resolve PR comments

* Fixed PR comments

* Skip table migration

* Improvements in Health tracking.

* Fixed PR suggestions.

* Minor fix

* Added comments

Clickstream.podspec

@@ -30,5 +30,15 @@ Pod::Spec.new do |s|
   s.dependency    "ReachabilitySwift"
   s.dependency    "GRDB.swift", "5.12.0"
   s.dependency    "Starscream", "4.0.4"
+  s.default_subspec  = 'Core'
+
+  s.subspec 'Core' do |core|
+  end
+
+  s.subspec 'Tracker' do |tracker|
+    tracker.source_files = 'Tracker/**/*.swift'
+    tracker.xcconfig =  { 'SWIFT_ACTIVE_COMPILATION_CONDITIONS' => '$(inherited) TRACKER_ENABLED' }
+  end
+
 
 end

Clickstream.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

Clickstream/Core/Data/Constants/Constants.swift

@@ -42,10 +42,7 @@ enum Constants {
         case dao = "com.clickstream.dao"
         case connectableAccess = "com.clickstream.connectableAccess"
         case atomicAccess = "com.clickstream.atomicAccess"
-    }
-
-    enum CacheIdentifiers: CacheIdentifier {
-        case retry = "com.clickstream.retryCache"
+        case tracker = "com.gojek.clickstream.tracker"
     }
 
     enum EventType: String, Codable {

Clickstream/Core/Domain/Entities/Event.swift

@@ -50,10 +50,6 @@ extension Event: DatabasePersistable {
         }
     }
 
-    static var codableCacheKey: String {
-        return "realTime"
-    }
-
     static var primaryKey: String {
         return "guid"
     }

Clickstream/Core/Interface/ClickStream.swift

@@ -27,9 +27,6 @@ public final class Clickstream {
     /// Temporary handling. Will be replaced by an experimentation module within Clickstream.
     internal static var isInitialisedOnBackgroundQueue: Bool = false
 
-    /// Tells whether the debugMode is enabled or not.
-    internal static var debugMode: Bool = false
-
     /// Holds the constraints for the sdk.
     internal static var constraints: ClickstreamConstraints = ClickstreamConstraints()
 
@@ -89,9 +86,6 @@ public final class Clickstream {
     public func trackEvent(with event: ClickstreamEvent) {
         self.eventProcessor.createEvent(event: event)
     }
-}
-
-extension Clickstream {
 
     /// Initializes an instance of the API with the given configurations.
     /// Returns a new Clickstream instance API object. This allows you to create one instance only.
@@ -145,3 +139,26 @@ extension Clickstream {
         return sharedInstance
     }
 }
+
+// MARK: - Code below here is support for the Clickstream's Health Tracking.
+#if TRACKER_ENABLED
+extension Clickstream {
+
+    /// Initialise tracker
+    /// - Parameters:
+    ///   - configs: ClickstreamHealthConfigurations
+    ///   - commonProperties: CSCommonProperties
+    ///   - dataSource: TrackerDataSource
+    ///   - delegate: TrackerDelegate
+    public func setTracker(configs: ClickstreamHealthConfigurations,
+                           commonProperties: CSCommonProperties,
+                           dataSource: TrackerDataSource,
+                           delegate: TrackerDelegate) {
+        Tracker.initialise(commonProperties: commonProperties, healthTrackingConfigs: configs,dataSource: dataSource, delegate: delegate)
+    }
+
+    public func getTracker() -> Tracker? {
+        return Tracker.sharedInstance
+    }
+}
+#endif

Clickstream/EventProcessor/Core/EventProcessor.swift

@@ -36,6 +36,15 @@ final class DefaultEventProcessor: EventProcessor {
             // Create an Event instance and forward it to the scheduler.
             if let event = checkedSelf.constructEvent(event: event) {
                 checkedSelf.eventWarehouser.store(event)
+                #if TRACKER_ENABLED
+                if Tracker.debugMode {
+                    let healthEvent = HealthAnalysisEvent(eventName: .ClickstreamEventReceived,
+                                                          eventGUID: event.guid)
+                    if event.type != Constants.EventType.instant.rawValue {
+                        Tracker.sharedInstance?.record(event: healthEvent)
+                    }
+                }
+                #endif
             }
         }
     }
@@ -47,17 +56,30 @@ final class DefaultEventProcessor: EventProcessor {
         guard let classification = classifier.getClassification(eventName: type(of: event.message).protoMessageName) else {
             return nil
         }
-
+
+        #if TRACKER_ENABLED
+        if Tracker.debugMode && classification != Constants.EventType.instant.rawValue {
+            var _eventGuid = event.guid
+            if !Tracker.healthTrackingConfigs.dropRateEventName.isEmpty {
+                _eventGuid = event.guid.appending("_\(Tracker.healthTrackingConfigs.dropRateEventName)")
+            } else {
+                _eventGuid = event.guid.appending("_\(typeOfEvent)")
+            }
+            let healthEvent = HealthAnalysisEvent(eventName: .ClickstreamEventReceivedForDropRate, eventGUID: _eventGuid)
+            Tracker.sharedInstance?.record(event: healthEvent)
+        }
+        #endif
+
         do {
             // Constructing the Odpf_Raccoon_Event
             let csEvent = try Odpf_Raccoon_Event.with {
                 $0.eventBytes = try event.message.serializedData()
                 $0.type = typeOfEvent
             }
             return try Event(guid: event.guid,
-                                    timestamp: event.timeStamp,
-                                    type: classification,
-                                    eventProtoData: csEvent.serializedData())
+                             timestamp: event.timeStamp,
+                             type: classification,
+                             eventProtoData: csEvent.serializedData())
         } catch {
             return nil
         }

Clickstream/EventScheduler/Core/EventBatchCreator.swift

@@ -48,8 +48,9 @@ extension DefaultEventBatchCreator {
     func forward(with events: [Event]) -> Bool {
         if canForward {
             let batch = EventBatch(uuid: UUID().uuidString, events: events)
-
             networkBuilder.trackBatch(batch, completion: nil)
+
+            self.trackHealthEvents(batch: batch, events: events)         
             return true
         }
         return false
@@ -69,3 +70,20 @@ extension DefaultEventBatchCreator {
         networkBuilder.isAvailable
     }
 }
+
+// MARK: - Track Clickstream health.
+extension DefaultEventBatchCreator {
+    private func trackHealthEvents(batch: EventBatch, events: [Event]) {
+        #if TRACKER_ENABLED
+        // We are checking only first event's type since batches are created on the basis of evemt priority i.e. realTime, healthEvent etc.
+        if events.first?.type != TrackerConstant.HealthEventType && events.first?.type != Constants.EventType.instant.rawValue {
+            let eventGUIDs = batch.events.map { $0.guid }
+            let eventGUIDString = "\(eventGUIDs.joined(separator: ", "))"
+            let batchCreatedEvent = HealthAnalysisEvent(eventName: .ClickstreamEventBatchCreated,
+                                                        events: eventGUIDString,
+                                                        eventBatchGUID: batch.uuid)
+            Tracker.sharedInstance?.record(event: batchCreatedEvent)
+        }
+        #endif
+    }
+}

Clickstream/EventScheduler/Core/EventBatchProcessor.swift

@@ -80,6 +80,7 @@ final class DefaultEventBatchProcessor: EventBatchProcessor {
             switch stateNotification {
             case .willTerminate, .didEnterBackground:
                 checkedSelf.flushAll()
+                checkedSelf.flushObservabilityEvents()
             case .willResignActive:
                 checkedSelf.stopTimer()
             case .didBecomeActive:
@@ -136,6 +137,15 @@ final class DefaultEventBatchProcessor: EventBatchProcessor {
 
                 if !eventsToBeFlushed.isEmpty {
                     eventBatchCreator.forward(with: eventsToBeFlushed)
+                    #if TRACKER_ENABLED
+                    if Tracker.debugMode {
+                        let eventGUIDs = eventsToBeFlushed.map { $0.guid }
+                        let eventGUIDString = "\(eventGUIDs.joined(separator: ", "))"
+                        let healthAnalysisEvent = HealthAnalysisEvent(eventName: .ClickstreamFlushOnBackground,
+                                                                      events: eventGUIDString)
+                        Tracker.sharedInstance?.record(event: healthAnalysisEvent)
+                    }
+                    #endif
                 }
             }
         }
@@ -156,6 +166,7 @@ final class DefaultEventBatchProcessor: EventBatchProcessor {
            let isConnected = object[Constants.Strings.didConnect] as? Bool,
            isConnected == true {
             flushAll()
+            flushObservabilityEvents()
         }
     }
 
@@ -170,3 +181,14 @@ final class DefaultEventBatchProcessor: EventBatchProcessor {
         eventBatchCreator.stop()
     }
 }
+
+private extension DefaultEventBatchProcessor {
+
+    func flushObservabilityEvents() {        
+        #if TRACKER_ENABLED
+        if eventBatchCreator.canForward, let events = Tracker.sharedInstance?.sendHealthEventsToInternalParty()(), !events.isEmpty {
+            eventBatchCreator.forward(with: events)
+        }
+        #endif
+    }
+}

Clickstream/EventScheduler/Core/EventWarehouser.swift

@@ -53,6 +53,14 @@ extension DefaultEventWarehouser {
             } else {
                 checkedSelf.batchRegulator.observe(event)
                 checkedSelf.persistence.insert(event)
+
+                #if TRACKER_ENABLED
+                let healthEvent = HealthAnalysisEvent(eventName: .ClickstreamEventCached,
+                                                      eventGUID: event.guid)
+                if event.type != Constants.EventType.instant.rawValue {
+                    Tracker.sharedInstance?.record(event: healthEvent)
+                }
+                #endif
             }
         }
     }

Clickstream/EventScheduler/Domain/Protocols/DatabasePersistable.swift

@@ -9,4 +9,4 @@
 import GRDB
 
 /// Any object conforming to this protocol can be persisted on the db.
-protocol DatabasePersistable: FetchableRecord, PersistableRecord, TableDefinable, FileStorable {}
+protocol DatabasePersistable: FetchableRecord, PersistableRecord, TableDefinable {}

Clickstream/NetworkManager/Core/NetworkBuilder.swift

@@ -64,6 +64,9 @@ extension DefaultNetworkBuilder {
 
                 if eventBatch.events.first?.type == Constants.EventType.instant.rawValue {
                     eventRequest.eventType = .instant
+                } else {
+                    checkedSelf.trackHealthEvents(eventBatch: eventBatch,
+                                                          eventBatchData: data)
                 }
 
                 checkedSelf.retryMech.trackBatch(with: eventRequest)
@@ -85,3 +88,19 @@ extension DefaultNetworkBuilder {
         }
     }
 }
+
+// MARK: - Track Clickstream health.
+extension DefaultNetworkBuilder {
+    private func trackHealthEvents(eventBatch: EventBatch, eventBatchData: Data) {
+        #if TRACKER_ENABLED
+        guard Tracker.debugMode else { return }
+        let eventGUIDs: [String] = eventBatch.events.compactMap { $0.guid }
+        let eventGUIDsString = "\(eventGUIDs.joined(separator: ", "))"
+
+        let healthEvent = HealthAnalysisEvent(eventName: .ClickstreamBatchSent,
+                                              events: eventGUIDsString,
+                                              eventBatchGUID: eventBatch.uuid)
+        Tracker.sharedInstance?.record(event: healthEvent)
+        #endif
+    }
+}