[pull] master from DataDog:master

Datadog/IntegrationUnitTests/RUM/ViewLoadingMetricsTests.swift

@@ -6,6 +6,7 @@
 
 import XCTest
 import TestUtilities
+import DatadogInternal
 @testable import DatadogRUM
 
 class ViewLoadingMetricsTests: XCTestCase {
@@ -479,4 +480,70 @@ class ViewLoadingMetricsTests: XCTestCase {
             "The INV value should be computed from the last 'Sign Up' action that leads to 'WelcomeView'."
         )
     }
+
+    func testGivenDisabledINV_thenViewEventHasNoINVValue() throws {
+        // This duplicates the first INV test, but ensures that INV has no value when it is disabled
+        let rumTime = DateProviderMock()
+        rumConfig.dateProvider = rumTime
+        rumConfig.nextViewActionPredicate = nil
+        RUM.enable(with: rumConfig, in: core)
+
+        let monitor = RUMMonitor.shared(in: core)
+
+        monitor.startView(key: "previous", name: "PreviousView")
+        rumTime.now += 2.seconds
+        monitor.addAction(type: .tap, name: "Tap in Previous View")
+
+        // When (the next view is started within the INV threshold after the action)
+        let expectedINV: TimeInterval = .mockRandom(
+            min: 0, max: TimeBasedINVActionPredicate.defaultMaxTimeToNextView * 0.99
+        )
+        rumTime.now += expectedINV
+        monitor.startView(key: "next", name: "NextView")
+
+        // Then (INV is tracked for the next view)
+        let session = try RUMSessionMatcher
+            .groupMatchersBySessions(try core.waitAndReturnRUMEventMatchers())
+            .takeSingle()
+
+        let nextViewEvent = try XCTUnwrap(session.views.first(where: { $0.name == "NextView" })?.viewEvents.last)
+        let actualINV = nextViewEvent.view.interactionToNextViewTime
+        XCTAssertNil(actualINV)
+    }
+
+    func testGivenDisabledINV_whenGivenCustomINVValue_thenViewEventHasCustomINVValue() throws {
+        // This duplicates the first INV test with a custom INV value added in.
+        let rumTime = DateProviderMock()
+        rumConfig.dateProvider = rumTime
+        rumConfig.nextViewActionPredicate = nil
+        RUM.enable(with: rumConfig, in: core)
+
+        let monitor = RUMMonitor.shared(in: core)
+
+        monitor.startView(key: "previous", name: "PreviousView")
+        rumTime.now += 2.seconds
+        monitor.addAction(type: .tap, name: "Tap in Previous View")
+
+        let nextTime: TimeInterval = .mockRandom(
+            min: 0, max: 2.5
+        )
+        rumTime.now += nextTime
+        monitor.startView(key: "next", name: "NextView")
+        monitor._internal?.setInternalViewAttribute(
+            at: .mockAny(),
+            key: CrossPlatformAttributes.customINVValue,
+            value: 180_000
+        )
+        // Force a view update
+        monitor.stopView(key: "next")
+
+        // Then (INV is tracked for the next view)
+        let session = try RUMSessionMatcher
+            .groupMatchersBySessions(try core.waitAndReturnRUMEventMatchers())
+            .takeSingle()
+
+        let nextViewEvent = try XCTUnwrap(session.views.first(where: { $0.name == "NextView" })?.viewEvents.last)
+        let actualINV = nextViewEvent.view.interactionToNextViewTime
+        XCTAssertEqual(180_000, actualINV)
+    }
 }

DatadogInternal/Sources/Attributes/Attributes.swift

@@ -156,6 +156,14 @@ public struct CrossPlatformAttributes {
 
     /// Add "binary images" to the reportted error to assist with symbolication. Used by Unity for IL2CPP symbolicaiton
     public static let includeBinaryImages = "_dd.error.include_binary_images"
+
+    /// Custom Flutter vital - First Build Complete. The amount of time between a route change (the start of a view) and when the first
+    /// `build` method is complete. In nanoseconds since view start
+    public static let flutterFirstBuildComplete: String = "_dd.performance.first_build_complete"
+
+    /// Custom value for Interaction To Next view.
+    /// For Flutter this is the amount of time between an action occurring and the First Build Complete ocurring on the next view.
+    public static let customINVValue: String = "_dd.view.custom_inv_value"
 }
 
 public struct LaunchArguments {

DatadogInternal/Sources/Utils/SwiftExtensions.swift

@@ -44,6 +44,10 @@ extension TimeInterval {
         self = Double(milliseconds) / 1_000
     }
 
+    public init(fromNanoseconds nanoseconds: Int64) {
+        self = Double(nanoseconds) / 1_000_000_000
+    }
+
     /// `TimeInterval` represented in milliseconds (capped to `.min` or `.max` respectively to its sign).
     public var toMilliseconds: UInt64 {
         let milliseconds = self * 1_000

DatadogRUM/Sources/Feature/RUMFeature.swift

@@ -43,7 +43,7 @@ internal final class RUMFeature: DatadogRemoteFeature {
             sampleRate: configuration.sessionEndedSampleRate
         )
         let tnsPredicateType = configuration.networkSettledResourcePredicate.metricPredicateType
-        let invPredicateType = configuration.nextViewActionPredicate.metricPredicateType
+        let invPredicateType = configuration.nextViewActionPredicate?.metricPredicateType ?? .disabled
 
         var watchdogTermination: WatchdogTerminationMonitor?
         if configuration.trackWatchdogTerminations {
@@ -124,8 +124,11 @@ internal final class RUMFeature: DatadogRemoteFeature {
                 )
             },
             interactionToNextViewMetricFactory: {
+                guard let nextViewActionPredicate = configuration.nextViewActionPredicate else {
+                    return nil
+                }
                 return INVMetric(
-                    predicate: configuration.nextViewActionPredicate
+                    predicate: nextViewActionPredicate
                 )
             }
         )

DatadogRUM/Sources/RUMConfiguration.swift

@@ -166,9 +166,11 @@ extension RUM {
         /// The `NextViewActionPredicate` determines which action in the previous view should be considered the "last interaction" for INV,
         /// based on properties such as action type, name, or timing relative to the next view’s start.
         ///
+        /// Setting this property to `nil` will disable measuring Interaction to Next View.
+        ///
         /// Default: The default predicate, `TimeBasedINVActionPredicate`, classifies actions as the last interaction if they occur within a
         /// 3-second threshold before the next view starts. You can customize this time threshold or provide your own predicate.
-        public var nextViewActionPredicate: NextViewActionPredicate
+        public var nextViewActionPredicate: NextViewActionPredicate?
 
         /// Custom mapper for RUM view events.
         ///
@@ -406,7 +408,7 @@ extension RUM.Configuration {
         trackWatchdogTerminations: Bool = false,
         vitalsUpdateFrequency: VitalsFrequency? = .average,
         networkSettledResourcePredicate: NetworkSettledResourcePredicate = TimeBasedTNSResourcePredicate(),
-        nextViewActionPredicate: NextViewActionPredicate = TimeBasedINVActionPredicate(),
+        nextViewActionPredicate: NextViewActionPredicate? = TimeBasedINVActionPredicate(),
         viewEventMapper: RUM.ViewEventMapper? = nil,
         resourceEventMapper: RUM.ResourceEventMapper? = nil,
         actionEventMapper: RUM.ActionEventMapper? = nil,

DatadogRUM/Sources/RUMMetrics/INVMetric.swift

@@ -61,6 +61,8 @@ internal enum INVNoValueReason: String, Error {
     case previousViewRemoved = "previous_view_removed"
     /// Actions were tracked in the previous view, but all were invalid (e.g., started before the view started).
     case invalidTrackedActions = "invalid_actions"
+    /// INV Is Disabled
+    case disabled = "disabled"
 }
 
 internal final class INVMetric: INVMetricTracking {

DatadogRUM/Sources/RUMMonitor/RUMCommand.swift

@@ -529,7 +529,7 @@ internal struct RUMKeepSessionAliveCommand: RUMCommand {
     let missedEventType: SessionEndedMetric.MissedEventType? = nil
 }
 
-// MARK: - Cross-platform perf metrics
+// MARK: - Cross-platform attributes
 
 internal struct RUMUpdatePerformanceMetric: RUMCommand {
     let canStartBackgroundView = false
@@ -541,3 +541,15 @@ internal struct RUMUpdatePerformanceMetric: RUMCommand {
     var attributes: [AttributeKey: AttributeValue]
     let missedEventType: SessionEndedMetric.MissedEventType? = nil
 }
+
+internal struct RUMSetInternalViewAttributeCommand: RUMCommand {
+    let canStartBackgroundView = false
+    let isUserInteraction = false
+    var time: Date
+    var globalAttributes: [AttributeKey: AttributeValue] = [:]
+    var attributes: [AttributeKey: AttributeValue] = [:]
+    let missedEventType: SessionEndedMetric.MissedEventType? = nil
+
+    let key: AttributeKey
+    let value: AttributeValue
+}

DatadogRUM/Sources/RUMMonitor/Scopes/RUMScopeDependencies.swift

@@ -61,7 +61,7 @@ internal struct RUMScopeDependencies {
     let networkSettledMetricFactory: (Date, String) -> TNSMetricTracking
 
     /// A factory function that creates a `INVMetric` when session starts.
-    let interactionToNextViewMetricFactory: () -> INVMetricTracking
+    let interactionToNextViewMetricFactory: () -> INVMetricTracking?
 
     init(
         featureScope: FeatureScope,
@@ -83,7 +83,7 @@ internal struct RUMScopeDependencies {
         viewEndedMetricFactory: @escaping () -> ViewEndedMetricController,
         watchdogTermination: WatchdogTerminationMonitor?,
         networkSettledMetricFactory: @escaping (Date, String) -> TNSMetricTracking,
-        interactionToNextViewMetricFactory: @escaping () -> INVMetricTracking
+        interactionToNextViewMetricFactory: @escaping () -> INVMetricTracking?
     ) {
         self.featureScope = featureScope
         self.rumApplicationID = rumApplicationID

DatadogRUM/Sources/RUMMonitor/Scopes/RUMSessionScope.swift

@@ -78,7 +78,7 @@ internal class RUMSessionScope: RUMScope, RUMContextProvider {
     /// The reason why this session has ended or `nil` if it is still active.
     private(set) var endReason: EndReason?
 
-    private let interactionToNextViewMetric: INVMetricTracking
+    private let interactionToNextViewMetric: INVMetricTracking?
 
     init(
         isInitialSession: Bool,

DatadogRUM/Sources/RUMMonitor/Scopes/RUMUserActionScope.swift

@@ -61,7 +61,7 @@ internal class RUMUserActionScope: RUMScope, RUMContextProvider {
     private var activeResourcesCount: Int = 0
 
     /// Interaction-to-Next-View metric for this view.
-    private let interactionToNextViewMetric: INVMetricTracking
+    private let interactionToNextViewMetric: INVMetricTracking?
 
     /// Callback called when a `RUMActionEvent` is submitted for storage.
     private let onActionEventSent: (RUMActionEvent) -> Void
@@ -76,7 +76,7 @@ internal class RUMUserActionScope: RUMScope, RUMContextProvider {
         serverTimeOffset: TimeInterval,
         isContinuous: Bool,
         instrumentation: InstrumentationType,
-        interactionToNextViewMetric: INVMetricTracking,
+        interactionToNextViewMetric: INVMetricTracking?,
         onActionEventSent: @escaping (RUMActionEvent) -> Void
     ) {
         self.parent = parent
@@ -205,7 +205,7 @@ internal class RUMUserActionScope: RUMScope, RUMContextProvider {
             onActionEventSent(event)
 
             if let activeViewID = self.context.activeViewID {
-                interactionToNextViewMetric.trackAction(
+                interactionToNextViewMetric?.trackAction(
                     startTime: actionStartTime,
                     endTime: completionTime,
                     name: name,

DatadogRUM/Sources/RUMMonitor/Scopes/RUMViewScope.swift

@@ -39,6 +39,8 @@ internal class RUMViewScope: RUMScope, RUMContextProvider {
     let identity: ViewIdentifier
     /// View attributes.
     private(set) var attributes: [AttributeKey: AttributeValue] = [:]
+    /// Internal view attributes - used by cross platform frameworks and should not be propagated to events
+    private(set) var internalAttributes: [AttributeKey: AttributeValue] = [:]
     /// View custom timings, keyed by name. The value of timing is given in nanoseconds.
     private(set) var customTimings: [String: Int64] = [:]
 
@@ -109,7 +111,7 @@ internal class RUMViewScope: RUMScope, RUMContextProvider {
     /// Time-to-Network-Settled metric for this view.
     private let networkSettledMetric: TNSMetricTracking
     /// Interaction-to-Next-View metric for this view.
-    private let interactionToNextViewMetric: INVMetricTracking
+    private var interactionToNextViewMetric: INVMetricTracking?
     /// Tracks "RUM View Ended" metric for this view.
     private let viewEndedMetric: ViewEndedMetricController
 
@@ -123,7 +125,7 @@ internal class RUMViewScope: RUMScope, RUMContextProvider {
         customTimings: [String: Int64],
         startTime: Date,
         serverTimeOffset: TimeInterval,
-        interactionToNextViewMetric: INVMetricTracking
+        interactionToNextViewMetric: INVMetricTracking?
     ) {
         self.parent = parent
         self.dependencies = dependencies
@@ -147,7 +149,7 @@ internal class RUMViewScope: RUMScope, RUMContextProvider {
             )
         }
         self.networkSettledMetric = dependencies.networkSettledMetricFactory(viewStartTime, viewName)
-        interactionToNextViewMetric.trackViewStart(at: startTime, name: name, viewID: viewUUID)
+        interactionToNextViewMetric?.trackViewStart(at: startTime, name: name, viewID: viewUUID)
 
         self.viewEndedMetric = dependencies.viewEndedMetricFactory()
 
@@ -218,6 +220,12 @@ internal class RUMViewScope: RUMScope, RUMContextProvider {
             // deactivated. This is achieved by setting `isActiveView` to `false` and sending one more view update.
             isActiveView = false
             needsViewUpdate = true
+        case let command as RUMSetInternalViewAttributeCommand where isActiveView:
+            internalAttributes[command.key] = command.value
+            // Purposefully don't perform a view update. Most (all?) internal view attributes
+            // aren't important enough to expect them to be uploaded automatically. They can
+            // get sent with the next view update.
+
         case let command as RUMStopViewCommand where identity == command.identity:
             isActiveView = false
             needsViewUpdate = true
@@ -288,7 +296,7 @@ internal class RUMViewScope: RUMScope, RUMContextProvider {
         let shouldComplete = !isActiveView && hasNoPendingResources
 
         if shouldComplete {
-            interactionToNextViewMetric.trackViewComplete(viewID: viewUUID)
+            interactionToNextViewMetric?.trackViewComplete(viewID: viewUUID)
             viewEndedMetric.send()
         }
 
@@ -531,7 +539,28 @@ internal class RUMViewScope: RUMScope, RUMContextProvider {
         let refreshRateInfo = vitalInfoSampler?.refreshRate
         let isSlowRendered = refreshRateInfo?.meanValue.map { $0 < Constants.slowRenderingThresholdFPS }
         let networkSettledTime = networkSettledMetric.value(with: context.applicationStateHistory)
-        let interactionToNextViewTime = interactionToNextViewMetric.value(for: viewUUID)
+        var interactionToNextViewTime = interactionToNextViewMetric?.value(for: viewUUID) ?? .failure(.disabled)
+        // Only overwrite with a custom value if INV was disabled
+        if interactionToNextViewTime == .failure(.disabled),
+           let customInvValue = internalAttributes[CrossPlatformAttributes.customINVValue] as? (any BinaryInteger),
+           let customInvValue = Int64(exactly: customInvValue) {
+            interactionToNextViewTime = .success(TimeInterval(fromNanoseconds: customInvValue))
+        }
+
+        // Only add the performance member if we have a value for it
+        let performance: RUMViewEvent.View.Performance?
+        if let fbcMetric = internalAttributes[CrossPlatformAttributes.flutterFirstBuildComplete] as? (any BinaryInteger),
+           let fbcMetric = Int64(exactly: fbcMetric) {
+            performance = .init(
+                cls: nil,
+                fbc: .init(timestamp: fbcMetric),
+                fcp: nil,
+                fid: nil,
+                inp: nil
+            )
+        } else {
+            performance = nil
+        }
 
         let viewEvent = RUMViewEvent(
             dd: .init(
@@ -621,6 +650,7 @@ internal class RUMViewScope: RUMScope, RUMContextProvider {
                 memoryMax: memoryInfo?.maxValue,
                 name: viewName,
                 networkSettledTime: networkSettledTime.value?.toInt64Nanoseconds,
+                performance: performance,
                 referrer: nil,
                 refreshRateAverage: refreshRateInfo?.meanValue,
                 refreshRateMin: refreshRateInfo?.minValue,

DatadogRUM/Sources/RUMMonitorProtocol+Internal.swift

@@ -93,6 +93,25 @@ public struct DatadogInternalInterface {
         monitor.process(command: performanceMetric)
     }
 
+    /// Add an internal view attribute. Internal view attributes are used by cross platform frameworks to determine the values
+    /// of certain internal metrics, including Flutter's First Build Complete metric. They are not propagated to other events
+    /// - Parameters:
+    ///   - time: the time of this command
+    ///   - key: the key for this attribute
+    ///   - value: the value of the attribute
+    public func setInternalViewAttribute(
+        at time: Date,
+        key: AttributeKey,
+        value: AttributeValue
+    ) {
+        let attributeCommand = RUMSetInternalViewAttributeCommand(
+            time: time,
+            key: key,
+            value: value
+        )
+        monitor.process(command: attributeCommand)
+    }
+
     /// Adds temporal metrics to given RUM resource.
     ///
     /// It must be called before the resource is stopped.

DatadogRUM/Sources/SDKMetrics/ViewEndedMetric.swift

@@ -25,6 +25,7 @@ internal final class ViewEndedMetric {
     internal enum MetricPredicateType: String {
         case timeBasedDefault = "time_based_default"
         case timeBasedCustom = "time_based_custom"
+        case disabled = "disabled"
         case custom = "custom"
     }