App start: native spans

CHANGELOG.md

@@ -5,6 +5,8 @@
 ### Features
 
 - Adds app start spans to first transaction ([#2009](https://github.com/getsentry/sentry-dart/pull/2009))
+- Set snapshot to `true` when Sentry attaches a stacktrace ([#2000](https://github.com/getsentry/sentry-dart/pull/2000)) 
+  - This may change grouping
 
 ## 8.1.0
 

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

@@ -23,6 +23,7 @@ import io.sentry.android.core.LoadClass
 import io.sentry.android.core.SentryAndroid
 import io.sentry.android.core.SentryAndroidOptions
 import io.sentry.android.core.performance.AppStartMetrics
+import io.sentry.android.core.performance.TimeSpan
 import io.sentry.protocol.DebugImage
 import io.sentry.protocol.SdkVersion
 import io.sentry.protocol.SentryId
@@ -71,10 +72,19 @@ class SentryFlutterPlugin : FlutterPlugin, MethodCallHandler, ActivityAware {
       "setTag" -> setTag(call.argument("key"), call.argument("value"), result)
       "removeTag" -> removeTag(call.argument("key"), result)
       "loadContexts" -> loadContexts(result)
+      "loadNativeData" -> loadNativeData()
       else -> result.notImplemented()
     }
   }
 
+  private fun loadNativeData() {
+    val appStartMetrics = AppStartMetrics.getInstance()
+
+    appStartMetrics.contentProviderOnCreateTimeSpans.forEach {
+      Log.d("noob", it.description.toString())
+    }
+  }
+
   override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
     if (!this::channel.isInitialized) {
       return
@@ -130,24 +140,63 @@ class SentryFlutterPlugin : FlutterPlugin, MethodCallHandler, ActivityAware {
       return
     }
 
-    val appStartTime = AppStartMetrics.getInstance().appStartTimeSpan.startTimestamp
-    val isColdStart =
-      AppStartMetrics.getInstance().appStartType == AppStartMetrics.AppStartType.COLD
+    val appStartMetrics = AppStartMetrics.getInstance()
+
+    val appStartTimeSpan = appStartMetrics.appStartTimeSpan
+    val appStartTime = appStartTimeSpan.startTimestamp
+    val isColdStart = appStartMetrics.appStartType == AppStartMetrics.AppStartType.COLD
 
     if (appStartTime == null) {
       Log.w("Sentry", "App start won't be sent due to missing appStartTime")
       result.success(null)
     } else {
       val appStartTimeMillis = DateUtils.nanosToMillis(appStartTime.nanoTimestamp().toDouble())
-      val item = mapOf<String, Any?>(
+      val item = mutableMapOf<String, Any?>(
         "pluginRegistrationTime" to pluginRegistrationTime,
         "appStartTime" to appStartTimeMillis,
         "isColdStart" to isColdStart,
       )
+
+      val androidNativeSpans = mutableMapOf<String, Any?>()
+
+      val processInitSpan = TimeSpan().apply {
+        description = "Process Initialization"
+        setStartUnixTimeMs(appStartTimeSpan.startTimestampMs)
+        setStartedAt(appStartTimeSpan.startUptimeMs)
+        setStoppedAt(appStartMetrics.classLoadedUptimeMs)
+      }
+      processInitSpan.addToMap(androidNativeSpans)
+
+      val applicationOnCreateSpan = appStartMetrics.applicationOnCreateTimeSpan
+      applicationOnCreateSpan.addToMap(androidNativeSpans)
+
+      val contentProviderSpans = appStartMetrics.contentProviderOnCreateTimeSpans
+      contentProviderSpans.forEach { span ->
+        span.addToMap(androidNativeSpans)
+      }
+
+      appStartMetrics.activityLifecycleTimeSpans.forEach { span ->
+        span.onCreate.addToMap(androidNativeSpans)
+        span.onStart.addToMap(androidNativeSpans)
+      }
+
+      item["nativeSpanTimes"] = androidNativeSpans
+
       result.success(item)
     }
   }
 
+  private fun TimeSpan.addToMap(map: MutableMap<String, Any?>) {
+    if (startTimestamp == null) return
+
+    description?.let { description ->
+      map[description] = mapOf<String, Any?>(
+        "startTimestampMsSinceEpoch" to startTimestampMs,
+        "stopTimestampMsSinceEpoch" to projectedStopTimestampMs,
+      )
+    }
+  }
+
   private fun beginNativeFrames(result: Result) {
     if (!sentryFlutter.autoPerformanceTracingEnabled) {
       result.success(null)

flutter/example/android/app/src/main/kotlin/io/sentry/samples/flutter/MyApplication.kt

@@ -0,0 +1,5 @@
+package io.sentry.samples.flutter
+
+import android.app.Application
+
+class MyApplication : Application()

flutter/example/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
     }
 
     dependencies {
-        classpath 'io.sentry:sentry-android-gradle-plugin:4.2.0'
+        classpath 'io.sentry:sentry-android-gradle-plugin:4.5.0'
         classpath 'com.android.tools.build:gradle:7.2.2'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath 'io.github.howardpang:androidNativeBundle:1.1.3'
@@ -32,4 +32,3 @@ subprojects {
 tasks.register("clean", Delete) {
     delete rootProject.buildDir
 }
-

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

@@ -379,6 +379,19 @@ public class SentryFlutterPluginApple: NSObject, FlutterPlugin {
         return
     }
 
+    struct TimeSpan {
+        var startTimestampMsSinceEpoch: NSNumber
+        var stopTimestampMsSinceEpoch: NSNumber
+        var description: String
+
+        func addToMap(_ map: inout [String: Any]) {
+            map[description] = [
+                "startTimestampMsSinceEpoch": startTimestampMsSinceEpoch,
+                "stopTimestampMsSinceEpoch": stopTimestampMsSinceEpoch
+            ]
+        }
+    }
+
     private func fetchNativeAppStart(result: @escaping FlutterResult) {
         #if os(iOS) || os(tvOS)
         guard let appStartMeasurement = PrivateSentrySDKOnly.appStartMeasurement else {
@@ -387,13 +400,53 @@ public class SentryFlutterPluginApple: NSObject, FlutterPlugin {
             return
         }
 
+        var nativeSpanTimes: [String: Any] = [:]
+
+        let appStartTimeMs = appStartMeasurement.appStartTimestamp.timeIntervalSince1970.toMilliseconds()
+        let runtimeInitTimeMs = appStartMeasurement.runtimeInitTimestamp.timeIntervalSince1970.toMilliseconds()
+        let moduleInitializationTimeMs =
+            appStartMeasurement.moduleInitializationTimestamp.timeIntervalSince1970.toMilliseconds()
+        let sdkStartTimeMs = appStartMeasurement.sdkStartTimestamp.timeIntervalSince1970.toMilliseconds()
+
+        if !appStartMeasurement.isPreWarmed {
+            let preRuntimeInitDescription = "Pre Runtime Init"
+            let preRuntimeInitSpan = TimeSpan(
+                startTimestampMsSinceEpoch: NSNumber(value: appStartTimeMs),
+                stopTimestampMsSinceEpoch: NSNumber(value: runtimeInitTimeMs),
+                description: preRuntimeInitDescription
+            )
+            preRuntimeInitSpan.addToMap(&nativeSpanTimes)
+
+            let moduleInitializationDescription = "Runtime init to Pre Main initializers"
+            let moduleInitializationSpan = TimeSpan(
+                startTimestampMsSinceEpoch: NSNumber(value: runtimeInitTimeMs),
+                stopTimestampMsSinceEpoch: NSNumber(value: moduleInitializationTimeMs),
+                description: moduleInitializationDescription
+            )
+            moduleInitializationSpan.addToMap(&nativeSpanTimes)
+        }
+
+        let uiKitInitDescription = "UIKit init"
+        let uiKitInitSpan = TimeSpan(
+            startTimestampMsSinceEpoch: NSNumber(value: moduleInitializationTimeMs),
+            stopTimestampMsSinceEpoch: NSNumber(value: sdkStartTimeMs),
+            description: uiKitInitDescription
+        )
+        uiKitInitSpan.addToMap(&nativeSpanTimes)
+
+        // Info: We don't have access to didFinishLaunchingTimestamp,
+        // On HybridSDKs, the Cocoa SDK misses the didFinishLaunchNotification and the
+        // didBecomeVisibleNotification. Therefore, we can't set the
+        // didFinishLaunchingTimestamp
+
         let appStartTime = appStartMeasurement.appStartTimestamp.timeIntervalSince1970 * 1000
         let isColdStart = appStartMeasurement.type == .cold
 
         let item: [String: Any] = [
             "pluginRegistrationTime": SentryFlutterPluginApple.pluginRegistrationTime,
             "appStartTime": appStartTime,
-            "isColdStart": isColdStart
+            "isColdStart": isColdStart,
+            "nativeSpanTimes": nativeSpanTimes
         ]
 
         result(item)
@@ -601,3 +654,9 @@ public class SentryFlutterPluginApple: NSObject, FlutterPlugin {
 }
 
 // swiftlint:enable function_body_length
+
+private extension TimeInterval {
+    func toMilliseconds() -> Int64 {
+        return Int64(self * 1000)
+    }
+}

flutter/lib/src/event_processor/native_app_start_event_processor.dart

@@ -54,6 +54,8 @@ class NativeAppStartEventProcessor implements EventProcessor {
         startTimestamp: appStartInfo.start,
         endTimestamp: appStartInfo.end);
 
+    await _attachNativeSpans(appStartInfo, transaction, appStartSpan);
+
     final pluginRegistrationSpan = await _createAndFinishSpan(
         tracer: transaction,
         operation: appStartInfo.appStartTypeOperation,
@@ -89,6 +91,28 @@ class NativeAppStartEventProcessor implements EventProcessor {
     ]);
   }
 
+  Future<void> _attachNativeSpans(AppStartInfo appStartInfo,
+      SentryTracer transaction, SentrySpan parent) async {
+    await Future.forEach<TimeSpan>(appStartInfo.nativeSpanTimes,
+        (timeSpan) async {
+      try {
+        final span = await _createAndFinishSpan(
+            tracer: transaction,
+            operation: appStartInfo.appStartTypeOperation,
+            description: timeSpan.description,
+            parentSpanId: parent.context.spanId,
+            traceId: transaction.context.traceId,
+            startTimestamp: timeSpan.start,
+            endTimestamp: timeSpan.end);
+        span.data.putIfAbsent('native', () => true);
+        transaction.children.add(span);
+      } catch (e) {
+        _hub.options.logger(SentryLevel.warning,
+            'Failed to attach native span to app start transaction: $e');
+      }
+    });
+  }
+
   Future<SentrySpan> _createAndFinishSpan({
     required SentryTracer tracer,
     required String operation,

flutter/lib/src/integrations/native_app_start_integration.dart

@@ -10,10 +10,13 @@ import '../event_processor/native_app_start_event_processor.dart';
 /// Integration which handles communication with native frameworks in order to
 /// enrich [SentryTransaction] objects with app start data for mobile vitals.
 class NativeAppStartIntegration extends Integration<SentryFlutterOptions> {
-  NativeAppStartIntegration(this._native, this._frameCallbackHandler);
+  NativeAppStartIntegration(this._native, this._frameCallbackHandler,
+      {Hub? hub})
+      : _hub = hub ?? HubAdapter();
 
   final SentryNative _native;
   final FrameCallbackHandler _frameCallbackHandler;
+  final Hub _hub;
 
   /// We filter out App starts more than 60s
   static const _maxAppStartMillis = 60000;
@@ -51,13 +54,15 @@ class NativeAppStartIntegration extends Integration<SentryFlutterOptions> {
   @override
   void call(Hub hub, SentryFlutterOptions options) {
     if (isIntegrationTest) {
-      final appStartInfo = AppStartInfo(AppStartType.cold,
-          start: DateTime.now(),
-          end: DateTime.now().add(const Duration(milliseconds: 100)),
-          pluginRegistration:
-              DateTime.now().add(const Duration(milliseconds: 50)),
-          mainIsolateStart:
-              DateTime.now().add(const Duration(milliseconds: 60)));
+      final appStartInfo = AppStartInfo(
+        AppStartType.cold,
+        start: DateTime.now(),
+        end: DateTime.now().add(const Duration(milliseconds: 100)),
+        pluginRegistration:
+            DateTime.now().add(const Duration(milliseconds: 50)),
+        mainIsolateStart: DateTime.now().add(const Duration(milliseconds: 60)),
+        nativeSpanTimes: [],
+      );
       setAppStartInfo(appStartInfo);
       return;
     }
@@ -101,12 +106,37 @@ class NativeAppStartIntegration extends Integration<SentryFlutterOptions> {
           return;
         }
 
+        List<TimeSpan> nativeSpanTimes = [];
+        for (final entry in nativeAppStart.nativeSpanTimes.entries) {
+          try {
+            final startTimestampMs =
+                entry.value['startTimestampMsSinceEpoch'] as int;
+            final endTimestampMs =
+                entry.value['stopTimestampMsSinceEpoch'] as int;
+            nativeSpanTimes.add(TimeSpan(
+              start: DateTime.fromMillisecondsSinceEpoch(startTimestampMs),
+              end: DateTime.fromMillisecondsSinceEpoch(endTimestampMs),
+              description: entry.key as String,
+            ));
+          } catch (e) {
+            // ignore: invalid_use_of_internal_member
+            _hub.options.logger(
+                SentryLevel.warning, 'Failed to parse native span times: $e');
+            continue;
+          }
+        }
+
+        // We want to sort because the native spans are not guaranteed to be in order.
+        // Performance wise this won't affect us since the native span amount is very low.
+        nativeSpanTimes.sort((a, b) => a.start.compareTo(b.start));
+
         final appStartInfo = AppStartInfo(
             nativeAppStart.isColdStart ? AppStartType.cold : AppStartType.warm,
             start: appStartDateTime,
             end: appStartEndDateTime,
             pluginRegistration: pluginRegistrationDateTime,
-            mainIsolateStart: mainIsolateStartDateTime);
+            mainIsolateStart: mainIsolateStartDateTime,
+            nativeSpanTimes: nativeSpanTimes);
 
         setAppStartInfo(appStartInfo);
       });
@@ -125,11 +155,13 @@ class AppStartInfo {
       {required this.start,
       required this.end,
       required this.pluginRegistration,
-      required this.mainIsolateStart});
+      required this.mainIsolateStart,
+      required this.nativeSpanTimes});
 
   final AppStartType type;
   final DateTime start;
   final DateTime end;
+  final List<TimeSpan> nativeSpanTimes;
   final DateTime pluginRegistration;
   final DateTime mainIsolateStart;
 
@@ -149,3 +181,11 @@ class AppStartInfo {
   final mainIsolateSetupDescription = 'Main isolate setup';
   final firstFrameRenderDescription = 'First frame render';
 }
+
+class TimeSpan {
+  TimeSpan({required this.start, required this.end, required this.description});
+
+  final DateTime start;
+  final DateTime end;
+  final String description;
+}

flutter/lib/src/native/sentry_native.dart

@@ -132,17 +132,20 @@ class NativeAppStart {
   NativeAppStart(
       {required this.appStartTime,
       required this.pluginRegistrationTime,
-      required this.isColdStart});
+      required this.isColdStart,
+      required this.nativeSpanTimes});
 
   double appStartTime;
   int pluginRegistrationTime;
   bool isColdStart;
+  Map<dynamic, dynamic> nativeSpanTimes;
 
   factory NativeAppStart.fromJson(Map<String, dynamic> json) {
     return NativeAppStart(
       appStartTime: json['appStartTime'] as double,
       pluginRegistrationTime: json['pluginRegistrationTime'] as int,
       isColdStart: json['isColdStart'] as bool,
+      nativeSpanTimes: json['nativeSpanTimes'] as Map<dynamic, dynamic>,
     );
   }
 }