working ttid and ttfd for non root app start navigations

Author: buenaflor

flutter/example/lib/main.dart

@@ -77,6 +77,7 @@ Future<void> setupSentry(AppRunner appRunner, String dsn,
     // going to log too much for your app, but can be useful when figuring out
     // configuration issues, e.g. finding out why your events are not uploaded.
     options.debug = true;
+    options.enableTimeToFullDisplayTracing = true;
 
     options.maxRequestBodySize = MaxRequestBodySize.always;
     options.maxResponseBodySize = MaxResponseBodySize.always;

flutter/lib/src/navigation/navigation_timing_manager.dart

@@ -45,12 +45,6 @@ class NavigationTimingManager {
   }
 
   void startMeasurement(String routeName) async {
-    final options = _hub.options is SentryFlutterOptions
-        // ignore: invalid_use_of_internal_member
-        ? _hub.options as SentryFlutterOptions
-        : null;
-
-    // This marks the start timestamp of both TTID and TTFD spans
     _startTimestamp = DateTime.now();
 
     // This has multiple branches
@@ -62,107 +56,106 @@ class NavigationTimingManager {
       // App start - this is a special edge case that only happens once
       AppStartTracker().onAppStartComplete((appStartInfo) {
         // Create a transaction based on app start start time
-        // Create ttidSpan and finish immediately with the app start start & end time
-        // This is a small workaround to pass the correct time stamps since we mutate
+        // Then create ttidSpan and finish immediately with the app start start & end time
+        // This is a small workaround to pass the correct time stamps since we cannot mutate
         // timestamps of transactions or spans in history
         if (appStartInfo != null) {
           final transaction = _transactionManager?.startTransaction(
               routeName, appStartInfo.start);
           if (transaction != null) {
-            final ttidSpan = _startTimeToInitialDisplaySpan(
-                routeName, transaction, appStartInfo.start);
+            final ttidSpan = _createTTIDSpan(transaction, routeName, appStartInfo.start);
             ttidSpan.finish(endTimestamp: appStartInfo.end);
           }
         }
       });
     } else {
-      DateTime? approximationEndTime;
-      final endTimeCompleter = Completer<DateTime>();
       final transaction =
           _transactionManager?.startTransaction(routeName, _startTimestamp!);
 
-      if (transaction != null) {
-        if (options?.enableTimeToFullDisplayTracing == true) {
-          _ttfdSpan = transaction.startChild('ui.load.full_display',
-              description: '$routeName full display',
-              startTimestamp: _startTimestamp!);
-
-          _ttfdSpan = _startTimeToFullDisplaySpan(
-              routeName, transaction, _startTimestamp!);
-        }
-        _ttidSpan = _startTimeToInitialDisplaySpan(
-            routeName, transaction, _startTimestamp!);
+      if (transaction == null) {
+        return;
       }
 
-      SchedulerBinding.instance.addPostFrameCallback((timeStamp) {
-        approximationEndTime = DateTime.now();
-        endTimeCompleter.complete(approximationEndTime);
-      });
+      _initializeSpans(transaction, routeName, _startTimestamp!);
 
-      final strategyDecision =
-          await SentryDisplayTracker().decideStrategyWithTimeout2(routeName);
-
-      switch (strategyDecision) {
-        case StrategyDecision.manual:
-          final endTimestamp = DateTime.now();
-          final duration = endTimestamp.millisecondsSinceEpoch -
-              _startTimestamp!.millisecondsSinceEpoch;
-          _endTimeToInitialDisplaySpan(_ttidSpan!, transaction!, endTimestamp, duration);
-          break;
-        case StrategyDecision.approximation:
-          if (approximationEndTime == null) {
-            await endTimeCompleter.future;
-          }
-          final duration = approximationEndTime!.millisecondsSinceEpoch -
-              _startTimestamp!.millisecondsSinceEpoch;
-          _endTimeToInitialDisplaySpan(
-              _ttidSpan!, transaction!, approximationEndTime!, duration);
-          await _ttidSpan?.finish(endTimestamp: approximationEndTime);
-          break;
-        default:
-          print('Unknown strategy decision: $strategyDecision');
-      }
+      final endTimestamp = await _determineEndTime(routeName);
+
+      final duration = endTimestamp.difference(_startTimestamp!).inMilliseconds;
+      _finishSpan(_ttidSpan!, transaction, 'time_to_initial_display', duration,
+          endTimestamp);
     }
   }
 
+  Future<DateTime> _determineEndTime(String routeName) async {
+    DateTime? approximationEndTime;
+    final endTimeCompleter = Completer<DateTime>();
+
+    SchedulerBinding.instance.addPostFrameCallback((_) {
+      approximationEndTime = DateTime.now();
+      endTimeCompleter.complete(approximationEndTime!);
+    });
+
+    final strategyDecision =
+        await SentryDisplayTracker().decideStrategyWithTimeout2(routeName);
+
+    if (strategyDecision == StrategyDecision.manual &&
+        !endTimeCompleter.isCompleted) {
+      approximationEndTime = DateTime.now();
+      endTimeCompleter.complete(approximationEndTime);
+    } else if (!endTimeCompleter.isCompleted) {
+      // If the decision is not manual and the completer hasn't been completed, await it.
+      await endTimeCompleter.future;
+    }
+
+    return approximationEndTime!;
+  }
+
   void reportInitiallyDisplayed(String routeName) {
     SentryDisplayTracker().reportManual2(routeName);
   }
 
   void reportFullyDisplayed() {
-    final endTime = DateTime.now();
+    final endTimestamp = DateTime.now();
     final transaction = Sentry.getSpan();
-    final duration = endTime.millisecondsSinceEpoch -
-        _startTimestamp!.millisecondsSinceEpoch;
-    if (_ttfdSpan != null && transaction != null) {
-      _endTimeToFullDisplaySpan(_ttfdSpan!, transaction, endTime, duration);
+    final duration = endTimestamp.difference(_startTimestamp!).inMilliseconds;
+    if (_ttidSpan == null || transaction == null) {
+      return;
     }
+    _finishSpan(_ttfdSpan!, transaction, 'time_to_full_display', duration, endTimestamp);
   }
 
-  static ISentrySpan _startTimeToInitialDisplaySpan(
-      String routeName, ISentrySpan transaction, DateTime startTimestamp) {
-    return transaction.startChild(SentryTraceOrigins.uiTimeToInitialDisplay,
-        description: '$routeName initial display',
-        startTimestamp: startTimestamp);
+  void _initializeSpans(ISentrySpan? transaction, String routeName, DateTime startTimestamp) {
+    final options = _hub.options is SentryFlutterOptions
+        // ignore: invalid_use_of_internal_member
+        ? _hub.options as SentryFlutterOptions
+        : null;
+    if (transaction == null) return;
+    _ttidSpan = _createTTIDSpan(transaction, routeName, startTimestamp);
+    if (options?.enableTimeToFullDisplayTracing == true) {
+      _ttfdSpan = _createTTFDSpan(transaction, routeName, startTimestamp);
+    }
   }
 
-  static ISentrySpan _startTimeToFullDisplaySpan(
-      String routeName, ISentrySpan transaction, DateTime startTimestamp) {
-    return transaction.startChild(SentryTraceOrigins.uiTimeToFullDisplay,
-        description: '$routeName full display', startTimestamp: startTimestamp);
+  ISentrySpan _createTTIDSpan(ISentrySpan transaction, String routeName, DateTime startTimestamp) {
+    return transaction.startChild(
+      SentryTraceOrigins.uiTimeToInitialDisplay,
+      description: '$routeName initial display',
+      startTimestamp: startTimestamp,
+    );
   }
 
-  static void _endTimeToInitialDisplaySpan(ISentrySpan ttidSpan,
-      ISentrySpan transaction, DateTime endTimestamp, int duration) async {
-    transaction.setMeasurement('time_to_initial_display', duration,
-        unit: DurationSentryMeasurementUnit.milliSecond);
-    await ttidSpan.finish(endTimestamp: endTimestamp);
+  ISentrySpan _createTTFDSpan(ISentrySpan transaction, String routeName, DateTime startTimestamp) {
+    return transaction.startChild(
+      SentryTraceOrigins.uiTimeToFullDisplay,
+      description: '$routeName full display',
+      startTimestamp: startTimestamp,
+    );
   }
 
-  static void _endTimeToFullDisplaySpan(ISentrySpan ttfdSpan,
-      ISentrySpan transaction, DateTime endTimestamp, int duration) async {
-    transaction.setMeasurement('time_to_full_display', duration,
+  void _finishSpan(ISentrySpan span, ISentrySpan transaction,
+      String measurementName, int duration, DateTime endTimestamp) {
+    transaction.setMeasurement(measurementName, duration,
         unit: DurationSentryMeasurementUnit.milliSecond);
-    await ttfdSpan.finish(endTimestamp: endTimestamp);
+    span.finish(endTimestamp: endTimestamp);
   }
 }

flutter/lib/src/sentry_widget.dart

@@ -143,5 +143,4 @@ class SentryDisplayTracker {
 enum StrategyDecision {
   manual,
   approximation,
-  undecided,
 }