more fixups.

Author: bsneed

Sources/AnalyticsLive/LivePlugins/AnalyticsJS.swift

@@ -1,6 +1,6 @@
 //
 //  File.swift
-//  
+//
 //
 //  Created by Brandon Sneed on 5/5/22.
 //
@@ -14,8 +14,6 @@ public class AnalyticsJS: JSExport {
 
     internal weak var analytics: Analytics?
 
-    internal var addedPlugins = [(String?, LivePlugin)]()
-    
     internal lazy var currentLivePluginVersion: String? = {
         return LivePlugins.currentLivePluginVersion()
     }()
@@ -36,9 +34,13 @@ public class AnalyticsJS: JSExport {
         Self.existingInstances.removeAll(where: { $0 === self.analytics })
     }
 
+    
     static func insertOrigin(event: RawEvent?, data: [String: Any]) -> RawEvent? {
         guard var working = event else { return event }
-        if let newContext = try? working.context?.add(value: data, forKey: "__eventOrigin") {
+        if let newContext = try? working.context?.add(
+            value: data,
+            forKey: "__eventOrigin"
+        ) {
             working.context = newContext
         }
         return working
@@ -51,45 +53,76 @@ public class AnalyticsJS: JSExport {
         ])
     }
 
+    private func contextEnrichment(with context: [String: Any]?) -> EnrichmentClosure {
+        return { event in
+            guard var working = event, let context = context else {
+                return event
+            }
+            
+            // Get existing context as dictionary and merge with new context
+            var mergedContext = working.context?.dictionaryValue ?? [:]
+            mergedContext.merge(context) { _, new in new }
+            
+            do {
+                working.context = try JSON(mergedContext)
+            } catch {
+                // If JSON creation fails, return original event
+                return event
+            }
+            return working
+        }
+    }
+    
+    private func enrichments(with context: [String: Any]?) -> [EnrichmentClosure] {
+        var enrichments = [originMarkerEnrichment]
+        if let context = context {
+            enrichments.append(contextEnrichment(with: context))
+        }
+        return enrichments
+    }
+    
     internal func setupExports() {
         exportProperty(named: "traits") { [weak self] in
-            guard let self else { return nil }
-            let traits: [String: Any]? = analytics?.traits()
+            guard let self, let analytics = self.analytics else { return nil }
+            let traits: [String: Any]? = analytics.traits()
             return traits as? JSConvertible
         }
 
         exportProperty(named: "userId") { [weak self] in
-            guard let self else { return nil }
-            return analytics?.userId
+            return self?.analytics?.userId
         }
 
         exportProperty(named: "anonymousId") { [weak self] in
-            guard let self else { return nil }
-            return analytics?.anonymousId
+            return self?.analytics?.anonymousId
         }
 
         exportMethod(named: "track") { [weak self] in self?.track(args: $0) }
-        exportMethod(named: "identify") { [weak self] in self?.identify(args: $0) }
+        exportMethod(named: "identify") {
+            [weak self] in self?.identify(args: $0)
+        }
         exportMethod(named: "screen") { [weak self] in self?.screen(args: $0) }
         exportMethod(named: "group") { [weak self] in self?.group(args: $0) }
-        exportMethod(named: "alias") { [weak self] in self?.alias(args: $0) }
         exportMethod(named: "add") { [weak self] in self?.add(args: $0) }
         exportMethod(named: "flush") { [weak self] in self?.flush(args: $0) }
         exportMethod(named: "reset") { [weak self] in self?.reset(args: $0) }
-        exportMethod(named: "removeLivePlugins") { [weak self] in self?.removeLivePlugins(args: $0) }
     }
 
     public override func construct(args: [JSConvertible?]) {
         if let writeKey = args.typed(as: String.self, index: 0) {
-            let existing = Self.existingInstances.first(where: { $0.writeKey == writeKey })
+            let existing = Self.existingInstances.first(
+                where: { $0.writeKey == writeKey
+                })
             if let existing {
                 self.analytics = existing
                 return
             } else {
                 // we do some work on user-created instances to avoid multiple instances of the same write key
                 // by just attaching whatever existing instance that might exist with that write key.
-                let createdAnalytics = Analytics(configuration: Configuration(writeKey: writeKey)
-                    .trackApplicationLifecycleEvents(false)
+                let createdAnalytics = Analytics(
+                    configuration: Configuration(
+                        writeKey: writeKey
+                    )
+                    .setTrackedApplicationLifecycleEvents(.none)
                 )
                 Self.existingInstances.append(createdAnalytics)
                 self.analytics = createdAnalytics
@@ -99,113 +132,109 @@ public class AnalyticsJS: JSExport {
 
     public func track(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
-        guard let name = args.typed(as: String.self, index: 0) else { return nil }
-        let properties = args.typed(as: Dictionary.self, index: 1)
-        
-        let addEventOrigin: EnrichmentClosure = { [weak self] event in
-            return Self.insertOrigin(event: event, data: [
-                "type": "signals",
-                "version": self?.currentLivePluginVersion ?? ""
-            ])
+        guard let name = args.typed(as: String.self, index: 0) else {
+            return nil
         }
+        let properties = args.typed(as: Dictionary.self, index: 1)
+        let context = args.typed(as: Dictionary.self, index: 2)
 
-        analytics.track(name: name, properties: properties, enrichments: [addEventOrigin])
+        analytics
+            .track(
+                name: name,
+                properties: properties,
+                enrichments: enrichments(with: context)
+            )
         return nil
     }
 
     public func identify(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
-        guard let userId = args.typed(as: String.self, index: 0) else { return nil }
+        guard let userId = args.typed(as: String.self, index: 0) else {
+            return nil
+        }
         let traits = args.typed(as: Dictionary.self, index: 1)
-        analytics.identify(userId: userId, traits: traits, enrichments: [originMarkerEnrichment])
+        let context = args.typed(as: Dictionary.self, index: 2)
+        analytics
+            .identify(
+                userId: userId,
+                traits: traits,
+                enrichments: enrichments(with: context)
+            )
         return nil
     }
 
     public func screen(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
-        guard let title = args.typed(as: String.self, index: 0) else { return nil }
+        guard let title = args.typed(as: String.self, index: 0) else {
+            return nil
+        }
         let category = args.typed(as: String.self, index: 1)
         let properties = args.typed(as: Dictionary.self, index: 2)
-        analytics.screen(title: title, category: category, properties: properties, enrichments: [originMarkerEnrichment])
+        let context = args.typed(as: Dictionary.self, index: 3)
+        analytics
+            .screen(
+                title: title,
+                category: category,
+                properties: properties,
+                enrichments: enrichments(with: context)
+            )
         return nil
+        
     }
 
     public func group(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
-        guard let groupId = args.typed(as: String.self, index: 0) else { return nil }
+        guard let groupId = args.typed(as: String.self, index: 0) else {
+            return nil
+        }
         let traits = args.typed(as: Dictionary.self, index: 1)
-        analytics.group(groupId: groupId, traits: traits, enrichments: [originMarkerEnrichment])
-        return nil
-    }
-    
-    public func alias(args: [JSConvertible?]) -> JSConvertible? {
-        guard let analytics else { return nil }
-        guard let newId = args.typed(as: String.self, index: 0) else { return nil }
-        analytics.alias(newId: newId, enrichments: [originMarkerEnrichment])
+        let context = args.typed(as: Dictionary.self, index: 2)
+        analytics
+            .group(
+                groupId: groupId,
+                traits: traits,
+                enrichments: enrichments(with: context)
+            )
         return nil
+        
     }
 
     public func flush(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
         analytics.flush()
         return nil
+    
     }
 
     public func reset(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
         analytics.reset()
         return nil
+        
     }
 
     public func add(args: [JSConvertible?]) -> JSConvertible? {
-        var result = false
-        
-        guard let analytics else { return result }
-        guard let plugin = args.typed(as: JSClass.self, index: 0) else { return result }
+        guard let analytics else { return nil }
+        guard let plugin = args.typed(as: JSClass.self, index: 0) else {
+            return false
+        }
 
         let type = plugin["type"]?.typed(as: Int.self)
         let destination = plugin["destination"]?.typed(as: String.self)
 
-        guard let type = type else { return result }
+        guard let type = type else { return false }
+        guard let pluginType = PluginType(rawValue: type) else { return false }
 
-        guard let pluginType = PluginType(rawValue: type) else { return result }
         let edgeFn = LivePlugin(jsPlugin: plugin, type: pluginType)
 
         if let dest = destination {
             // we have a destination specified, so add it there
-            if let d = analytics.find(key: dest) {
-                DispatchQueue.main.async {
-                    _ = d.add(plugin: edgeFn)
-                }
-                result = true
-                self.addedPlugins.append((dest, edgeFn))
-            }
+            guard let d = analytics.find(key: dest) else { return false }
+            _ = d.add(plugin: edgeFn)
+            return true
         } else {
-            DispatchQueue.main.async {
-                _ = analytics.add(plugin: edgeFn)
-            }
-            result = true
-            self.addedPlugins.append((nil, edgeFn))
+            _ = analytics.add(plugin: edgeFn)
+            return true
         }
-        return result
-    }
-    
-    public func removeLivePlugins(args: [JSConvertible?]) -> JSConvertible? {
-        guard let analytics else { return nil }
-        
-        for tuple in self.addedPlugins {
-            let (dest, p) = tuple
-            if let dst = dest {
-                // Remove from destination
-                if let d = analytics.find(key: dst) {
-                    d.remove(plugin: p)
-                }
-            } else {
-                // Remove from main timeline
-                analytics.remove(plugin: p)
-            }
-        }
-        self.addedPlugins.removeAll()
-        return nil
     }
 }

Sources/AnalyticsLive/Signals/AutoTracking/Networking/SignalsNetworkTracking.swift

@@ -38,6 +38,7 @@ public class SignalsNetworkProtocol: URLProtocol, URLSessionDataDelegate {
 
     internal var session: URLSession? = nil
     internal var sessionTask: URLSessionDataTask? = nil
+    internal let requestId: String = UUID().uuidString
     @Atomic internal var receivedData: Data? = nil
     @Atomic internal var response: URLResponse? = nil
 
@@ -73,7 +74,18 @@ public class SignalsNetworkProtocol: URLProtocol, URLSessionDataDelegate {
         sessionTask?.resume()
 
         // emit our request signal since it's about to go out.
-        emit(action: .request)
+        let contentType = newRequest.value(forHTTPHeaderField: "Content-Type")
+        let data = NetworkSignal.NetworkData(
+            action: .request,
+            url: newRequest.url,
+            body: deserialize(contentType: contentType, data: newRequest.httpBody),
+            contentType: contentType,
+            method: newRequest.httpMethod,
+            status: nil,
+            requestId: requestId
+        )
+        let signal = NetworkSignal(data: data)
+        Signals.shared.emit(signal: signal, source: .autoNetwork)
     }
 
     override public func stopLoading() {
@@ -104,7 +116,20 @@ public class SignalsNetworkProtocol: URLProtocol, URLSessionDataDelegate {
         }
 
         client?.urlProtocolDidFinishLoading(self)
-        emit(action: .response)
+        
+        let httpResponse = self.response as? HTTPURLResponse
+        let contentType = httpResponse?.value(forHTTPHeaderField: "Content-Type")
+        let data = NetworkSignal.NetworkData(
+            action: .response,
+            url: request.url,
+            body: deserialize(contentType: contentType, data: request.httpBody),
+            contentType: contentType,
+            method: request.httpMethod,
+            status: httpResponse?.statusCode,
+            requestId: requestId
+        )
+        let signal = NetworkSignal(data: data)
+        Signals.shared.emit(signal: signal, source: .autoNetwork)
     }
 
 }
@@ -137,7 +162,7 @@ extension SignalsNetworkProtocol {
 }
 
 extension SignalsNetworkProtocol {
-    func deserialize(contentType: String?) -> [String: Any]? {
+    func deserialize(contentType: String?, data: Data?) -> [String: Any]? {
         guard let contentType else { return nil }
         let parts = contentType.components(separatedBy: ";")
         // strip any params off .. we can't really evaluate them that well
@@ -146,18 +171,6 @@ extension SignalsNetworkProtocol {
         let deserializer = Self.deserializers[ct] ?? Self.deserializers[contentType] ?? Self.textPlain
         return deserializer(receivedData)
     }
-    
-    func emit(action: NetworkSignal.NetworkAction) {
-        guard let url = request.url else { return }
-        let httpResponse = self.response as? HTTPURLResponse
-        let statusCode = httpResponse?.statusCode
-        
-        let contentType = httpResponse?.value(forHTTPHeaderField: "Content-Type")
-        let data = deserialize(contentType: contentType)
-        
-        let s = NetworkSignal(action: action, url: url, statusCode: statusCode, data: data)
-        Signals.shared.emit(signal: s, source: .autoNetwork)
-    }
 }
 
 final class SignalsAuthenticationChallengeSender: NSObject, URLAuthenticationChallengeSender {