RUM-11470: Report Time to full display

Author: simaoseica-dd

DatadogCore/Tests/Objc/DDRUMMonitorTests.swift

@@ -323,6 +323,7 @@ class DDRUMMonitorTests: XCTestCase {
         objcRUMMonitor.stopView(viewController: mockView, attributes: ["event-attribute2": "foo2"])
         objcRUMMonitor.startView(key: "view2", name: "SecondView", attributes: ["event-attribute1": "bar1"])
         objcRUMMonitor.addViewLoadingTime(overwrite: true)
+        objcRUMMonitor.reportAppFullyDisplayed()
         objcRUMMonitor.stopView(key: "view2", attributes: ["event-attribute2": "bar2"])
 
         let rumEventMatchers = try core.waitAndReturnRUMEventMatchers()

DatadogCore/Tests/Objc/ObjcAPITests/DDRUMMonitor+apiTests.m

@@ -59,6 +59,7 @@ - (void)testDDRUMMonitorAPI {
     DDRUMMonitor *monitor = [DDRUMMonitor shared];
     [monitor currentSessionIDWithCompletion:^(NSString * _Nullable sessionID) {}];
     [monitor stopSession];
+    [monitor reportAppFullyDisplayed];
 
     [monitor addViewAttributeForKey:@"key" value: @"value"];
     [monitor addViewAttributes:@{@"string": @"value", @"integer": @1, @"boolean": @true}];

DatadogRUM/Sources/RUM+objc.swift

@@ -522,6 +522,10 @@ public class objc_RUMMonitor: NSObject {
         swiftRUMMonitor.stopSession()
     }
 
+    public func reportAppFullyDisplayed() {
+        swiftRUMMonitor.reportAppFullyDisplayed()
+    }
+
     public func addViewAttribute(forKey key: String, value: Any) {
         swiftRUMMonitor.addViewAttribute(forKey: key, value: AnyEncodable(value))
     }

DatadogRUM/Sources/RUMMonitor/Monitor.swift

@@ -241,17 +241,8 @@ extension Monitor: RUMMonitorProtocol {
         process(command: RUMStopSessionCommand(time: dateProvider.now))
     }
 
-    // MARK: - custom timings
-
-    func addTiming(name: String) {
-        process(
-            command: RUMAddViewTimingCommand(
-                time: dateProvider.now,
-                globalAttributes: self.attributes,
-                attributes: [:],
-                timingName: name
-            )
-        )
+    func reportAppFullyDisplayed() {
+        process(command: RUMTimeToFullDisplayCommand(time: dateProvider.now))
     }
 
     // MARK: - errors
@@ -664,6 +655,17 @@ extension Monitor: RUMMonitorViewProtocol {
         )
     }
 
+    func addTiming(name: String) {
+        process(
+            command: RUMAddViewTimingCommand(
+                time: dateProvider.now,
+                globalAttributes: self.attributes,
+                attributes: [:],
+                timingName: name
+            )
+        )
+    }
+
     func addViewLoadingTime(overwrite: Bool) {
         process(
             command: RUMAddViewLoadingTime(

DatadogRUM/Sources/RUMMonitor/RUMCommand.swift

@@ -115,6 +115,19 @@ internal struct RUMTimeToInitialDisplayCommand: RUMCommand {
     let missedEventType: SessionEndedMetric.MissedEventType? = nil
 }
 
+internal struct RUMTimeToFullDisplayCommand: RUMCommand {
+    var time: Date
+    var globalAttributes: [AttributeKey: AttributeValue] = [:]
+    var attributes: [AttributeKey: AttributeValue] = [:]
+    var canStartApplicationLaunchView = false
+    var canStartBackgroundView = false
+    let shouldRestartLastViewAfterSessionExpiration = false
+    let shouldRestartLastViewAfterSessionStop = false
+    let canStartBackgroundViewAfterSessionStop = false
+    let isUserInteraction = false
+    let missedEventType: SessionEndedMetric.MissedEventType? = nil
+}
+
 // MARK: - RUM View related commands
 
 internal struct RUMAddViewAttributesCommand: RUMCommand {

DatadogRUM/Sources/RUMMonitor/Scopes/RUMAppLaunchManager.swift

@@ -7,17 +7,22 @@
 import DatadogInternal
 import Foundation
 
-internal class RUMAppLaunchVitalScope {
+internal class RUMAppLaunchManager {
     internal enum Constants {
         // Maximum time for an erroneous TTID (Time to Initial Display)
         static let maxTTIDDuration: TimeInterval = 60 // 1 minute
+        // Maximum time for an erroneous ttfd
+        static let maxTTFDDuration: TimeInterval = 90 // 90 seconds
     }
     // MARK: - Properties
 
     private unowned let parent: RUMContextProvider
     private let dependencies: RUMScopeDependencies
 
     private var timeToInitialDisplay: Double?
+    private var timeToFullDisplay: Double?
+    private var viewLoadingTime: Double?
+    private var startupType: RUMVitalEvent.Vital.AppLaunchProperties.StartupType?
 
     private lazy var startupTypeHandler = StartupTypeHandler(appStateManager: dependencies.appStateManager)
 
@@ -35,84 +40,79 @@ internal class RUMAppLaunchVitalScope {
             switch command {
             case let command as RUMTimeToInitialDisplayCommand:
                 try writeTTIDVitalEvent(from: command, context: context, writer: writer)
+            case let command as RUMTimeToFullDisplayCommand:
+                try writeTTFDVitalEvent(from: command, context: context, writer: writer)
+            case let command as RUMAddViewLoadingTime:
+                try registerViewLoadingTime(from: command, context: context)
+            case let command as RUMStopViewCommand:
+                if viewLoadingTime != nil,
+                   timeToFullDisplay == nil {
+                    try writeTTFDVitalEvent(from: command, context: context, writer: writer)
+                }
             default: break
             }
         } catch {
             dependencies.telemetry.error("RUMAppLaunchManager failed to write the ttid vital event.", error: error)
         }
     }
+}
 
-    // MARK: - Private Methods
+// MARK: - TTID
 
+private extension RUMAppLaunchManager {
     private func writeTTIDVitalEvent(from command: RUMTimeToInitialDisplayCommand, context: DatadogContext, writer: Writer) throws {
-        guard
-            shouldProcess(command: command, context: context),
-            let timeToInitialDisplay = timeToInitialDisplay(from: command, context: context)
+        guard shouldProcess(command: command, context: context),
+              let ttid = time(from: command, context: context)
         else {
             return
         }
 
-        self.timeToInitialDisplay = timeToInitialDisplay
-
-        let attributes = command.globalAttributes
-            .merging(command.attributes) { $1 }
+        self.timeToInitialDisplay = ttid
 
         dependencies.appStateManager.currentAppStateInfo { [weak self] currentAppStateInfo in
             guard let self else {
                 return
             }
 
-            let appLaunchMetric: RUMVitalEvent.Vital.AppLaunchProperties.AppLaunchMetric = .ttid
+            let attributes = command.globalAttributes
+                .merging(command.attributes) { $1 }
+
             let startupType = self.startupTypeHandler.startupType(currentAppState: currentAppStateInfo)
-            let vital = RUMVitalEvent.Vital.appLaunchProperties(
-                value: RUMVitalEvent.Vital.AppLaunchProperties(
-                    appLaunchMetric: .ttid,
-                    duration: Double(timeToInitialDisplay.toInt64Nanoseconds),
-                    id: dependencies.rumUUIDGenerator.generateUnique().toRUMDataFormat,
-                    isPrewarmed: context.launchInfo.launchReason == .prewarming,
-                    name: appLaunchMetric.name,
-                    startupType: startupType
-                )
-            )
+            self.startupType = startupType
 
-            let vitalEvent = RUMVitalEvent(
-                dd: .init(),
-                account: .init(context: context),
-                application: .init(id: parent.context.rumApplicationID),
-                buildId: context.buildId,
-                buildVersion: context.buildNumber,
-                ciTest: dependencies.ciTest,
-                connectivity: .init(context: context),
-                context: RUMEventAttributes(contextInfo: attributes),
-                date: context.launchInfo.processLaunchDate.timeIntervalSince1970.toInt64Milliseconds,
-                ddtags: context.ddTags,
-                device: context.normalizedDevice(),
-                os: context.os,
-                service: context.service,
-                session: .init(
-                    hasReplay: context.hasReplay,
-                    id: parent.context.sessionID.toRUMDataFormat,
-                    type: dependencies.sessionType
-                ),
-                source: .init(rawValue: context.source) ?? .ios,
-                synthetics: dependencies.syntheticsTest,
-                usr: .init(context: context),
-                version: context.version,
-                vital: vital
+            self.writeVitalEvent(
+                duration: Double(ttid.toInt64Nanoseconds),
+                appLaunchMetric: .ttid,
+                startupType: startupType,
+                attributes: attributes,
+                context: context,
+                writer: writer
             )
 
-            writer.write(value: vitalEvent)
+            // The TTFD is always written after the TTID. If it exists already, means it was not written before.
+            if let timeToFullDisplay {
+                let ttfd = max(ttid, timeToFullDisplay)
+                self.writeVitalEvent(
+                    duration: Double(ttfd.toInt64Nanoseconds),
+                    appLaunchMetric: .ttfd,
+                    startupType: startupType,
+                    attributes: attributes,
+                    context: context,
+                    writer: writer
+                )
+            }
         }
     }
 
-    private func shouldProcess(command: RUMTimeToInitialDisplayCommand, context: DatadogContext) -> Bool {
+    func shouldProcess(command: RUMTimeToInitialDisplayCommand, context: DatadogContext) -> Bool {
         // Ignore command if the time to initial display was already written
         guard self.timeToInitialDisplay == nil else {
             return false
         }
 
-        // Ignore command if the time to initial display is too big
-        guard command.time.timeIntervalSince(context.launchInfo.processLaunchDate) < Constants.maxTTIDDuration else {
+        // Ignore command if the time since the SDK load is too big
+        guard let runtimeLoadDate = context.launchInfo.launchPhaseDates[.runtimeLoad],
+              command.time.timeIntervalSince(runtimeLoadDate) < Constants.maxTTIDDuration else {
             return false
         }
 
@@ -124,7 +124,7 @@ internal class RUMAppLaunchVitalScope {
         return true
     }
 
-    private func timeToInitialDisplay(from command: RUMTimeToInitialDisplayCommand, context: DatadogContext) -> TimeInterval? {
+    func time(from command: RUMCommand, context: DatadogContext) -> TimeInterval? {
         switch context.launchInfo.launchReason {
         case .userLaunch:
             return command.time.timeIntervalSince(context.launchInfo.processLaunchDate)
@@ -138,6 +138,138 @@ internal class RUMAppLaunchVitalScope {
             return nil
         }
     }
+
+    func writeVitalEvent(
+        duration: TimeInterval,
+        appLaunchMetric: RUMVitalEvent.Vital.AppLaunchProperties.AppLaunchMetric,
+        startupType: RUMVitalEvent.Vital.AppLaunchProperties.StartupType,
+        attributes: [AttributeKey: AttributeValue],
+        context: DatadogContext,
+        writer: Writer
+    ) {
+        let vital = RUMVitalEvent.Vital.appLaunchProperties(
+            value: RUMVitalEvent.Vital.AppLaunchProperties(
+                appLaunchMetric: appLaunchMetric,
+                duration: duration,
+                id: dependencies.rumUUIDGenerator.generateUnique().toRUMDataFormat,
+                isPrewarmed: context.launchInfo.launchReason == .prewarming,
+                name: appLaunchMetric.name,
+                startupType: startupType
+            )
+        )
+
+        let vitalEvent = RUMVitalEvent(
+            dd: .init(),
+            account: .init(context: context),
+            application: .init(id: parent.context.rumApplicationID),
+            buildId: context.buildId,
+            buildVersion: context.buildNumber,
+            ciTest: dependencies.ciTest,
+            connectivity: .init(context: context),
+            context: RUMEventAttributes(contextInfo: attributes),
+            date: context.launchInfo.processLaunchDate.timeIntervalSince1970.toInt64Milliseconds,
+            ddtags: context.ddTags,
+            device: context.normalizedDevice(),
+            os: context.os,
+            service: context.service,
+            session: .init(
+                hasReplay: context.hasReplay,
+                id: parent.context.sessionID.toRUMDataFormat,
+                type: dependencies.sessionType
+            ),
+            source: .init(rawValue: context.source) ?? .ios,
+            synthetics: dependencies.syntheticsTest,
+            usr: .init(context: context),
+            version: context.version,
+            vital: vital
+        )
+
+        writer.write(value: vitalEvent)
+    }
+}
+
+// MARK: - TTFD
+
+private extension RUMAppLaunchManager {
+    func writeTTFDVitalEvent(from command: RUMTimeToFullDisplayCommand, context: DatadogContext, writer: Writer) throws {
+        guard shouldProcess(command: command, context: context),
+              let ttfd = time(from: command, context: context) else { return }
+
+        self.timeToFullDisplay = ttfd
+
+        if let timeToFullDisplay, let timeToInitialDisplay, let startupType {
+            let attributes = command.globalAttributes
+                .merging(command.attributes) { $1 }
+            let ttfd = max(timeToInitialDisplay, timeToFullDisplay)
+
+            self.writeVitalEvent(
+                duration: Double(ttfd.toInt64Nanoseconds),
+                appLaunchMetric: .ttfd,
+                startupType: startupType,
+                attributes: attributes,
+                context: context,
+                writer: writer
+            )
+        }
+    }
+
+    func shouldProcess(command: RUMTimeToFullDisplayCommand, context: DatadogContext) -> Bool {
+        // Ignore command if the time to full display was already written
+        guard self.timeToFullDisplay == nil else {
+            return false
+        }
+
+        // Ignore command if the time since the SDK load is too big
+        guard let runtimeLoadDate = context.launchInfo.launchPhaseDates[.runtimeLoad],
+              command.time.timeIntervalSince(runtimeLoadDate) < Constants.maxTTFDDuration else {
+            return false
+        }
+
+        return true
+    }
+}
+
+// MARK: - View loading time
+
+private extension RUMAppLaunchManager {
+    func registerViewLoadingTime(from command: RUMAddViewLoadingTime, context: DatadogContext) throws {
+        guard shouldProcess(command: command, context: context),
+              let viewLoadingTime = time(from: command, context: context) else { return }
+
+        self.viewLoadingTime = viewLoadingTime
+    }
+
+    func writeTTFDVitalEvent(from command: RUMStopViewCommand, context: DatadogContext, writer: Writer) throws {
+        if let viewLoadingTime, let timeToInitialDisplay, let startupType {
+            let attributes = command.globalAttributes
+                .merging(command.attributes) { $1 }
+            let ttfd = max(timeToInitialDisplay, viewLoadingTime)
+
+            self.writeVitalEvent(
+                duration: Double(ttfd.toInt64Nanoseconds),
+                appLaunchMetric: .ttfd,
+                startupType: startupType,
+                attributes: attributes,
+                context: context,
+                writer: writer
+            )
+        }
+    }
+
+    func shouldProcess(command: RUMAddViewLoadingTime, context: DatadogContext) -> Bool {
+        // Ignore command if the time to full display was already written
+        guard self.timeToFullDisplay == nil else {
+            return false
+        }
+
+        // Ignore command if the time since the SDK load is too big
+        guard let runtimeLoadDate = context.launchInfo.launchPhaseDates[.runtimeLoad],
+              command.time.timeIntervalSince(runtimeLoadDate) < Constants.maxTTFDDuration else {
+            return false
+        }
+
+        return true
+    }
 }
 
 private extension RUMVitalEvent.Vital.AppLaunchProperties.AppLaunchMetric {