DataDog · brunovsiqueira · Aug 18, 2026 · Aug 20, 2026 · Aug 21, 2026 · fuzzybinary
@@ -82,9 +82,14 @@ class RumSessionDecoder {
           visit.longTaskEvents.add(longTaskEvent);
           break;
         case 'vital':
-          final operationStepEvent =
-              RumVitalOperationStepEventDecoder(e.rumEvent);
-          visit.vitalStepEvents.add(operationStepEvent);
+          if (RumVitalAppLaunchEventDecoder.isAppLaunchVital(e.rumEvent)) {
+            final appLaunchEvent = RumVitalAppLaunchEventDecoder(e.rumEvent);
+            visit.appLaunchVitalEvents.add(appLaunchEvent);
+          } else {
+            final operationStepEvent =
+                RumVitalOperationStepEventDecoder(e.rumEvent);
+            visit.vitalStepEvents.add(operationStepEvent);
+          }
           break;
       }
     }
@@ -109,6 +114,7 @@ class RumViewVisit {
   final List<RumErrorEventDecoder> errorEvents = [];
   final List<RumLongTaskEventDecoder> longTaskEvents = [];
   final List<RumVitalOperationStepEventDecoder> vitalStepEvents = [];
+  final List<RumVitalAppLaunchEventDecoder> appLaunchVitalEvents = [];
 
   RumViewVisit(this.id, this.name, this.path);
 }
@@ -361,3 +367,24 @@ class RumVitalOperationStepEventDecoder extends RumEventDecoder {
       rumEvent['vital']['failure_reason'] as String?;
   String get stepType => rumEvent['vital']['step_type'] as String;
 }
+
+/// Decodes app launch vitals, which carry the app launch metrics (`ttid` and
+/// `ttfd`) rather than the operation step properties.
+class RumVitalAppLaunchEventDecoder extends RumEventDecoder {
+  RumVitalAppLaunchEventDecoder(super.rumEvent);
+
+  static bool isAppLaunchVital(Map<String, dynamic> rumEvent) {
+    final vital = rumEvent['vital'];
+    return vital is Map && vital['type'] == 'app_launch';
+  }
+
+  RumViewInfoDecoder get view => RumViewInfoDecoder(rumEvent['view']);
+
+  String get appLaunchMetric =>
+      rumEvent['vital']['app_launch_metric'] as String;
+
+  /// Duration of the app launch metric, in nanoseconds.
+  int get duration => (rumEvent['vital']['duration'] as num).toInt();
+
+  String? get startupType => rumEvent['vital']['startup_type'] as String?;
+}
@@ -118,6 +118,7 @@ class DatadogRumPlugin : MethodChannel.MethodCallHandler {
                 "stopView" -> stopView(call, result)
                 "addTiming" -> addTiming(call, result)
                 "addViewLoadingTime" -> addViewLoadingTime(call, result)
+                "reportAppFullyDisplayed" -> reportAppFullyDisplayed(call, result)
                 "startResource" -> startResource(call, result)
                 "stopResource" -> stopResource(call, result)
                 "stopResourceWithError" -> stopResourceWithError(call, result)
@@ -291,6 +292,11 @@ class DatadogRumPlugin : MethodChannel.MethodCallHandler {
         }
     }
 
+    private fun reportAppFullyDisplayed(call: MethodCall, result: Result) {
+        rum?.reportAppFullyDisplayed()
+        result.success(null)
+    }
+
     private fun startResource(call: MethodCall, result: Result) {
         val key = call.argument<String>(PARAM_KEY)
         val url = call.argument<String>(PARAM_URL)

@@ -593,6 +593,21 @@ class DatadogRumPluginTest {
         verify { mockResult.success(null) }
     }
 
+    @Test
+    fun `M call monitor reportAppFullyDisplayed W reportAppFullyDisplayed is called`() {
+        // GIVEN
+        val call = MethodCall("reportAppFullyDisplayed", mapOf<String, Any?>())
+        val mockResult = mockk<MethodChannel.Result>()
+        every { mockResult.success(any()) } returns Unit
+
+        // WHEN
+        plugin.onMethodCall(call, mockResult)
+
+        // THEN
+        verify { monitorProxy.mockMonitor.reportAppFullyDisplayed() }
+        verify { mockResult.success(null) }
+    }
+
     @Test
     fun `M call monitor startResource W startResource is called`(
         @StringForgery resourceKey: String,
@@ -1066,7 +1081,8 @@ class DatadogRumPluginTest {
             "failureReason" to ContractParameter.Type(SupportedContractType.STRING),
             "attributes" to ContractParameter.Type(SupportedContractType.MAP)
         )),
-        Contract("stopSession", mapOf())
+        Contract("stopSession", mapOf()),
+        Contract("reportAppFullyDisplayed", mapOf())
     )
 
     @Test

@@ -196,7 +196,8 @@ class DatadogRumPluginTests: XCTestCase {
             "failureReason": .string,
             "attributes": .map
         ]),
-        Contract(methodName: "stopSession", requiredParameters: [:])
+        Contract(methodName: "stopSession", requiredParameters: [:]),
+        Contract(methodName: "reportAppFullyDisplayed", requiredParameters: [:])
     ]
 
     func testRumPlugin_ContractViolationsThrowErrors() {
@@ -382,6 +383,18 @@ class DatadogRumPluginTests: XCTestCase {
         XCTAssertEqual(resultStatus, .called(value: nil))
     }
 
+    func testReportAppFullyDisplayed_CallsRumMonitor() {
+        let call = FlutterMethodCall(methodName: "reportAppFullyDisplayed", arguments: [:] as [String: Any?])
+
+        var resultStatus = ResultStatus.notCalled
+        plugin.handle(call) { result in
+            resultStatus = .called(value: result)
+        }
+
+        XCTAssertEqual(mock.callLog, [ .reportAppFullyDisplayed ])
+        XCTAssertEqual(resultStatus, .called(value: nil))
+    }
+
     func testStartResource_CallsRumMonitor() {
         let call = FlutterMethodCall(methodName: "startResource", arguments: [
             "key": "resource_key",

@@ -187,6 +187,33 @@ void main() {
     expect(view1.vitalStepEvents[2].vitalOperationKey, isNull);
     expect(view1.vitalStepEvents[2].vitalFailureReason, 'error');
 
+    // `reportAppFullyDisplayed` reports TTFD as an app launch vital rather than
+    // as a property of the view it was called from, so look for it across the
+    // whole session.
+    //
+    // This is only checked on iOS. The Browser SDK has no equivalent API, and
+    // the Android SDK only sends TTFD once it has computed TTID for the startup
+    // scenario, which does not happen in this app -- it sends no app launch
+    // vitals at all, so there is nothing to assert on there yet.
+    if (!kIsWeb && Platform.isIOS) {
+      final ttfdVitals = rumLog
+          .where((e) =>
+              e.eventType == 'vital' &&
+              RumVitalAppLaunchEventDecoder.isAppLaunchVital(e.rumEvent))
+          .map((e) => RumVitalAppLaunchEventDecoder(e.rumEvent))
+          .where((e) => e.appLaunchMetric == 'ttfd')
+          .toList();
+
+      // Only the first call to `reportAppFullyDisplayed` is reported.
+      expect(ttfdVitals.length, 1);
+      // TTFD is measured from the launch of the app, so it should be at least
+      // as long as the fake loading the scenario performs before reporting it.
+      expect(ttfdVitals[0].duration,
+          greaterThanOrEqualTo(const Duration(milliseconds: 50).inNanoseconds));
+      expect(ttfdVitals[0].duration,
+          lessThan(const Duration(seconds: 60).inNanoseconds));
+    }
+
     // Verify user in all events, except for the first view event
     for (final viewEvent in view1.viewEvents.sublist(1)) {
       verifyUser(viewEvent);

@@ -105,6 +105,7 @@ class _RumManualInstrumentationScenarioState
     await Future<void>.delayed(const Duration(milliseconds: 50));
     DatadogSdk.instance.rum?.addTiming('content-ready');
     DatadogSdk.instance.rum?.addViewLoadingTime();
+    DatadogSdk.instance.rum?.reportAppFullyDisplayed();
 
     DatadogSdk.instance.setUserInfo(
         id: 'fake-id',

@@ -194,6 +194,9 @@ public class DatadogRumPlugin: NSObject, FlutterPlugin {
                     FlutterError.missingParameter(methodName: call.method)
                 )
             }
+        case "reportAppFullyDisplayed":
+            rum?.reportAppFullyDisplayed()
+            result(nil)
         case "startResource":
             if let key = arguments["key"] as? String,
                let methodString = arguments["httpMethod"] as? String,

@@ -271,6 +271,20 @@ class DatadogRum {
     });
   }
 
+  /// Marks the moment when the UI of the app is considered fully displayed.
+  /// The duration between the launch of the app and this call is reported as
+  /// the time to full display (TTFD) of the app launch.
+  ///
+  /// Only the first call to this method has any effect for a given RUM
+  /// session.
+  ///
+  /// *Note*: This API is experimental and may change in the future.
+  void reportAppFullyDisplayed() {
+    wrap('rum.reportAppFullyDisplayed', logger, null, () {
+      return _platform.reportAppFullyDisplayed();
+    });
+  }
+
   /// Notifies that the Exception or Error [error] occurred in currently
   /// presented View, with an origin of [source]. You can optionally set
   /// additional [attributes] for this error, an [errorType] and a

@@ -202,6 +202,14 @@ class DdRumMethodChannel extends DdRumPlatform {
     });
   }
 
+  @override
+  Future<void> reportAppFullyDisplayed() {
+    return methodChannel.invokeMethod(
+      'reportAppFullyDisplayed',
+      <String, Object?>{},
+    );
+  }
+
   @override
   Future<void> addErrorInfo(
     DateTime timestamp,

@@ -57,6 +57,11 @@ class DdNoOpRumPlatform extends DdRumPlatform {
     return Future.value();
   }
 
+  @override
+  Future<void> reportAppFullyDisplayed() {
+    return Future.value();
+  }
+
   @override
   Future<void> addAction(
     DateTime timestamp,

@@ -41,6 +41,7 @@ abstract class DdRumPlatform extends PlatformInterface {
   );
   Future<void> addTiming(DateTime timestamp, String name);
   Future<void> addViewLoadingTime(bool overwrite);
+  Future<void> reportAppFullyDisplayed();
 
   Future<void> startResource(
     DateTime timestamp,

@@ -210,6 +210,11 @@ class DdRumWeb extends DdRumPlatform {
     // NOOP - Not supported by the Browser SDK
   }
 
+  @override
+  Future<void> reportAppFullyDisplayed() async {
+    // NOOP - Not supported by the Browser SDK
+  }
+
   @override
   Future<void> addAction(
     DateTime timestamp,

@@ -150,6 +150,14 @@ void main() {
     ]);
   });
 
+  test('reportAppFullyDisplayed calls to platform', () async {
+    await ddRumPlatform.reportAppFullyDisplayed();
+
+    expect(log, [
+      isMethodCall('reportAppFullyDisplayed', arguments: <String, Object?>{}),
+    ]);
+  });
+
   test('startResource calls to platform', () async {
     final timestamp = randomTimestamp();
     await ddRumPlatform.startResource(