feat: Standalone app start tracing

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Features
+
+- Add standalone app start tracing as an experimental option (#7660), enable it via `options.experimental.enableStandaloneAppStartTracing = true`
+
 ## 9.13.0
 
 ### Fixes
@@ -9,6 +15,7 @@
 
 ### Features
 
+- Prevent memory strings in stack overflow crash reports (#7841)
 - Add Set conformance to SentryAttributeValue (#7876)
 
 ## 9.12.1

Samples/SentrySampleShared/SentrySampleShared/SentrySDKOverrides.swift

@@ -93,6 +93,7 @@ public enum SentrySDKOverrides: String, CaseIterable {
         case disableWatchdogTracking            = "--io.sentry.performance.disable-watchdog-tracking"
         case disableUITracing                   = "--io.sentry.performance.disable-ui-tracing"
         case disablePrewarmedAppStartTracing    = "--io.sentry.performance.disable-prewarmed-app-start-tracing"
+        case enableStandaloneAppStartTracing    = "--io.sentry.performance.enable-standalone-app-start-tracing"
         case disablePerformanceTracing          = "--io.sentry.performance.disable-auto-performance-tracing"
         case sessionTrackingIntervalMillis      = "--io.sentry.performance.sessionTrackingIntervalMillis"
     }
@@ -312,7 +313,7 @@ extension SentrySDKOverrides.Other {
 extension SentrySDKOverrides.Performance {
     public var overrideType: OverrideType {
         switch self {
-        case .disableTimeToFullDisplayTracing, .disableSessionTracking, .disableFileIOTracing, .disableUIVCTracing, .disableCoreDataTracing, .disableANRTracking, .disableWatchdogTracking, .disableUITracing, .disablePrewarmedAppStartTracing, .disablePerformanceTracing: return .boolean
+        case .disableTimeToFullDisplayTracing, .disableSessionTracking, .disableFileIOTracing, .disableUIVCTracing, .disableCoreDataTracing, .disableANRTracking, .disableWatchdogTracking, .disableUITracing, .disablePrewarmedAppStartTracing, .enableStandaloneAppStartTracing, .disablePerformanceTracing: return .boolean
         case .sessionTrackingIntervalMillis: return .string
         }
     }
@@ -408,7 +409,7 @@ extension SentrySDKOverrides.Other {
 extension SentrySDKOverrides.Performance {
     public var ignoresDisableEverything: Bool {
         switch self {
-        case .disableTimeToFullDisplayTracing, .disableSessionTracking, .disableFileIOTracing, .disableUIVCTracing, .disableCoreDataTracing, .disableANRTracking, .disableWatchdogTracking, .disableUITracing, .disablePrewarmedAppStartTracing, .disablePerformanceTracing: return false
+        case .disableTimeToFullDisplayTracing, .disableSessionTracking, .disableFileIOTracing, .disableUIVCTracing, .disableCoreDataTracing, .disableANRTracking, .disableWatchdogTracking, .disableUITracing, .disablePrewarmedAppStartTracing, .enableStandaloneAppStartTracing, .disablePerformanceTracing: return false
         case .sessionTrackingIntervalMillis: return true
         }
     }

Samples/SentrySampleShared/SentrySampleShared/SentrySDKWrapper.swift

@@ -124,6 +124,7 @@ public struct SentrySDKWrapper {
         options.enableUserInteractionTracing = !isBenchmarking && !SentrySDKOverrides.Performance.disableUITracing.boolValue
 
         options.enablePreWarmedAppStartTracing = !isBenchmarking && !SentrySDKOverrides.Performance.disablePrewarmedAppStartTracing.boolValue
+        options.experimental.enableStandaloneAppStartTracing = SentrySDKOverrides.Performance.enableStandaloneAppStartTracing.boolValue
         options.enableUIViewControllerTracing = !SentrySDKOverrides.Performance.disableUIVCTracing.boolValue
 
         // -- Screenshot Options --

Samples/Shared/feature-flags.yml

@@ -55,6 +55,7 @@ schemeTemplates:
         "--io.sentry.performance.disable-file-io-tracing": false
         "--io.sentry.performance.disable-automatic-session-tracking": false
         "--io.sentry.performance.disable-watchdog-tracking": false
+        "--io.sentry.performance.enable-standalone-app-start-tracing": false
         "--io.sentry.tracing.disable-tracing": false
         "--io.sentry.performance.disable-core-data-tracing": false
         "--io.sentry.performance.disable-uiviewcontroller-tracing": false

Sources/Sentry/SentryAppStartMeasurementProvider.m

@@ -4,6 +4,7 @@
 
 #    import "PrivateSentrySDKOnly.h"
 #    import "SentryAppStartMeasurement.h"
+#    import "SentryId.h"
 #    import "SentryInternalCDefines.h"
 #    import "SentryInternalDefines.h"
 #    import "SentryLogC.h"
@@ -21,6 +22,8 @@
 
 static NSObject *appStartMeasurementLock;
 static BOOL appStartMeasurementRead;
+static SentryId *_Nullable appStartTraceId;
+static NSString *_Nullable appStartScreen;
 
 @implementation SentryAppStartMeasurementProvider
 
@@ -94,10 +97,51 @@ + (nullable SentryAppStartMeasurement *)appStartMeasurementForOperation:(NSStrin
     return measurement;
 }
 
++ (void)markAsRead
+{
+    @synchronized(appStartMeasurementLock) {
+        appStartMeasurementRead = YES;
+    }
+}
+
++ (void)setAppStartTraceId:(nullable SentryId *)traceId
+{
+    @synchronized(appStartMeasurementLock) {
+        appStartTraceId = traceId;
+    }
+}
+
++ (nullable SentryId *)appStartTraceId
+{
+    @synchronized(appStartMeasurementLock) {
+        return appStartTraceId;
+    }
+}
+
++ (void)setAppStartScreen:(nullable NSString *)screenName
+{
+    @synchronized(appStartMeasurementLock) {
+        if (appStartScreen == nil) {
+            appStartScreen = [screenName copy];
+        }
+    }
+}
+
++ (nullable NSString *)consumeAppStartScreen
+{
+    @synchronized(appStartMeasurementLock) {
+        NSString *name = appStartScreen;
+        appStartScreen = nil;
+        return name;
+    }
+}
+
 + (void)reset
 {
     @synchronized(appStartMeasurementLock) {
         appStartMeasurementRead = NO;
+        appStartTraceId = nil;
+        appStartScreen = nil;
     }
 }
 

Sources/Sentry/SentryBuildAppStartSpans.m

@@ -1,15 +1,20 @@
 #import "SentryAppStartMeasurement.h"
+#import "SentryLogC.h"
 #import "SentrySpanContext+Private.h"
+#import "SentrySpanDataKey.h"
 #import "SentrySpanId.h"
 #import "SentrySpanInternal.h"
+#import "SentrySpanOperation.h"
 #import "SentrySwift.h"
 #import "SentryTraceOrigin.h"
 #import "SentryTracer.h"
 #import <SentryBuildAppStartSpans.h>
 
 #if SENTRY_HAS_UIKIT
 
-id<SentrySpan>
+#    pragma mark - Private
+
+static id<SentrySpan>
 sentryBuildAppStartSpan(
     SentryTracer *tracer, SentrySpanId *parentId, NSString *operation, NSString *description)
 {
@@ -22,78 +27,135 @@
                                             origin:SentryTraceOriginAutoAppStart
                                            sampled:tracer.sampled];
 
+    // Pass nil for the framesTracker because app start spans are created during launch,
+    // before the frames tracker is available.
     return [[SentrySpanInternal alloc] initWithTracer:tracer context:context framesTracker:nil];
 }
 
-NSArray<id<SentrySpan>> *
-sentryBuildAppStartSpans(
-    SentryTracer *tracer, SentryAppStartMeasurement *_Nullable appStartMeasurement)
+/**
+ * Internal helper that builds the app start child spans. When @c isStandalone is @c YES the
+ * intermediate grouping span is omitted and children are parented directly to the tracer.
+ */
+static NSArray<id<SentrySpan>> *
+sentryBuildAppStartSpansInternal(SentryTracer *tracer,
+    SentryAppStartMeasurement *_Nullable appStartMeasurement, BOOL isStandalone)
 {
-
     if (appStartMeasurement == nil) {
         return @[];
     }
 
     NSString *operation;
     NSString *type;
 
-    switch (appStartMeasurement.type) {
-    case SentryAppStartTypeCold:
-        operation = @"app.start.cold";
-        type = @"Cold Start";
-        break;
-    case SentryAppStartTypeWarm:
-        operation = @"app.start.warm";
-        type = @"Warm Start";
-        break;
-    default:
-        return @[];
+    if (isStandalone) {
+        operation = SentrySpanOperationAppStart;
+        type = @"App Start";
+    } else {
+        switch (appStartMeasurement.type) {
+        case SentryAppStartTypeCold:
+            operation = SentrySpanOperationAppStartCold;
+            type = @"Cold Start";
+            break;
+        case SentryAppStartTypeWarm:
+            operation = SentrySpanOperationAppStartWarm;
+            type = @"Warm Start";
+            break;
+        default:
+            SENTRY_LOG_ERROR(@"Unknown app start type, can't build app start spans");
+            return @[];
+        }
+    }
+
+    NSString *startType = nil;
+    if (appStartMeasurement.type == SentryAppStartTypeCold
+        || appStartMeasurement.type == SentryAppStartTypeWarm) {
+        NSString *base = appStartMeasurement.type == SentryAppStartTypeCold ? @"cold" : @"warm";
+        startType = appStartMeasurement.isPreWarmed
+            ? [NSString stringWithFormat:@"%@.prewarmed", base]
+            : base;
     }
 
     NSMutableArray<id<SentrySpan>> *appStartSpans = [NSMutableArray array];
 
     NSDate *appStartEndTimestamp = [appStartMeasurement.appStartTimestamp
         dateByAddingTimeInterval:appStartMeasurement.duration];
 
-    id<SentrySpan> appStartSpan = sentryBuildAppStartSpan(tracer, tracer.spanId, operation, type);
-    [appStartSpan setStartTimestamp:appStartMeasurement.appStartTimestamp];
-    [appStartSpan setTimestamp:appStartEndTimestamp];
-
-    [appStartSpans addObject:appStartSpan];
+    SentrySpanId *appStartSpanParentId;
+    if (isStandalone) {
+        appStartSpanParentId = tracer.spanId;
+    } else {
+        id<SentrySpan> appStartSpan
+            = sentryBuildAppStartSpan(tracer, tracer.spanId, operation, type);
+        [appStartSpan setStartTimestamp:appStartMeasurement.appStartTimestamp];
+        [appStartSpan setTimestamp:appStartEndTimestamp];
+        [appStartSpans addObject:appStartSpan];
+        appStartSpanParentId = appStartSpan.spanId;
+    }
 
     if (!appStartMeasurement.isPreWarmed) {
         id<SentrySpan> premainSpan
-            = sentryBuildAppStartSpan(tracer, appStartSpan.spanId, operation, @"Pre Runtime Init");
+            = sentryBuildAppStartSpan(tracer, appStartSpanParentId, operation, @"Pre Runtime Init");
         [premainSpan setStartTimestamp:appStartMeasurement.appStartTimestamp];
         [premainSpan setTimestamp:appStartMeasurement.runtimeInitTimestamp];
+        if (isStandalone && startType != nil) {
+            [premainSpan setDataValue:startType forKey:SentrySpanDataKeyAppVitalsStartType];
+        }
         [appStartSpans addObject:premainSpan];
 
         id<SentrySpan> runtimeInitSpan = sentryBuildAppStartSpan(
-            tracer, appStartSpan.spanId, operation, @"Runtime Init to Pre Main Initializers");
+            tracer, appStartSpanParentId, operation, @"Runtime Init to Pre Main Initializers");
         [runtimeInitSpan setStartTimestamp:appStartMeasurement.runtimeInitTimestamp];
         [runtimeInitSpan setTimestamp:appStartMeasurement.moduleInitializationTimestamp];
+        if (isStandalone && startType != nil) {
+            [runtimeInitSpan setDataValue:startType forKey:SentrySpanDataKeyAppVitalsStartType];
+        }
         [appStartSpans addObject:runtimeInitSpan];
     }
 
     id<SentrySpan> appInitSpan
-        = sentryBuildAppStartSpan(tracer, appStartSpan.spanId, operation, @"UIKit Init");
+        = sentryBuildAppStartSpan(tracer, appStartSpanParentId, operation, @"UIKit Init");
     [appInitSpan setStartTimestamp:appStartMeasurement.moduleInitializationTimestamp];
     [appInitSpan setTimestamp:appStartMeasurement.sdkStartTimestamp];
+    if (isStandalone && startType != nil) {
+        [appInitSpan setDataValue:startType forKey:SentrySpanDataKeyAppVitalsStartType];
+    }
     [appStartSpans addObject:appInitSpan];
 
     id<SentrySpan> didFinishLaunching
-        = sentryBuildAppStartSpan(tracer, appStartSpan.spanId, operation, @"Application Init");
+        = sentryBuildAppStartSpan(tracer, appStartSpanParentId, operation, @"Application Init");
     [didFinishLaunching setStartTimestamp:appStartMeasurement.sdkStartTimestamp];
     [didFinishLaunching setTimestamp:appStartMeasurement.didFinishLaunchingTimestamp];
+    if (isStandalone && startType != nil) {
+        [didFinishLaunching setDataValue:startType forKey:SentrySpanDataKeyAppVitalsStartType];
+    }
     [appStartSpans addObject:didFinishLaunching];
 
     id<SentrySpan> frameRenderSpan
-        = sentryBuildAppStartSpan(tracer, appStartSpan.spanId, operation, @"Initial Frame Render");
+        = sentryBuildAppStartSpan(tracer, appStartSpanParentId, operation, @"Initial Frame Render");
     [frameRenderSpan setStartTimestamp:appStartMeasurement.didFinishLaunchingTimestamp];
     [frameRenderSpan setTimestamp:appStartEndTimestamp];
+    if (isStandalone && startType != nil) {
+        [frameRenderSpan setDataValue:startType forKey:SentrySpanDataKeyAppVitalsStartType];
+    }
     [appStartSpans addObject:frameRenderSpan];
 
     return appStartSpans;
 }
 
+#    pragma mark - Public
+
+NSArray<id<SentrySpan>> *
+sentryBuildAppStartSpans(
+    SentryTracer *tracer, SentryAppStartMeasurement *_Nullable appStartMeasurement)
+{
+    return sentryBuildAppStartSpansInternal(tracer, appStartMeasurement, NO);
+}
+
+NSArray<id<SentrySpan>> *
+sentryBuildStandaloneAppStartSpans(
+    SentryTracer *tracer, SentryAppStartMeasurement *_Nullable appStartMeasurement)
+{
+    return sentryBuildAppStartSpansInternal(tracer, appStartMeasurement, YES);
+}
+
 #endif // SENTRY_HAS_UIKIT

Sources/Sentry/SentryDefaultUIViewControllerPerformanceTracker.m

@@ -3,6 +3,7 @@
 
 #if SENTRY_HAS_UIKIT
 
+#    import "SentryAppStartMeasurementProvider.h"
 #    import "SentryHub.h"
 #    import "SentryLogC.h"
 #    import "SentryPerformanceTracker.h"
@@ -183,6 +184,9 @@ - (void)startRootSpanFor:(UIViewController *)controller
         }
 
         NSString *name = [SwiftDescriptor getViewControllerClassName:controller];
+
+        [SentryAppStartMeasurementProvider setAppStartScreen:name];
+
         spanId = [self.tracker startSpanWithName:name
                                       nameSource:kSentryTransactionNameSourceComponent
                                        operation:SentrySpanOperationUiLoad

Sources/Sentry/SentryPerformanceTracker.m

@@ -1,4 +1,5 @@
 #import "SentryPerformanceTracker.h"
+#import "SentryAppStartMeasurementProvider.h"
 #import "SentryHub+Private.h"
 #import "SentryLogC.h"
 #import "SentrySDK+Private.h"
@@ -71,11 +72,25 @@
         newSpan = [activeSpan startChildWithOperation:operation description:name];
         newSpan.origin = origin;
     } else {
-        SentryTransactionContext *context =
-            [[SentryTransactionContext alloc] initWithName:name
-                                                nameSource:nameSource
-                                                 operation:operation
-                                                    origin:origin];
+        SentryId *appStartTraceId = [SentryAppStartMeasurementProvider appStartTraceId];
+        SentryTransactionContext *context;
+        if (appStartTraceId != nil) {
+            context = [[SentryTransactionContext alloc] initWithName:name
+                                                          nameSource:nameSource
+                                                           operation:operation
+                                                              origin:origin
+                                                             traceId:appStartTraceId
+                                                              spanId:[[SentrySpanId alloc] init]
+                                                        parentSpanId:nil
+                                                       parentSampled:kSentrySampleDecisionUndecided
+                                                    parentSampleRate:nil
+                                                    parentSampleRand:nil];
+        } else {
+            context = [[SentryTransactionContext alloc] initWithName:name
+                                                          nameSource:nameSource
+                                                           operation:operation
+                                                              origin:origin];
+        }
 
         id<SentrySpan> span = SentrySDKInternal.currentHub.scope.span;
 

Sources/Sentry/SentrySpanDataKey.m

@@ -2,3 +2,8 @@
 
 NSString *const SentrySpanDataKeyFileSize = @"file.size";
 NSString *const SentrySpanDataKeyFilePath = @"file.path";
+
+NSString *const SentrySpanDataKeyAppVitalsStartType = @"app.vitals.start.type";
+NSString *const SentrySpanDataKeyAppVitalsStartValue = @"app.vitals.start.value";
+NSString *const SentrySpanDataKeyAppVitalsStartColdValue = @"app.vitals.start.cold.value";
+NSString *const SentrySpanDataKeyAppVitalsStartWarmValue = @"app.vitals.start.warm.value";

Sources/Sentry/SentrySpanOperation.m

@@ -15,6 +15,10 @@
 
 NSString *const SentrySpanOperationUiAction = @"ui.action";
 NSString *const SentrySpanOperationUiActionClick = @"ui.action.click";
+NSString *const SentrySpanOperationAppStart = @"app.start";
+NSString *const SentrySpanOperationAppStartCold = @"app.start.cold";
+NSString *const SentrySpanOperationAppStartWarm = @"app.start.warm";
+
 NSString *const SentrySpanOperationUiLoad = @"ui.load";
 NSString *const SentrySpanOperationUiLoadInitialDisplay = @"ui.load.initial_display";
 NSString *const SentrySpanOperationUiLoadFullDisplay = @"ui.load.full_display";