refactor: fetch app start in integration instead of event processor

flutter/lib/src/event_processor/native_app_start_event_processor.dart

@@ -2,57 +2,29 @@ import 'dart:async';
 
 import 'package:sentry/sentry.dart';
 
-import '../native/sentry_native.dart';
+import '../integrations/integrations.dart';
 
 /// EventProcessor that enriches [SentryTransaction] objects with app start
 /// measurement.
 class NativeAppStartEventProcessor implements EventProcessor {
-  /// We filter out App starts more than 60s
-  static const _maxAppStartMillis = 60000;
+  NativeAppStartEventProcessor();
 
-  NativeAppStartEventProcessor(
-    this._native,
-  );
-
-  final SentryNative _native;
+  // We want the app start measurement to only be added once to the first transaction
+  bool _didAddAppStartMeasurement = false;
 
   @override
   Future<SentryEvent?> apply(SentryEvent event, {Hint? hint}) async {
-    final appStartEnd = _native.appStartEnd;
+    if (_didAddAppStartMeasurement || event is! SentryTransaction) {
+      return event;
+    }
 
-    if (appStartEnd != null &&
-        event is SentryTransaction &&
-        !_native.didFetchAppStart) {
-      final nativeAppStart = await _native.fetchNativeAppStart();
-      if (nativeAppStart == null) {
-        return event;
-      }
-      final measurement = nativeAppStart.toMeasurement(appStartEnd);
-      // We filter out app start more than 60s.
-      // This could be due to many different reasons.
-      // If you do the manual init and init the SDK too late and it does not
-      // compute the app start end in the very first Screen.
-      // If the process starts but the App isn't in the foreground.
-      // If the system forked the process earlier to accelerate the app start.
-      // And some unknown reasons that could not be reproduced.
-      // We've seen app starts with hours, days and even months.
-      if (measurement.value >= _maxAppStartMillis) {
-        return event;
-      }
+    final appStartInfo = await NativeAppStartIntegration.getAppStartInfo();
+    final measurement = appStartInfo?.toMeasurement();
+
+    if (measurement != null) {
       event.measurements[measurement.name] = measurement;
+      _didAddAppStartMeasurement = true;
     }
     return event;
   }
 }
-
-extension NativeAppStartMeasurement on NativeAppStart {
-  SentryMeasurement toMeasurement(DateTime appStartEnd) {
-    final appStartDateTime =
-        DateTime.fromMillisecondsSinceEpoch(appStartTime.toInt());
-    final duration = appStartEnd.difference(appStartDateTime);
-
-    return isColdStart
-        ? SentryMeasurement.coldAppStart(duration)
-        : SentryMeasurement.warmAppStart(duration);
-  }
-}

flutter/lib/src/frame_callback_handler.dart

@@ -0,0 +1,12 @@
+import 'package:flutter/scheduler.dart';
+
+abstract class FrameCallbackHandler {
+  void addPostFrameCallback(FrameCallback callback);
+}
+
+class DefaultFrameCallbackHandler implements FrameCallbackHandler {
+  @override
+  void addPostFrameCallback(FrameCallback callback) {
+    SchedulerBinding.instance.addPostFrameCallback(callback);
+  }
+}

flutter/lib/src/integrations/native_app_start_integration.dart

@@ -1,7 +1,9 @@
-import 'package:flutter/scheduler.dart';
-import 'package:sentry/sentry.dart';
+import 'dart:async';
 
-import '../sentry_flutter_options.dart';
+import 'package:meta/meta.dart';
+
+import '../../sentry_flutter.dart';
+import '../frame_callback_handler.dart';
 import '../native/sentry_native.dart';
 import '../event_processor/native_app_start_event_processor.dart';
 
@@ -13,6 +15,36 @@
   final SentryNative _native;
   final SchedulerBindingProvider _schedulerBindingProvider;
 
+  /// We filter out App starts more than 60s
+  static const _maxAppStartMillis = 60000;
+
+  static Completer<AppStartInfo?> _appStartCompleter =
+      Completer<AppStartInfo?>();
+  static AppStartInfo? _appStartInfo;
+
+  @internal
+  static void setAppStartInfo(AppStartInfo? appStartInfo) {
+    _appStartInfo = appStartInfo;
+    if (_appStartCompleter.isCompleted) {
+      _appStartCompleter = Completer<AppStartInfo?>();
+    }
+    _appStartCompleter.complete(appStartInfo);
+  }
+
+  @internal
+  static Future<AppStartInfo?> getAppStartInfo() {
+    if (_appStartInfo != null) {
+      return Future.value(_appStartInfo);
+    }
+    return _appStartCompleter.future;
+  }
+
+  @visibleForTesting
+  static void clearAppStartInfo() {
+    _appStartInfo = null;
+    _appStartCompleter = Completer<AppStartInfo?>();
+  }
+
   @override
   void call(Hub hub, SentryFlutterOptions options) {
     if (options.autoAppStart) {
@@ -21,18 +53,74 @@
         options.logger(SentryLevel.debug,
             'Scheduler binding is null. Can\'t auto detect app start time.');
       } else {
-        schedulerBinding.addPostFrameCallback((timeStamp) {
+        schedulerBinding.addPostFrameCallback((timeStamp) async {
+          if (_native.didFetchAppStart) {
+            setAppStartInfo(null);
+            return;
+          }
+
           // ignore: invalid_use_of_internal_member
-          _native.appStartEnd = options.clock();
+          // We only assign the current time if it's not already set - this is useful in tests
+          _native.appStartEnd ??= options.clock();
+          final appStartEnd = _native.appStartEnd;
+          final nativeAppStart = await _native.fetchNativeAppStart();
+
+          if (nativeAppStart == null || appStartEnd == null) {
+            setAppStartInfo(null);
+            return;
+          }
+
+          final appStartDateTime = DateTime.fromMillisecondsSinceEpoch(
+              nativeAppStart.appStartTime.toInt());
+          final duration = appStartEnd.difference(appStartDateTime);
+
+          // We filter out app start more than 60s.
+          // This could be due to many different reasons.
+          // If you do the manual init and init the SDK too late and it does not
+          // compute the app start end in the very first Screen.
+          // If the process starts but the App isn't in the foreground.
+          // If the system forked the process earlier to accelerate the app start.
+          // And some unknown reasons that could not be reproduced.
+          // We've seen app starts with hours, days and even months.
+          if (duration.inMilliseconds > _maxAppStartMillis) {
+            setAppStartInfo(null);
+            return;
+          }
+
+          final appStartInfo = AppStartInfo(
+              nativeAppStart.isColdStart
+                  ? AppStartType.cold
+                  : AppStartType.warm,
+              start: DateTime.fromMillisecondsSinceEpoch(
+                  nativeAppStart.appStartTime.toInt()),
+              end: appStartEnd);
+          setAppStartInfo(appStartInfo);
         });
       }
     }
 
-    options.addEventProcessor(NativeAppStartEventProcessor(_native));
+    options.addEventProcessor(NativeAppStartEventProcessor());
 
     options.sdk.addIntegration('nativeAppStartIntegration');
   }
 }
 
 /// Used to provide scheduler binding at call time.
-typedef SchedulerBindingProvider = SchedulerBinding? Function();
+typedef SchedulerBindingProvider = FrameCallbackHandler? Function();
+
+enum AppStartType { cold, warm }
+
+class AppStartInfo {
+  AppStartInfo(this.type, {required this.start, required this.end});
+
+  final AppStartType type;
+  final DateTime start;
+  final DateTime end;
+
+  SentryMeasurement toMeasurement() {
+    final duration = end.difference(start);
+    return type == AppStartType.cold
+        ? SentryMeasurement.coldAppStart(duration)
+        : SentryMeasurement.warmAppStart(duration);
+  }
+}

flutter/lib/src/sentry_flutter.dart

@@ -1,14 +1,14 @@
 import 'dart:async';
 import 'dart:ui';
 
-import 'package:flutter/scheduler.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter/widgets.dart';
 import 'package:meta/meta.dart';
 import '../sentry_flutter.dart';
 import 'event_processor/android_platform_exception_event_processor.dart';
 import 'event_processor/flutter_exception_event_processor.dart';
 import 'event_processor/platform_exception_event_processor.dart';
+import 'frame_callback_handler.dart';
 import 'integrations/connectivity/connectivity_integration.dart';
 import 'integrations/screenshot_integration.dart';
 import 'native/factory.dart';
@@ -192,7 +192,7 @@ mixin SentryFlutter {
         () {
           try {
             /// Flutter >= 2.12 throws if SchedulerBinding.instance isn't initialized.
-            return SchedulerBinding.instance;
+            return DefaultFrameCallbackHandler();
           } catch (_) {}
           return null;
         },

flutter/test/fake_frame_callback_handler.dart

@@ -0,0 +1,18 @@
+import 'package:flutter/scheduler.dart';
+import 'package:sentry_flutter/src/frame_callback_handler.dart';
+
+class FakeFrameCallbackHandler implements FrameCallbackHandler {
+  FrameCallback? storedCallback;
+
+  final Duration _finishAfterDuration;
+
+  FakeFrameCallbackHandler(
+      {Duration finishAfterDuration = const Duration(milliseconds: 500)})
+      : _finishAfterDuration = finishAfterDuration;
+
+  @override
+  void addPostFrameCallback(FrameCallback callback) async {
+    await Future.delayed(_finishAfterDuration);
+    callback(Duration.zero);
+  }
+}

flutter/test/integrations/native_app_start_integration_test.dart

@@ -1,12 +1,12 @@
 @TestOn('vm')
-
 import 'package:flutter_test/flutter_test.dart';
 import 'package:mockito/mockito.dart';
 import 'package:sentry_flutter/sentry_flutter.dart';
 import 'package:sentry_flutter/src/integrations/native_app_start_integration.dart';
 import 'package:sentry_flutter/src/native/sentry_native.dart';
 import 'package:sentry/src/sentry_tracer.dart';
 
+import '../fake_frame_callback_handler.dart';
 import '../mocks.dart';
 import '../mocks.mocks.dart';
 
@@ -18,10 +18,10 @@ void main() {
       TestWidgetsFlutterBinding.ensureInitialized();
 
       fixture = Fixture();
+      NativeAppStartIntegration.clearAppStartInfo();
     });
 
     test('native app start measurement added to first transaction', () async {
-      fixture.options.autoAppStart = false;
       fixture.native.appStartEnd = DateTime.fromMillisecondsSinceEpoch(10);
       fixture.binding.nativeAppStart = NativeAppStart(0, true);
 
@@ -40,7 +40,6 @@ void main() {
 
     test('native app start measurement not added to following transactions',
         () async {
-      fixture.options.autoAppStart = false;
       fixture.native.appStartEnd = DateTime.fromMillisecondsSinceEpoch(10);
       fixture.binding.nativeAppStart = NativeAppStart(0, true);
 
@@ -58,7 +57,6 @@ void main() {
     });
 
     test('measurements appended', () async {
-      fixture.options.autoAppStart = false;
       fixture.native.appStartEnd = DateTime.fromMillisecondsSinceEpoch(10);
       fixture.binding.nativeAppStart = NativeAppStart(0, true);
       final measurement = SentryMeasurement.warmAppStart(Duration(seconds: 1));
@@ -79,7 +77,6 @@ void main() {
     });
 
     test('native app start measurement not added if more than 60s', () async {
-      fixture.options.autoAppStart = false;
       fixture.native.appStartEnd = DateTime.fromMillisecondsSinceEpoch(60001);
       fixture.binding.nativeAppStart = NativeAppStart(0, true);
 
@@ -111,7 +108,8 @@ class Fixture {
     return NativeAppStartIntegration(
       native,
       () {
-        return TestWidgetsFlutterBinding.ensureInitialized();
+        TestWidgetsFlutterBinding.ensureInitialized();
+        return FakeFrameCallbackHandler();
       },
     );
   }