Merge pull request #3098 from DataDog/gonzalezreal/PANA-8393/generic-embedded-content-view-tree

[PANA-8393] Support cross-platform embedded content in view-tree recording

Author: gonzalezreal

Datadog/Datadog.xcodeproj/project.pbxproj

@@ -16,6 +16,9 @@ public enum FeatureMessage {
     /// Represent a Browser SDK event sent through the JS bridge.
     case webview(WebViewMessage)
 
+    /// Session Replay records produced by an embedded renderer.
+    case embeddedContent(EmbeddedContentMessage)
+
     /// A core context message.
     ///
     /// The core will send updated context through the bus. Do not send new context values

DatadogInternal/Sources/MessageBus/FeatureMessage.swift

@@ -0,0 +1,57 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+import Foundation
+
+/// Session Replay data produced by an embedded renderer.
+public enum EmbeddedContentMessage {
+    /// A batch of serialized Session Replay records.
+    public struct RecordBatch {
+        /// A single serialized Session Replay record.
+        public typealias Record = [String: Any]
+
+        /// The serialized Session Replay records.
+        public let records: [Record]
+
+        /// The identifier shared with the native view hosting the embedded content.
+        public let slotID: String
+
+        /// The RUM view identifier associated with the records.
+        public let viewID: String
+
+        /// Creates a batch of embedded Session Replay records.
+        public init(records: [Record], slotID: String, viewID: String) {
+            self.records = records
+            self.slotID = slotID
+            self.viewID = viewID
+        }
+    }
+
+    /// An encoded resource referenced by embedded Session Replay records.
+    public struct Resource {
+        /// The content identifier referenced by Session Replay records.
+        public let identifier: String
+
+        /// The encoded resource bytes.
+        public let data: Data
+
+        /// The resource media type.
+        public let mimeType: String
+
+        /// Creates an embedded Session Replay resource.
+        public init(identifier: String, data: Data, mimeType: String) {
+            self.identifier = identifier
+            self.data = data
+            self.mimeType = mimeType
+        }
+    }
+
+    /// A batch of records associated with an embedded native container.
+    case records(RecordBatch)
+
+    /// A resource referenced by embedded Session Replay records.
+    case resource(Resource)
+}

DatadogInternal/Sources/Models/SessionReplay/EmbeddedContentMessage.swift

@@ -0,0 +1,33 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+#if os(iOS)
+import UIKit
+
+private var sessionReplaySlotIDKey: UInt8 = 0
+
+extension UIView: DatadogExtended {}
+
+@_spi(Internal)
+public extension DatadogExtension where ExtendedType: UIView {
+    /// Identifies this view as a host slot for embedded Session Replay content.
+    ///
+    /// The slot ID is supplied by the embedding SDK and is independent of the view's wireframe ID.
+    var sessionReplaySlotID: String? {
+        get {
+            objc_getAssociatedObject(type, &sessionReplaySlotIDKey) as? String
+        }
+        nonmutating set {
+            objc_setAssociatedObject(
+                type,
+                &sessionReplaySlotIDKey,
+                newValue,
+                .OBJC_ASSOCIATION_COPY_NONATOMIC
+            )
+        }
+    }
+}
+#endif

DatadogInternal/Sources/Models/SessionReplay/UIView+SessionReplaySlotID.swift

@@ -0,0 +1,60 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+#if os(iOS)
+import TestUtilities
+import Testing
+import UIKit
+
+@_spi(Internal)
+@testable import DatadogInternal
+
+@Suite(.datadogTesting)
+@MainActor
+struct UIViewSessionReplaySlotIDTests {
+    @available(iOS 13.0, *)
+    @Test
+    func slotIDIsNilByDefault() {
+        // given
+        let view = UIView()
+
+        // when
+        let slotID = view.dd.sessionReplaySlotID
+
+        // then
+        #expect(slotID == nil)
+    }
+
+    @available(iOS 13.0, *)
+    @Test
+    func slotIDIsStoredPerView() {
+        // given
+        let view = UIView()
+        let otherView = UIView()
+
+        // when
+        view.dd.sessionReplaySlotID = "renderer-slot"
+
+        // then
+        #expect(view.dd.sessionReplaySlotID == "renderer-slot")
+        #expect(otherView.dd.sessionReplaySlotID == nil)
+    }
+
+    @available(iOS 13.0, *)
+    @Test
+    func settingSlotIDToNilClearsIt() {
+        // given
+        let view = UIView()
+        view.dd.sessionReplaySlotID = "renderer-slot"
+
+        // when
+        view.dd.sessionReplaySlotID = nil
+
+        // then
+        #expect(view.dd.sessionReplaySlotID == nil)
+    }
+}
+#endif

DatadogInternal/Tests/Models/UIViewSessionReplaySlotIDTests.swift

@@ -0,0 +1,86 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+#if os(iOS)
+import Foundation
+import DatadogInternal
+
+internal struct EmbeddedContentReceiver: FeatureMessageReceiver {
+    internal struct EmbeddedRecord: Encodable {
+        /// The native RUM application ID associated with the records.
+        let applicationID: String
+        /// The native RUM session ID associated with the records.
+        let sessionID: String
+        /// The embedded RUM view ID associated with the records.
+        let viewID: String
+        /// The embedded Session Replay records.
+        let records: [AnyEncodable]
+    }
+
+    /// Session Replay feature scope.
+    let scope: FeatureScope
+
+    /// Shared writer for native and embedded Session Replay resources.
+    let resourcesWriter: ResourcesWriting
+
+    /// Shared publisher for native and embedded Session Replay record counts.
+    let srContextPublisher: SRContextPublisher
+
+    func receive(message: FeatureMessage, from core: DatadogCoreProtocol) -> Bool {
+        guard case let .embeddedContent(embeddedContentMessage) = message else {
+            return false
+        }
+
+        scope.eventWriteContext { context, writer in
+            guard
+                let rumContext = context.additionalContext(ofType: RUMCoreContext.self),
+                rumContext.sessionSampler.isSampled
+            else {
+                return
+            }
+
+            switch embeddedContentMessage {
+            case .records(let batch):
+                guard !batch.records.isEmpty else {
+                    return
+                }
+
+                let records = batch.records.map { record in
+                    var record = record
+                    record["slotId"] = batch.slotID
+                    return AnyEncodable(record)
+                }
+
+                writer.write(
+                    value: EmbeddedRecord(
+                        applicationID: rumContext.applicationID,
+                        sessionID: rumContext.sessionID,
+                        viewID: batch.viewID,
+                        records: records
+                    )
+                )
+                srContextPublisher.incrementRecordCount(
+                    by: Int64(records.count),
+                    forViewID: batch.viewID
+                )
+            case .resource(let resource):
+                resourcesWriter.write(
+                    resources: [
+                        EnrichedResource(
+                            identifier: resource.identifier,
+                            data: resource.data,
+                            mimeType: resource.mimeType,
+                            context: .init(rumContext.applicationID)
+                        )
+                    ]
+                )
+            }
+        }
+
+        return true
+    }
+}
+#endif

DatadogSessionReplay/Sources/Feature/EmbeddedContentReceiver.swift

@@ -14,15 +14,27 @@ internal struct RecordingComponents {
 
     init(
         core: DatadogCoreProtocol,
-        configuration: SessionReplay.Configuration
+        configuration: SessionReplay.Configuration,
+        resourcesWriter: any ResourcesWriting,
+        srContextPublisher: SRContextPublisher
     ) throws {
         if #available(iOS 13.0, tvOS 13.0, *), configuration.featureFlags[.layerTreeRecording] {
             // This is purely defensive, as `SessionReplay.enable()` initializes on the main thread
             self = try runOnMainThreadSync {
-                try .layerTreeRecordingComponents(core: core, configuration: configuration)
+                try .layerTreeRecordingComponents(
+                    core: core,
+                    configuration: configuration,
+                    resourcesWriter: resourcesWriter,
+                    srContextPublisher: srContextPublisher
+                )
             }
         } else {
-            self = try .viewTreeRecordingComponents(core: core, configuration: configuration)
+            self = try .viewTreeRecordingComponents(
+                core: core,
+                configuration: configuration,
+                resourcesWriter: resourcesWriter,
+                srContextPublisher: srContextPublisher
+            )
         }
     }
 
@@ -36,7 +48,9 @@ internal struct RecordingComponents {
 
     private static func viewTreeRecordingComponents(
         core: DatadogCoreProtocol,
-        configuration: SessionReplay.Configuration
+        configuration: SessionReplay.Configuration,
+        resourcesWriter: any ResourcesWriting,
+        srContextPublisher: SRContextPublisher
     ) throws -> Self {
         let processorsQueue = BackgroundAsyncQueue(label: "com.datadoghq.session-replay.processors", qos: .utility)
         // The telemetry queue targets the processors queue with a lower qos.
@@ -53,14 +67,14 @@ internal struct RecordingComponents {
 
         let resourceProcessor = ResourceProcessor(
             queue: processorsQueue,
-            resourcesWriter: ResourcesWriter(scope: core.scope(for: ResourcesFeature.self))
+            resourcesWriter: resourcesWriter
         )
 
         let snapshotProcessor = SnapshotProcessor(
             queue: processorsQueue,
             recordWriter: RecordWriter(core: core),
             resourceProcessor: resourceProcessor,
-            srContextPublisher: SRContextPublisher(core: core),
+            srContextPublisher: srContextPublisher,
             telemetry: telemetry
         )
 
@@ -79,7 +93,7 @@ internal struct RecordingComponents {
             imagePrivacy: configuration.imagePrivacyLevel,
             touchPrivacy: configuration.touchPrivacyLevel,
             rumContextObserver: contextReceiver,
-            srContextPublisher: SRContextPublisher(core: core),
+            srContextPublisher: srContextPublisher,
             recorder: recorder,
             replaySampleRate: configuration.debugSDK ? 100 : configuration.replaySampleRate,
             telemetry: telemetry,
@@ -96,7 +110,9 @@ internal struct RecordingComponents {
     @MainActor
     private static func layerTreeRecordingComponents(
         core: DatadogCoreProtocol,
-        configuration: SessionReplay.Configuration
+        configuration: SessionReplay.Configuration,
+        resourcesWriter: any ResourcesWriting,
+        srContextPublisher: SRContextPublisher
     ) throws -> Self {
         let processorsQueue = BackgroundAsyncQueue(label: "com.datadoghq.session-replay.processors", qos: .utility)
         // The telemetry queue targets the processors queue with a lower qos.
@@ -111,13 +127,13 @@ internal struct RecordingComponents {
         )
         let resourceProcessor = ResourceProcessor(
             queue: processorsQueue,
-            resourcesWriter: ResourcesWriter(scope: core.scope(for: ResourcesFeature.self))
+            resourcesWriter: resourcesWriter
         )
         let snapshotProcessor = LayerSnapshotProcessor(
             queue: processorsQueue,
             recordWriter: RecordWriter(core: core),
             resourceProcessor: resourceProcessor,
-            replayContextPublisher: SRContextPublisher(core: core),
+            replayContextPublisher: srContextPublisher,
             telemetry: telemetry
         )
 
@@ -143,7 +159,7 @@ internal struct RecordingComponents {
             textAndInputPrivacy: configuration.textAndInputPrivacyLevel,
             imagePrivacy: configuration.imagePrivacyLevel,
             touchPrivacy: configuration.touchPrivacyLevel,
-            srContextPublisher: SRContextPublisher(core: core),
+            srContextPublisher: srContextPublisher,
             layerRecording: layerRecorder,
             replaySampleRate: configuration.debugSDK ? 100 : configuration.replaySampleRate,
             telemetry: telemetry,

DatadogSessionReplay/Sources/Feature/RecordingComponents.swift

@@ -11,6 +11,7 @@ import DatadogInternal
 /// Publisher that sets Session Replay context for being utilized by other Features.
 internal class SRContextPublisher {
     private weak var core: DatadogCoreProtocol?
+    private var recordCounts: [String: Int64] = [:]
 
     init(core: DatadogCoreProtocol) {
         self.core = core
@@ -21,9 +22,18 @@ internal class SRContextPublisher {
         core?.set(context: SessionReplayCoreContext.HasReplay(value: value))
     }
 
-    /// Notifies other Features on the state of Session Replay records count.
-    func setRecordsCountByViewID(_ value: [String: Int64]) {
-        core?.set(context: SessionReplayCoreContext.RecordsCount(value: value))
+    /// Increments the Session Replay record count for a RUM view.
+    func incrementRecordCount(by count: Int64, forViewID viewID: String) {
+        guard count > 0 else {
+            return
+        }
+
+        core?.set(
+            context: {
+                self.recordCounts[viewID, default: 0] += count
+                return SessionReplayCoreContext.RecordsCount(value: self.recordCounts)
+            }
+        )
     }
 }
 #endif