Update

flutter/lib/src/event_processor/native_app_start_event_processor.dart

@@ -1,3 +1,5 @@
+// ignore_for_file: invalid_use_of_internal_member
+
 import 'dart:async';
 
 import '../../sentry_flutter.dart';
@@ -78,7 +80,7 @@ class NativeAppStartEventProcessor implements EventProcessor {
         description: 'First frame render',
         parentSpanId: appStartSpan.context.spanId,
         traceId: transactionTraceId,
-        startTimestamp: SentryFlutter.dartLoadingEnd!,
+        startTimestamp: SentryFlutter.dartLoadingEnd,
         endTimestamp: appStartInfo.end);
 
     transaction.children.addAll([

flutter/lib/src/integrations/native_app_start_integration.dart

@@ -72,6 +72,7 @@ class NativeAppStartIntegration extends Integration<SentryFlutterOptions> {
         final appStartEnd = _native.appStartEnd;
         final nativeAppStart = await _native.fetchNativeAppStart();
         final engineEndtime = await _native.fetchEngineEndtime();
+        final dartLoadingEnd = SentryFlutter.dartLoadingEnd;
 
         if (nativeAppStart == null ||
             appStartEnd == null ||
@@ -104,7 +105,8 @@ class NativeAppStartIntegration extends Integration<SentryFlutterOptions> {
                 nativeAppStart.appStartTime.toInt()),
             end: appStartEnd,
             engineEnd: engineEndDatetime,
-            dartLoadingEnd: SentryFlutter.dartLoadingEnd!);
+            dartLoadingEnd: dartLoadingEnd);
+
         setAppStartInfo(appStartInfo);
       });
     }

flutter/lib/src/sentry_flutter.dart

@@ -34,8 +34,10 @@ typedef FlutterOptionsConfiguration = FutureOr<void> Function(
 mixin SentryFlutter {
   static const _channel = MethodChannel('sentry_flutter');
 
+  /// Represents the time when the dart isolate stopped loading and is ready to execute.
   @internal
-  static DateTime? dartLoadingEnd;
+  // ignore: invalid_use_of_internal_member
+  static DateTime dartLoadingEnd = getUtcDateTime();
 
   static Future<void> init(
     FlutterOptionsConfiguration optionsConfiguration, {
@@ -46,6 +48,7 @@ mixin SentryFlutter {
   }) async {
     final flutterOptions = SentryFlutterOptions();
 
+    // ignore: invalid_use_of_internal_member
     dartLoadingEnd = flutterOptions.clock();
 
     if (platformChecker != null) {

flutter/test/integrations/native_app_start_integration_test.dart

@@ -1,4 +1,5 @@
 @TestOn('vm')
+import 'package:collection/collection.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:mockito/mockito.dart';
 import 'package:sentry_flutter/sentry_flutter.dart';
@@ -109,6 +110,100 @@ void main() {
       expect(appStartInfo?.end, DateTime.fromMillisecondsSinceEpoch(10));
     });
   });
+
+  group('App start spans', () {
+    late SentrySpan? coldStartSpan,
+        engineReadySpan,
+        dartIsolateLoadingSpan,
+        firstFrameRenderSpan;
+    // ignore: invalid_use_of_internal_member
+    late SentryTracer tracer;
+    late Fixture fixture;
+
+    setUp(() async {
+      TestWidgetsFlutterBinding.ensureInitialized();
+
+      fixture = Fixture();
+      NativeAppStartIntegration.clearAppStartInfo();
+
+      fixture.native.appStartEnd = DateTime.fromMillisecondsSinceEpoch(50);
+      fixture.binding.nativeAppStart = NativeAppStart(0, true);
+      // dartLoadingEnd needs to be set after engine end (see MockNativeChannel)
+      SentryFlutter.dartLoadingEnd = DateTime.fromMillisecondsSinceEpoch(15);
+
+      fixture.getNativeAppStartIntegration().call(fixture.hub, fixture.options);
+
+      final processor = fixture.options.eventProcessors.first;
+      tracer = fixture.createTracer();
+      final transaction = SentryTransaction(tracer);
+      final enriched =
+          await processor.apply(transaction, Hint()) as SentryTransaction;
+
+      coldStartSpan = enriched.spans.firstWhereOrNull(
+          (element) => element.context.description == 'Cold start');
+      engineReadySpan = enriched.spans.firstWhereOrNull(
+          (element) => element.context.description == 'Engine init and ready');
+      dartIsolateLoadingSpan = enriched.spans.firstWhereOrNull(
+          (element) => element.context.description == 'Dart isolate loading');
+      firstFrameRenderSpan = enriched.spans.firstWhereOrNull(
+          (element) => element.context.description == 'First frame render');
+    });
+
+    test('are added by event processor', () async {
+      expect(coldStartSpan, isNotNull);
+      expect(engineReadySpan, isNotNull);
+      expect(dartIsolateLoadingSpan, isNotNull);
+      expect(firstFrameRenderSpan, isNotNull);
+    });
+
+    test('have correct op', () async {
+      const op = 'app.start.cold';
+      expect(coldStartSpan?.context.operation, op);
+      expect(engineReadySpan?.context.operation, op);
+      expect(dartIsolateLoadingSpan?.context.operation, op);
+      expect(firstFrameRenderSpan?.context.operation, op);
+    });
+
+    test('have correct parents', () async {
+      expect(coldStartSpan?.context.parentSpanId, tracer.context.spanId);
+      expect(
+          engineReadySpan?.context.parentSpanId, coldStartSpan?.context.spanId);
+      expect(dartIsolateLoadingSpan?.context.parentSpanId,
+          coldStartSpan?.context.spanId);
+      expect(firstFrameRenderSpan?.context.parentSpanId,
+          coldStartSpan?.context.spanId);
+    });
+
+    test('have correct traceId', () async {
+      final traceId = tracer.context.traceId;
+      expect(coldStartSpan?.context.traceId, traceId);
+      expect(engineReadySpan?.context.traceId, traceId);
+      expect(dartIsolateLoadingSpan?.context.traceId, traceId);
+      expect(firstFrameRenderSpan?.context.traceId, traceId);
+    });
+
+    test('have correct startTimestamp', () async {
+      final appStartTime = DateTime.fromMillisecondsSinceEpoch(
+              fixture.binding.nativeAppStart!.appStartTime.toInt())
+          .toUtc();
+      expect(coldStartSpan?.startTimestamp, appStartTime);
+      expect(engineReadySpan?.startTimestamp, appStartTime);
+      expect(dartIsolateLoadingSpan?.startTimestamp,
+          engineReadySpan?.endTimestamp);
+      expect(firstFrameRenderSpan?.startTimestamp,
+          dartIsolateLoadingSpan?.endTimestamp);
+    });
+
+    test('have correct endTimestamp', () async {
+      final engineEndtime = await fixture.native.fetchEngineEndtime();
+      expect(coldStartSpan?.endTimestamp, fixture.native.appStartEnd?.toUtc());
+      expect(engineReadySpan?.endTimestamp,
+          DateTime.fromMillisecondsSinceEpoch(engineEndtime!).toUtc());
+      expect(dartIsolateLoadingSpan?.endTimestamp,
+          SentryFlutter.dartLoadingEnd.toUtc());
+      expect(firstFrameRenderSpan?.endTimestamp, coldStartSpan?.endTimestamp);
+    });
+  });
 }
 
 class Fixture {

flutter/test/mocks.dart

@@ -294,6 +294,11 @@ class TestMockSentryNative implements SentryNative {
     numberOfDiscardProfilerCalls++;
     return Future.value(null);
   }
+
+  @override
+  Future<int?> fetchEngineEndtime() {
+    return Future.value(10);
+  }
 }
 
 // TODO can this be replaced with https://pub.dev/packages/mockito#verifying-exact-number-of-invocations--at-least-x--never
@@ -395,6 +400,11 @@ class MockNativeChannel implements SentryNativeBinding {
     numberOfDiscardProfilerCalls++;
     return Future.value(null);
   }
+
+  @override
+  Future<int?> fetchEngineEndtime() {
+    return Future.value(10);
+  }
 }
 
 class MockRendererWrapper implements RendererWrapper {

flutter/test/navigation/sentry_display_widget_test.dart

@@ -61,6 +61,8 @@ void main() {
       AppStartType.cold,
       start: getUtcDateTime().add(Duration(seconds: 1)),
       end: getUtcDateTime().add(Duration(seconds: 2)),
+      engineEnd: getUtcDateTime().add(Duration(seconds: 3)),
+      dartLoadingEnd: getUtcDateTime().add(Duration(seconds: 4)),
     );
     NativeAppStartIntegration.setAppStartInfo(appStartInfo);
 

flutter/test/sentry_navigator_observer_test.dart

@@ -501,6 +501,8 @@ void main() {
           AppStartType.cold,
           start: DateTime.now().add(const Duration(seconds: 1)),
           end: DateTime.now().add(const Duration(seconds: 2)),
+          engineEnd: DateTime.now().add(const Duration(seconds: 3)),
+          dartLoadingEnd: DateTime.now().add(const Duration(seconds: 4)),
         ),
       );