ref: SentryOptions in Swift (#6628)

* ref: SentryOptions in Swift

* Renames

* Improve defaults

* Fix

* Fix duplicate test

Author: noahsmartin

Samples/iOS-Swift/iOS-Swift/Profiling/ProfilingViewController.swift

@@ -1,4 +1,4 @@
-import Sentry
+@_spi(Private) import Sentry
 import SentrySampleShared
 import UIKit
 

Samples/iOS-Swift/iOS-Swift/Tools/iOS-Swift-Bridging-Header.h

@@ -3,4 +3,3 @@
 #import "SentryExposure.h"
 #import <Sentry/PrivateSentrySDKOnly.h>
 #import <Sentry/SentryDsn+Private.h>
-#import <Sentry/SentryOptions+Private.h>

Sentry.xcodeproj/project.pbxproj

@@ -1,14 +1,14 @@
 import _SentryPrivate
 import Foundation
-@_spi(Private) import Sentry
+@_spi(Private) @testable import Sentry
 
 public class TestClient: SentryClientInternal {
-    public override init?(options: Options) {
+    public override init?(options: NSObject) {
         super.init(
             options: options,
-            transportAdapter: TestTransportAdapter(transports: [TestTransport()], options: options),
+            transportAdapter: TestTransportAdapter(transports: [TestTransport()], options: options as! Options),
             fileManager: try! TestFileManager(
-                options: options,
+                options: options as? Options,
                 dateProvider: TestCurrentDateProvider(),
                 dispatchQueueWrapper: TestSentryDispatchQueueWrapper()
             ),
@@ -22,7 +22,7 @@ public class TestClient: SentryClientInternal {
 
     // Without this override we get a fatal error: use of unimplemented initializer
     // see https://stackoverflow.com/questions/28187261/ios-swift-fatal-error-use-of-unimplemented-initializer-init
-    @_spi(Private) public override init(options: Options, transportAdapter: SentryTransportAdapter, fileManager: SentryFileManager, threadInspector: SentryDefaultThreadInspector, debugImageProvider: SentryDebugImageProvider, random: SentryRandomProtocol, locale: Locale, timezone: TimeZone) {
+    @_spi(Private) public override init(options: NSObject, transportAdapter: SentryTransportAdapter, fileManager: SentryFileManager, threadInspector: SentryDefaultThreadInspector, debugImageProvider: SentryDebugImageProvider, random: SentryRandomProtocol, locale: Locale, timezone: TimeZone) {
         super.init(
             options: options,
             transportAdapter: transportAdapter,

SentryTestUtils/Sources/TestClient.swift

@@ -7,6 +7,11 @@ import Foundation
     var readTimestampLastInForegroundInvocations: Int = 0
     var storeTimestampLastInForegroundInvocations: Int = 0
     var deleteTimestampLastInForegroundInvocations: Int = 0
+    
+    public init(options: Options?, dateProvider: any SentryCurrentDateProvider, dispatchQueueWrapper: SentryDispatchQueueWrapper) throws {
+        let helper = try SentryFileManagerHelper(options: options)
+        super.init(helper: helper, dateProvider: dateProvider, dispatchQueueWrapper: dispatchQueueWrapper)
+    }
 
     @_spi(Private) public var storeEnvelopeInvocations = Invocations<SentryEnvelope>()
     public var storeEnvelopePath: String?

SentryTestUtils/Sources/TestFileManager.swift

@@ -6,7 +6,6 @@
 #import "SentryInstallation.h"
 #import "SentryInternalDefines.h"
 #import "SentryMeta.h"
-#import "SentryOptions+Private.h"
 #import "SentryProfileCollector.h"
 #import "SentryPropagationContext.h"
 #import "SentrySDK+Private.h"

Sources/Sentry/PrivateSentrySDKOnly.m

@@ -7,7 +7,6 @@
 #    import "SentryInternalDefines.h"
 #    import "SentryLaunchProfiling.h"
 #    import "SentryLogC.h"
-#    import "SentryOptions+Private.h"
 #    import "SentryProfileConfiguration.h"
 #    import "SentryProfiler+Private.h"
 #    import "SentrySamplerDecision.h"

Sources/Sentry/Profiling/SentryLaunchProfiling.m

@@ -5,15 +5,13 @@
 #    import "SentryContinuousProfiler.h"
 #    import "SentryInternalDefines.h"
 #    import "SentryLogC.h"
-#    import "SentryOptions+Private.h"
 #    import "SentryProfiler+Private.h"
 #    include <mutex>
 
 #    import "SentryEvent+Private.h"
 #    import "SentryHub+Private.h"
 #    import "SentryInternalDefines.h"
 #    import "SentryLaunchProfiling.h"
-#    import "SentryOptions+Private.h"
 #    import "SentryProfileConfiguration.h"
 #    import "SentryProfiledTracerConcurrency.h"
 #    import "SentryProfiler+Private.h"

Sources/Sentry/Profiling/SentryProfiledTracerConcurrency.mm

@@ -2,9 +2,14 @@
 #if SENTRY_TARGET_PROFILING_SUPPORTED
 
 #    import "SentryClient.h"
+#    import "SentryDependencyContainerSwiftHelper.h"
+#    import "SentryHub.h"
+#    import "SentryInternalDefines.h"
+#    import "SentryLaunchProfiling.h"
 #    import "SentryLogC.h"
-#    import "SentryOptions+Private.h"
+#    import "SentryProfileConfiguration.h"
 #    import "SentryProfiler+Private.h"
+#    import "SentrySDK+Private.h"
 #    import "SentrySamplerDecision.h"
 #    import "SentrySwift.h"
 
@@ -159,6 +164,24 @@
 }
 
 #    if SENTRY_HAS_UIKIT
+BOOL
+sentry_appHangsDisabled(void)
+{
+    SentryOptions *options = [[[SentrySDKInternal currentHub] getClient] options];
+    if (options == nil) {
+        return NO;
+    }
+    return [options isAppHangTrackingDisabled];
+}
+BOOL
+sentry_autoPerformanceTracingDisabled(void)
+{
+    SentryOptions *options = [[[SentrySDKInternal currentHub] getClient] options];
+    if (options == nil) {
+        return YES;
+    }
+    return ![options enableAutoPerformanceTracing];
+}
 void
 sentry_startFramesTracker(void)
 {
@@ -183,4 +206,93 @@
     return [SentryDependencyContainer.sharedInstance.framesTracker currentFrames];
 }
 #    endif // SENTRY_HAS_UIKIT
+
+void
+sentry_configureContinuousProfiling(SentryOptions *options)
+{
+    if (options.configureProfiling == nil) {
+        SENTRY_LOG_DEBUG(@"Continuous profiling V2 configuration not set by SDK consumer, nothing "
+                         @"to do here.");
+        return;
+    }
+
+    SentryProfileOptions *_Nonnull profilingOptions = sentry_getSentryProfileOptions();
+    options.profiling = profilingOptions;
+    options.configureProfiling(profilingOptions);
+
+    if (sentry_isTraceLifecycle(profilingOptions) && !options.isTracingEnabled) {
+        SENTRY_LOG_WARN(
+            @"Tracing must be enabled in order to configure profiling with trace lifecycle.");
+        return;
+    }
+
+    // if a launch profiler was started, sentry_profileConfiguration will have been set at that time
+    // with the hydrated options that were persisted from the previous SDK start, which are used to
+    // help determine when/how to stop the launch profile. otherwise, there won't yet be a
+    // SentryProfileConfiguration instance, so we'll instantiate one which will be used to access
+    // the profile session sample rate henceforth
+    if (sentry_profileConfiguration == nil) {
+        sentry_profileConfiguration =
+            [[SentryProfileConfiguration alloc] initWithProfileOptions:profilingOptions];
+    }
+
+    sentry_reevaluateSessionSampleRate();
+
+    SENTRY_LOG_DEBUG(@"Configured profiling options: <%@: {\n  lifecycle: %@\n  sessionSampleRate: "
+                     @"%.2f\n  profileAppStarts: %@\n}",
+        options.profiling, sentry_isTraceLifecycle(profilingOptions) ? @"trace" : @"manual",
+        sentry_sessionSampleRate(profilingOptions),
+        sentry_profileAppStarts(profilingOptions) ? @"YES" : @"NO");
+}
+
+void
+sentry_sdkInitProfilerTasks(SentryOptions *options, SentryHubInternal *hub)
+{
+    // get the configuration options from the last time the launch config was written; it may be
+    // different than the new options the SDK was just started with
+    SentryProfileConfiguration *configurationFromLaunch = sentry_profileConfiguration;
+
+    sentry_configureContinuousProfiling(options);
+
+    sentry_dispatchAsync(SentryDependencyContainerSwiftHelper.dispatchQueueWrapper, ^{
+        if (configurationFromLaunch.isProfilingThisLaunch) {
+            BOOL shouldStopAndTransmitLaunchProfile = YES;
+
+            BOOL profileIsContinuousV2 = configurationFromLaunch.profileOptions != nil;
+            BOOL v2LifecycleIsManual = profileIsContinuousV2
+                && !sentry_isTraceLifecycle(SENTRY_UNWRAP_NULLABLE(
+                    SentryProfileOptions, configurationFromLaunch.profileOptions));
+
+#    if SENTRY_HAS_UIKIT
+            BOOL v2LifecycleIsTrace = profileIsContinuousV2
+                && sentry_isTraceLifecycle(SENTRY_UNWRAP_NULLABLE(
+                    SentryProfileOptions, configurationFromLaunch.profileOptions));
+            BOOL profileIsCorrelatedToTrace = !profileIsContinuousV2 || v2LifecycleIsTrace;
+            if (profileIsCorrelatedToTrace && configurationFromLaunch.waitForFullDisplay) {
+                SENTRY_LOG_DEBUG(
+                    @"Will wait to stop launch profile correlated to a trace until full "
+                    @"display reported.");
+                shouldStopAndTransmitLaunchProfile = NO;
+            }
+#    endif // SENTRY_HAS_UIKIT
+
+            if (v2LifecycleIsManual) {
+                SENTRY_LOG_DEBUG(@"Continuous manual launch profiles aren't stopped on calls to "
+                                 @"SentrySDK.start, "
+                                 @"not stopping profile.");
+                shouldStopAndTransmitLaunchProfile = NO;
+            }
+
+            if (shouldStopAndTransmitLaunchProfile) {
+                SENTRY_LOG_DEBUG(
+                    @"Stopping launch profile in SentrySDK.start because there is no time "
+                    @"to display tracker to stop it.");
+                sentry_stopAndDiscardLaunchProfileTracer(hub);
+            }
+        }
+
+        sentry_configureLaunchProfilingForNextLaunch(options);
+    });
+}
+
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED

Sources/Sentry/Profiling/SentryProfilingSwiftHelpers.m

@@ -28,7 +28,7 @@ FOUNDATION_EXPORT const unsigned char SentryVersionString[];
 #    import <Sentry/SentryMechanismContext.h>
 #    import <Sentry/SentryMessage.h>
 #    import <Sentry/SentryNSError.h>
-#    import <Sentry/SentryOptions.h>
+#    import <Sentry/SentryProfilingConditionals.h>
 #    import <Sentry/SentryReplayApi.h>
 #    import <Sentry/SentryRequest.h>
 #    import <Sentry/SentrySampleDecision.h>