RUM-13949 wire TimeseriesSessionCollector into RUM session and configuration

Author: barboraplasovska

DatadogRUM/Sources/Feature/RUMFeature.swift

@@ -184,7 +184,16 @@ internal final class RUMFeature: DatadogRemoteFeature {
                     predicate: nextViewActionPredicate
                 )
             },
-            sessionType: configuration.sessionTypeOverride.flatMap { RUMSessionType(rawValue: $0) }
+            sessionType: configuration.sessionTypeOverride.flatMap { RUMSessionType(rawValue: $0) },
+            timeseriesCollector: {
+                guard configuration.enableTimeseries, let vitalsReaders = configuration.vitalsUpdateFrequency.map({
+                    VitalsReaders(frequency: $0.timeInterval, telemetry: core.telemetry)
+                }) else { return nil }
+                return TimeseriesSessionCollector(
+                    memoryReader: vitalsReaders.memory,
+                    featureScope: featureScope
+                )
+            }()
         )
 
         self.monitor = Monitor(

DatadogRUM/Sources/RUMConfiguration.swift

@@ -326,6 +326,14 @@ extension RUM {
         /// Default: `false`.
         public var collectAccessibility: Bool
 
+        /// Enables collection of memory and CPU timeseries events.
+        ///
+        /// When enabled, memory footprint and CPU usage are sampled every second and uploaded as
+        /// timeseries events scoped to the RUM session. Requires `vitalsUpdateFrequency` to be set.
+        ///
+        /// Default: `false`.
+        public var enableTimeseries: Bool
+
         /// Feature flags to preview features in RUM.
         public var featureFlags: FeatureFlags
 
@@ -534,6 +542,7 @@ extension RUM.Configuration {
     ///   - trackSlowFrames: Enables the collection of slow frames (view hitches). Default: `true`.
     ///   - telemetrySampleRate: The sampling rate for SDK internal telemetry utilized by Datadog. Must be a value between `0` and `100`. Default: `20`.
     ///   - collectAccessibility: Determines whether accessibility data should be collected and included in RUM view events. Default: `false`.
+    ///   - enableTimeseries: Enables collection of memory and CPU timeseries events. Default: `false`.
     ///   - featureFlags: Experimental feature flags.
     /// 
     /// - Note: On watchOS, automatic UIKit and SwiftUI view/action tracking is unavailable. The predicate parameters will be ignored.
@@ -569,6 +578,7 @@ extension RUM.Configuration {
         trackSlowFrames: Bool = true,
         telemetrySampleRate: SampleRate = 20,
         collectAccessibility: Bool = false,
+        enableTimeseries: Bool = false,
         featureFlags: FeatureFlags = .defaults
     ) {
         self.applicationID = applicationID
@@ -598,6 +608,7 @@ extension RUM.Configuration {
         self.trackSlowFrames = trackSlowFrames
         self.telemetrySampleRate = telemetrySampleRate
         self.collectAccessibility = collectAccessibility
+        self.enableTimeseries = enableTimeseries
         self.featureFlags = featureFlags
     }
     #else
@@ -624,6 +635,7 @@ extension RUM.Configuration {
         trackSlowFrames: Bool = true,
         telemetrySampleRate: SampleRate = 20,
         collectAccessibility: Bool = false,
+        enableTimeseries: Bool = false,
         featureFlags: FeatureFlags = .defaults
     ) {
         self.applicationID = applicationID
@@ -648,6 +660,7 @@ extension RUM.Configuration {
         self.trackSlowFrames = trackSlowFrames
         self.telemetrySampleRate = telemetrySampleRate
         self.collectAccessibility = collectAccessibility
+        self.enableTimeseries = enableTimeseries
         self.featureFlags = featureFlags
     }
     #endif

DatadogRUM/Sources/RUMMonitor/Scopes/RUMScopeDependencies.swift

@@ -46,6 +46,7 @@ internal struct RUMScopeDependencies {
     let firstFrameReader: RenderLoopReader
     let viewHitchesReaderFactory: () -> (RenderLoopReader & ViewHitchesModel)?
     let vitalsReaders: VitalsReaders?
+    let timeseriesCollector: TimeseriesCollecting?
     let accessibilityReader: AccessibilityReading?
     let onSessionStart: RUM.SessionListener?
     let viewCache: ViewCache
@@ -98,7 +99,8 @@ internal struct RUMScopeDependencies {
         watchdogTermination: WatchdogTerminationMonitor?,
         networkSettledMetricFactory: @escaping (Date, String) -> TNSMetricTracking,
         interactionToNextViewMetricFactory: @escaping () -> INVMetricTracking?,
-        sessionType: RUMSessionType?
+        sessionType: RUMSessionType?,
+        timeseriesCollector: TimeseriesCollecting? = nil
     ) {
         self.featureScope = featureScope
         self.rumApplicationID = rumApplicationID
@@ -117,6 +119,7 @@ internal struct RUMScopeDependencies {
         self.firstFrameReader = firstFrameReader
         self.viewHitchesReaderFactory = viewHitchesReaderFactory
         self.vitalsReaders = vitalsReaders
+        self.timeseriesCollector = timeseriesCollector
         self.accessibilityReader = accessibilityReader
         self.onSessionStart = onSessionStart
         self.viewCache = viewCache

DatadogRUM/Sources/RUMMonitor/Scopes/RUMSessionScope.swift

@@ -94,7 +94,9 @@ internal class RUMSessionScope: RUMScope, RUMContextProvider {
     /// Indicates whether the "ApplicationLaunch" view was active when the app entered the background.
     private var hadApplicationLaunchViewWhenEnteringBackground: Bool? = nil
     /// The reason why this session has ended or `nil` if it is still active.
-    private(set) var endReason: EndReason?
+    private(set) var endReason: EndReason? {
+        didSet { if endReason != nil { dependencies.timeseriesCollector?.stop() } }
+    }
 
     /// Counter to track the index of views in this session. Starts at 0 for the first view.
     private var nextViewIndex: Int = 0
@@ -161,6 +163,12 @@ internal class RUMSessionScope: RUMScope, RUMContextProvider {
 
         // Update fatal error context with recent RUM session state:
         dependencies.fatalErrorContext.sessionState = state
+
+        dependencies.timeseriesCollector?.start(
+            sessionID: sessionUUID.rawValue.uuidString.lowercased(),
+            applicationID: dependencies.rumApplicationID,
+            sessionType: dependencies.sessionType
+        )
     }
 
     /// Creates a new Session upon expiration of the previous one.

DatadogRUM/Tests/RUMMonitor/Scopes/RUMSessionScopeTests.swift

@@ -706,4 +706,102 @@ class RUMSessionScopeTests: XCTestCase {
         // Then
         XCTAssertTrue(result)
     }
+
+    // MARK: - Timeseries collector lifecycle
+
+    func testWhenSessionScopeIsCreated_itStartsTimeseriesCollector() {
+        // Given
+        let collector = TimeseriesCollectorSpy()
+
+        // When
+        let _: RUMSessionScope = .mockWith(
+            parent: parent,
+            dependencies: .mockWith(timeseriesCollector: collector)
+        )
+
+        // Then
+        XCTAssertEqual(collector.startCallCount, 1)
+        XCTAssertEqual(collector.stopCallCount, 0)
+    }
+
+    func testWhenSessionExpiresDueToMaxDuration_itStopsTimeseriesCollector() {
+        // Given
+        let collector = TimeseriesCollectorSpy()
+        var currentTime = Date()
+        let scope: RUMSessionScope = .mockWith(
+            parent: parent,
+            startTime: currentTime,
+            dependencies: .mockWith(timeseriesCollector: collector)
+        )
+
+        // When — push past the max session duration
+        currentTime.addTimeInterval(RUMSessionScope.Constants.sessionMaxDuration)
+        _ = scope.process(command: RUMCommandMock(time: currentTime), context: context, writer: writer)
+
+        // Then
+        XCTAssertEqual(collector.stopCallCount, 1)
+    }
+
+    func testWhenSessionExpiresDueToInactivity_itStopsTimeseriesCollector() {
+        // Given
+        let collector = TimeseriesCollectorSpy()
+        var currentTime = Date()
+        let scope: RUMSessionScope = .mockWith(
+            parent: parent,
+            startTime: currentTime,
+            dependencies: .mockWith(timeseriesCollector: collector)
+        )
+
+        _ = scope.process(command: RUMCommandMock(time: currentTime), context: context, writer: writer)
+
+        // When — push past the session inactivity timeout
+        currentTime.addTimeInterval(RUMSessionScope.Constants.sessionTimeoutDuration)
+        _ = scope.process(command: RUMCommandMock(time: currentTime), context: context, writer: writer)
+
+        // Then
+        XCTAssertEqual(collector.stopCallCount, 1)
+    }
+
+    func testWhenSessionScopeStartsNewSession_itStartsCollectorWithCorrectSessionID() {
+        // Given
+        let collector = TimeseriesCollectorSpy()
+        let applicationID = "test-app-id"
+
+        // When
+        let scope: RUMSessionScope = .mockWith(
+            parent: parent,
+            dependencies: .mockWith(
+                rumApplicationID: applicationID,
+                timeseriesCollector: collector
+            )
+        )
+
+        // Then
+        XCTAssertEqual(collector.startCallCount, 1)
+        XCTAssertEqual(collector.lastStartedApplicationID, applicationID)
+        XCTAssertNotNil(collector.lastStartedSessionID, "Session ID should be set")
+        XCTAssertFalse(collector.lastStartedSessionID?.isEmpty ?? true)
+        XCTAssertEqual(collector.lastStartedSessionType, scope.context.sessionID != .nullUUID ? .user : .user)
+    }
+}
+
+// MARK: - Test Helpers
+
+private class TimeseriesCollectorSpy: TimeseriesCollecting {
+    var startCallCount = 0
+    var stopCallCount = 0
+    var lastStartedSessionID: String?
+    var lastStartedApplicationID: String?
+    var lastStartedSessionType: RUMSessionType?
+
+    func start(sessionID: String, applicationID: String, sessionType: RUMSessionType) {
+        startCallCount += 1
+        lastStartedSessionID = sessionID
+        lastStartedApplicationID = applicationID
+        lastStartedSessionType = sessionType
+    }
+
+    func stop() {
+        stopCallCount += 1
+    }
 }

TestUtilities/Sources/Mocks/DatadogRUM/RUMFeatureMocks.swift

@@ -1153,7 +1153,8 @@ extension RUMScopeDependencies {
         interactionToNextViewMetricFactory: @escaping () -> INVMetricTracking = {
             INVMetric(predicate: TimeBasedINVActionPredicate())
         },
-        sessionType: RUMSessionType? = nil
+        sessionType: RUMSessionType? = nil,
+        timeseriesCollector: TimeseriesCollecting? = nil
     ) -> RUMScopeDependencies {
         return RUMScopeDependencies(
             featureScope: featureScope,
@@ -1183,7 +1184,8 @@ extension RUMScopeDependencies {
             watchdogTermination: watchdogTermination,
             networkSettledMetricFactory: networkSettledMetricFactory,
             interactionToNextViewMetricFactory: interactionToNextViewMetricFactory,
-            sessionType: sessionType
+            sessionType: sessionType,
+            timeseriesCollector: timeseriesCollector
         )
     }
 
@@ -1545,6 +1547,7 @@ public class RUMActionsHandlerMock: RUMActionsHandling {
         onViewModifierTapped?(actionName, actionAttributes)
     }
 }
+#endif
 
 public class SamplingBasedVitalReaderMock: SamplingBasedVitalReader {
     public var vitalData: Double?
@@ -1577,7 +1580,6 @@ public class ContinuousVitalReaderMock: ContinuousVitalReader {
         }
     }
 }
-#endif
 
 extension TelemetryReceiver: AnyMockable {
     public static func mockAny() -> Self { .mockWith() }