Initial

flutter/android/src/main/kotlin/io/sentry/flutter/SentryFlutterPlugin.kt

@@ -127,7 +127,25 @@ class SentryFlutterPlugin : FlutterPlugin, MethodCallHandler, ActivityAware {
       return
     }
 
-    val appStartTime = AppStartMetrics.getInstance().appStartTimeSpan.startTimestamp
+    val appStartMetrics = AppStartMetrics.getInstance()
+
+    val applicationOnCreateStartTime = appStartMetrics.applicationOnCreateTimeSpan.startTimestamp
+    println("ok?: ${appStartMetrics.appStartTimeSpan.startUptimeMs}")
+
+    val classInitUptimeMs = appStartMetrics.classLoadedUptimeMs
+    val appStartUptimeMs = appStartMetrics.appStartTimeSpan.startUptimeMs
+    val appStartTime = appStartMetrics.appStartTimeSpan.startTimestamp
+    val contentProviderOnCreates = appStartMetrics.contentProviderOnCreateTimeSpans
+    println(contentProviderOnCreates.isEmpty())
+    println("haha");
+    contentProviderOnCreates.forEach {
+      println("contentProviderOnCreates: ${it.startTimestamp}")
+      println("contentProviderOnCreates: ${it.projectedStopTimestamp}")
+      println("")
+    }
+    val appl = appStartMetrics.applicationOnCreateTimeSpan
+//    AppStartMetrics.onApplicationPostCreate()
+    print("appl: ${appl.startTimestamp} ${appl.startTimestampMs} ${appl.hasStopped()}")
     val isColdStart =
       AppStartMetrics.getInstance().appStartType == AppStartMetrics.AppStartType.COLD
 
@@ -136,10 +154,23 @@ class SentryFlutterPlugin : FlutterPlugin, MethodCallHandler, ActivityAware {
       result.success(null)
     } else {
       val appStartTimeMillis = DateUtils.nanosToMillis(appStartTime.nanoTimestamp().toDouble())
-      val item = mapOf<String, Any?>(
+      val item = mutableMapOf<String, Any?>(
         "appStartTime" to appStartTimeMillis,
         "isColdStart" to isColdStart,
       )
+      println("ok?: ${classInitUptimeMs - appStartMetrics.appStartTimeSpan.startUptimeMs}");
+//      if (applicationOnCreateStartTime != null) {
+//        println("is not null");
+//        val applicationOnCreateTimeMillis =
+//          DateUtils.nanosToMillis(applicationOnCreateStartTime.nanoTimestamp().toDouble())
+//        item["applicationOnCreateTime"] = mapOf("test" to "test")
+//      }
+      item["nativeSpanTimes"] = mapOf<String, Any?>(
+        "classInitUptimeMs" to classInitUptimeMs,
+        "appStartUptimeMs" to appStartUptimeMs,
+      )
+
+
       result.success(item)
     }
   }

flutter/example/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "1430"
+   LastUpgradeVersion = "1510"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"

flutter/example/lib/main.dart

@@ -83,7 +83,7 @@ Future<void> setupSentry(
       // configuration issues, e.g. finding out why your events are not uploaded.
       options.debug = true;
       options.spotlight = Spotlight(enabled: true);
-      options.enableTimeToFullDisplayTracing = true;
+      // options.enableTimeToFullDisplayTracing = true;
       options.enableMetrics = true;
 
       options.maxRequestBodySize = MaxRequestBodySize.always;

flutter/ios/Classes/SentryFlutterPluginApple.swift

@@ -382,13 +382,26 @@ public class SentryFlutterPluginApple: NSObject, FlutterPlugin {
             result(nil)
             return
         }
+
+        let runtimeInitTimestamp = appStartMeasurement.runtimeInitTimestamp.timeIntervalSince1970 * 1000
+        let moduleInitTimestamp = appStartMeasurement.moduleInitializationTimestamp.timeIntervalSince1970 * 1000
+        let sdkStartTimestamp = appStartMeasurement.sdkStartTimestamp.timeIntervalSince1970 * 1000
+        let didFinishLaunchingTimestamp = appStartMeasurement.didFinishLaunchingTimestamp.timeIntervalSince1970 * 1000
+
+        let nativeSpanTimes: [String: Any] = [
+            "runtimeInitTimestamp": runtimeInitTimestamp,
+            "moduleInitTimestamp": moduleInitTimestamp,
+            "sdkStartTimestamp": sdkStartTimestamp,
+            "didFinishLaunchingTimestamp": didFinishLaunchingTimestamp
+        ]
 
         let appStartTime = appStartMeasurement.appStartTimestamp.timeIntervalSince1970 * 1000
         let isColdStart = appStartMeasurement.type == .cold
 
         let item: [String: Any] = [
             "appStartTime": appStartTime,
-            "isColdStart": isColdStart
+            "isColdStart": isColdStart,
+            "nativeSpanTimes": nativeSpanTimes
         ]
 
         result(item)

flutter/lib/src/event_processor/native_app_start_event_processor.dart

@@ -5,12 +5,19 @@ import 'package:sentry/sentry.dart';
 import '../integrations/integrations.dart';
 import '../native/sentry_native.dart';
 
+// ignore: implementation_imports
+import 'package:sentry/src/sentry_tracer.dart';
+
 /// EventProcessor that enriches [SentryTransaction] objects with app start
 /// measurement.
 class NativeAppStartEventProcessor implements EventProcessor {
   final SentryNative _native;
+  final Hub _hub;
 
-  NativeAppStartEventProcessor(this._native);
+  NativeAppStartEventProcessor(
+    this._native, {
+    Hub? hub,
+  }) : _hub = hub ?? HubAdapter();
 
   @override
   Future<SentryEvent?> apply(SentryEvent event, Hint hint) async {
@@ -25,6 +32,117 @@ class NativeAppStartEventProcessor implements EventProcessor {
       event.measurements[measurement.name] = measurement;
       _native.didAddAppStartMeasurement = true;
     }
+
+    final transaction = event.tracer;
+
+    if (appStartInfo == null) {
+      return event;
+    }
+
+    final classInitUptimeMs =
+        appStartInfo.nativeSpanTimes['classInitUptimeMs'] as int?;
+    final appStartUptimeMs =
+        appStartInfo.nativeSpanTimes['appStartUptimeMs'] as int?;
+    final runTimeInitTimestamp =
+        appStartInfo.nativeSpanTimes['runtimeInitTimestamp'] as double?;
+    final moduleInitTimestamp =
+    appStartInfo.nativeSpanTimes['moduleInitTimestamp'] as double?;
+    final sdkStartTimestamp = appStartInfo.nativeSpanTimes['sdkStartTimestamp'] as double?;
+    final didFinishLaunchingTimestamp = appStartInfo.nativeSpanTimes['didFinishLaunchingTimestamp'] as double?;
+
+    if (runTimeInitTimestamp != null && moduleInitTimestamp != null && sdkStartTimestamp != null && didFinishLaunchingTimestamp != null) {
+      final aa = DateTime.fromMillisecondsSinceEpoch(runTimeInitTimestamp.toInt());
+      final bb = DateTime.fromMillisecondsSinceEpoch(moduleInitTimestamp.toInt());
+      final sdkStart = DateTime.fromMillisecondsSinceEpoch(sdkStartTimestamp.toInt());
+      // final didFinishLaunching = DateTime.fromMillisecondsSinceEpoch(didFinishLaunchingTimestamp.toInt());
+
+      final preRuntimeInitSpan = await _createAndFinishSpan(
+          tracer: transaction,
+          operation: 'ui.load',
+          description: 'Pre runtime init',
+          parentSpanId: transaction.context.spanId,
+          traceId: transaction.context.traceId,
+          startTimestamp: appStartInfo.start,
+          endTimestamp: aa);
+
+      final runtimeInitSpan = await _createAndFinishSpan(
+          tracer: transaction,
+          operation: 'ui.load',
+          description: 'Runtime init',
+          parentSpanId: transaction.context.spanId,
+          traceId: transaction.context.traceId,
+          startTimestamp: aa,
+          endTimestamp: bb);
+
+      final appInitSpan = await _createAndFinishSpan(
+          tracer: transaction,
+          operation: 'ui.load',
+          description: 'UIKit init',
+          parentSpanId: transaction.context.spanId,
+          traceId: transaction.context.traceId,
+          startTimestamp: bb,
+          endTimestamp: sdkStart);
+
+      final didFinishLaunchingSpan = await _createAndFinishSpan(
+          tracer: transaction,
+          operation: 'ui.load',
+          description: 'Application init',
+          parentSpanId: transaction.context.spanId,
+          traceId: transaction.context.traceId,
+          startTimestamp: sdkStart,
+          endTimestamp: appStartInfo.end);
+
+      transaction.children.addAll([
+        preRuntimeInitSpan,
+        runtimeInitSpan,
+        appInitSpan,
+        didFinishLaunchingSpan,
+      ]);
+    }
+
+    print('classInitUptimeMs: $classInitUptimeMs');
+
+    if (classInitUptimeMs != null && appStartUptimeMs != null) {
+      final duration = classInitUptimeMs - appStartUptimeMs;
+
+      final classInitSpan = await _createAndFinishSpan(
+          tracer: transaction,
+          operation: 'ui.load',
+          description: 'Class init',
+          parentSpanId: transaction.context.spanId,
+          traceId: transaction.context.traceId,
+          startTimestamp: appStartInfo.start,
+          endTimestamp:
+              appStartInfo.start.add(Duration(milliseconds: duration)));
+
+      transaction.children.addAll([
+        classInitSpan,
+      ]);
+    }
+
     return event;
   }
+
+  Future<SentrySpan> _createAndFinishSpan({
+    required SentryTracer tracer,
+    required String operation,
+    required String description,
+    required SpanId? parentSpanId,
+    required SentryId? traceId,
+    required DateTime startTimestamp,
+    required DateTime endTimestamp,
+  }) async {
+    final span = SentrySpan(
+        tracer,
+        SentrySpanContext(
+          operation: operation,
+          description: description,
+          parentSpanId: parentSpanId,
+          traceId: traceId,
+        ),
+        _hub,
+        startTimestamp: startTimestamp);
+    await span.finish(endTimestamp: endTimestamp);
+    return span;
+  }
 }

flutter/lib/src/integrations/native_app_start_integration.dart

@@ -53,7 +53,8 @@ class NativeAppStartIntegration extends Integration<SentryFlutterOptions> {
     if (isIntegrationTest) {
       final appStartInfo = AppStartInfo(AppStartType.cold,
           start: DateTime.now(),
-          end: DateTime.now().add(const Duration(milliseconds: 100)));
+          end: DateTime.now().add(const Duration(milliseconds: 100)),
+          nativeSpanTimes: {});
       setAppStartInfo(appStartInfo);
       return;
     }
@@ -95,7 +96,8 @@ class NativeAppStartIntegration extends Integration<SentryFlutterOptions> {
             nativeAppStart.isColdStart ? AppStartType.cold : AppStartType.warm,
             start: DateTime.fromMillisecondsSinceEpoch(
                 nativeAppStart.appStartTime.toInt()),
-            end: appStartEnd);
+            end: appStartEnd,
+            nativeSpanTimes: nativeAppStart.nativeSpanTimes);
         setAppStartInfo(appStartInfo);
       });
     }
@@ -109,11 +111,14 @@ class NativeAppStartIntegration extends Integration<SentryFlutterOptions> {
 enum AppStartType { cold, warm }
 
 class AppStartInfo {
-  AppStartInfo(this.type, {required this.start, required this.end});
+  AppStartInfo(this.type,
+      {required this.start, required this.end, required this.nativeSpanTimes});
 
   final AppStartType type;
   final DateTime start;
   final DateTime end;
+  final Map<dynamic, dynamic> nativeSpanTimes;
+
   Duration get duration => end.difference(start);
 
   SentryMeasurement toMeasurement() {

flutter/lib/src/native/sentry_native.dart

@@ -129,15 +129,17 @@ class SentryNative {
 }
 
 class NativeAppStart {
-  NativeAppStart(this.appStartTime, this.isColdStart);
+  NativeAppStart(this.appStartTime, this.isColdStart, this.nativeSpanTimes);
 
   double appStartTime;
   bool isColdStart;
+  Map<dynamic, dynamic> nativeSpanTimes;
 
   factory NativeAppStart.fromJson(Map<String, dynamic> json) {
     return NativeAppStart(
       json['appStartTime'] as double,
       json['isColdStart'] as bool,
+      json['nativeSpanTimes'] as Map<dynamic, dynamic>,
     );
   }
 }