ref(profiling): function renames

SentryTestUtils/SentryLaunchProfiling+Tests.h

@@ -43,7 +43,8 @@ BOOL sentry_willProfileNextLaunch(SentryOptions *options);
  */
 void _sentry_nondeduplicated_startLaunchProfile(void);
 
-SentryTransactionContext *sentry_context(NSNumber *tracesRate, NSNumber *tracesRand);
+SentryTransactionContext *sentry_contextForLaunchProfilerForTrace(
+    NSNumber *tracesRate, NSNumber *tracesRand);
 
 NS_ASSUME_NONNULL_END
 

Sources/Sentry/PrivateSentrySDKOnly.mm

@@ -224,11 +224,9 @@ + (uint64_t)startProfilerForTrace:(SentryId *)traceId;
     return payload;
 }
 
-+ (void)discardProfilerForTrace:(SentryId *)traceId
-                   traceSampled:(BOOL)launchTraceSampledForContinuousProfilingV2;
++ (void)discardProfilerForTrace:(SentryId *)traceId traceSampled:(BOOL)isProfiling;
 {
-    sentry_discardProfiler(
-        traceId, SentrySDK.currentHub, launchTraceSampledForContinuousProfilingV2);
+    sentry_discardProfilerCorrelatedToTrace(traceId, SentrySDK.currentHub, isProfiling);
 }
 
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED

Sources/Sentry/Profiling/SentryLaunchProfiling.m

@@ -42,7 +42,7 @@
 SentryTracer *_Nullable sentry_launchTracer;
 
 SentryTracerConfiguration *
-sentry_config(
+sentry_configForLaunchProfilerForTrace(
     NSNumber *profilesRate, NSNumber *profilesRand, SentryProfileOptions *_Nullable profileOptions)
 {
     SentryTracerConfiguration *config = [SentryTracerConfiguration defaultConfiguration];
@@ -175,7 +175,7 @@
 }
 
 SentryTransactionContext *
-sentry_context(NSNumber *tracesRate, NSNumber *tracesRand)
+sentry_contextForLaunchProfilerForTrace(NSNumber *tracesRate, NSNumber *tracesRand)
 {
     SentryTransactionContext *context =
         [[SentryTransactionContext alloc] initWithName:@"launch"
@@ -215,7 +215,7 @@
     [SentryLog configure:YES diagnosticLevel:kSentryLevelDebug];
 #    endif // defined(DEBUG)
 
-    NSDictionary<NSString *, NSNumber *> *launchConfig = appLaunchProfileConfiguration();
+    NSDictionary<NSString *, NSNumber *> *launchConfig = sentry_appLaunchProfileConfiguration();
     if ([launchConfig[kSentryLaunchProfileConfigKeyContinuousProfiling] boolValue]) {
         SENTRY_LOG_DEBUG(@"Starting continuous launch profile.");
         [SentryContinuousProfiler start];
@@ -280,10 +280,14 @@
 
     SENTRY_LOG_INFO(@"Starting app launch trace profile at %llu.", getAbsoluteTime());
     sentry_isTracingAppLaunch = YES;
-    sentry_launchTracer = [[SentryTracer alloc]
-        initWithTransactionContext:sentry_context(tracesRate, tracesRand)
-                               hub:nil
-                     configuration:sentry_config(profilesRate, profilesRand, profileOptions)];
+
+    SentryTransactionContext *context
+        = sentry_contextForLaunchProfilerForTrace(tracesRate, tracesRand);
+    SentryTracerConfiguration *config
+        = sentry_configForLaunchProfilerForTrace(profilesRate, profilesRand, profileOptions);
+    sentry_launchTracer = [[SentryTracer alloc] initWithTransactionContext:context
+                                                                       hub:nil
+                                                             configuration:config];
 }
 
 #    pragma mark - Public

Sources/Sentry/Profiling/SentryProfiledTracerConcurrency.mm

@@ -117,7 +117,7 @@
     _unsafe_cleanUpContinuousProfilerV2();
 }
 
-SentryId *_Nullable _sentry_startContinuousProfilerV2(
+SentryId *_Nullable _sentry_startContinuousProfilerV2ForTrace(
     SentryProfileOptions *profileOptions, SentryTransactionContext *transactionContext)
 {
     if (profileOptions.lifecycle != SentryProfileLifecycleTrace) {
@@ -138,7 +138,7 @@
 } // namespace
 
 void
-sentry_trackProfilerForTracer(SentryProfiler *profiler, SentryId *internalTraceId)
+sentry_trackTransactionProfilerForTrace(SentryProfiler *profiler, SentryId *internalTraceId)
 {
     std::lock_guard<std::mutex> l(_gStateLock);
 
@@ -166,24 +166,16 @@
 }
 
 void
-sentry_discardProfilerHybrid(SentryId *internalTraceId, SentryHub *hub)
-{
-}
-
-void
-sentry_discardProfiler(
-    SentryId *internalTraceId, SentryHub *hub, BOOL launchTraceSampledForContinuousProfilingV2)
+sentry_discardProfilerCorrelatedToTrace(SentryId *internalTraceId, SentryHub *hub, BOOL isProfiling)
 {
     std::lock_guard<std::mutex> l(_gStateLock);
 
     if ([SentryContinuousProfiler isCurrentlyProfiling]) {
         BOOL notLaunchContinuousProfileV2TraceLifecycle = hub != nil
             && hub.client.options.profiling != nil
             && hub.client.options.profiling.lifecycle == SentryProfileLifecycleTrace;
-        if (!notLaunchContinuousProfileV2TraceLifecycle
-            && !launchTraceSampledForContinuousProfilingV2) {
-            SENTRY_LOG_DEBUG(@"The trace associated with the profiler was not sampled, so the "
-                             @"profiler was never started and there is nothing to discard.");
+        if (!notLaunchContinuousProfileV2TraceLifecycle && !isProfiling) {
+            SENTRY_LOG_DEBUG(@"Continuous profiler v1 won't be stopped with a tracer.");
             return;
         }
 
@@ -326,17 +318,23 @@
     }];
 }
 
-SentryId *_Nullable sentry_startProfiler(SentryTracerConfiguration *configuration, SentryHub *hub,
-    SentryTransactionContext *transactionContext)
+SentryId *_Nullable sentry_startProfilerForTrace(SentryTracerConfiguration *configuration,
+    SentryHub *hub, SentryTransactionContext *transactionContext)
 {
     if (configuration.profileOptions != nil) {
-        return _sentry_startContinuousProfilerV2(configuration.profileOptions, transactionContext);
+        // launch profile; there's hub to get options from, so they're read from the launch profile
+        // config file and packaged into the tracer configuration in the launch profile codepath
+        return _sentry_startContinuousProfilerV2ForTrace(
+            configuration.profileOptions, transactionContext);
     } else if ([hub.getClient.options isContinuousProfilingEnabled]) {
+        // non launch profile
         SentryProfileOptions *profileOptions = hub.getClient.options.profiling;
         if (profileOptions == nil) {
+            SENTRY_LOG_DEBUG(
+                @"Continuous profiling v1 configured; will not start automatically for trace.");
             return nil;
         }
-        return _sentry_startContinuousProfilerV2(profileOptions, transactionContext);
+        return _sentry_startContinuousProfilerV2ForTrace(profileOptions, transactionContext);
     } else {
         BOOL profileShouldBeSampled
             = configuration.profilesSamplerDecision.decision == kSentrySampleDecisionYes;

Sources/Sentry/Profiling/SentryTraceProfiler.mm

@@ -35,7 +35,7 @@ + (BOOL)startWithTracer:(SentryId *)traceId
 
         if ([_threadUnsafe_gTraceProfiler isRunning]) {
             SENTRY_LOG_DEBUG(@"A trace profiler is already running.");
-            sentry_trackProfilerForTracer(_threadUnsafe_gTraceProfiler, traceId);
+            sentry_trackTransactionProfilerForTrace(_threadUnsafe_gTraceProfiler, traceId);
             // record a new metric sample for every concurrent span start
             [_threadUnsafe_gTraceProfiler.metricProfiler recordMetrics];
             return YES;
@@ -49,7 +49,7 @@ + (BOOL)startWithTracer:(SentryId *)traceId
         }
 
         _threadUnsafe_gTraceProfiler.profilerId = [[SentryId alloc] init];
-        sentry_trackProfilerForTracer(_threadUnsafe_gTraceProfiler, traceId);
+        sentry_trackTransactionProfilerForTrace(_threadUnsafe_gTraceProfiler, traceId);
     }
 
     [self scheduleTimeoutTimer];

Sources/Sentry/SentryFileManager.m

@@ -672,7 +672,7 @@ - (BOOL)isDirectory:(NSString *)path
     return sentryLaunchConfigFileURL;
 }
 
-NSDictionary<NSString *, NSNumber *> *_Nullable appLaunchProfileConfiguration(void)
+NSDictionary<NSString *, NSNumber *> *_Nullable sentry_appLaunchProfileConfiguration(void)
 {
     NSURL *url = launchProfileConfigFileURL();
     if (![[NSFileManager defaultManager] fileExistsAtPath:url.path]) {

Sources/Sentry/SentryTracer.m

@@ -179,7 +179,7 @@ - (instancetype)initWithTransactionContext:(SentryTransactionContext *)transacti
 #endif // SENTRY_HAS_UIKIT
 
 #if SENTRY_TARGET_PROFILING_SUPPORTED
-    _profilerReferenceID = sentry_startProfiler(configuration, hub, transactionContext);
+    _profilerReferenceID = sentry_startProfilerForTrace(configuration, hub, transactionContext);
     _isProfiling = _profilerReferenceID != nil;
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
 
@@ -191,8 +191,7 @@ - (instancetype)initWithTransactionContext:(SentryTransactionContext *)transacti
 - (void)dealloc
 {
 #if SENTRY_TARGET_PROFILING_SUPPORTED
-    sentry_discardProfiler(_profilerReferenceID, self.hub,
-        self.isProfiling /* launchTraceSampledForContinuousProfilingV2 */);
+    sentry_discardProfilerCorrelatedToTrace(_profilerReferenceID, self.hub, self.isProfiling);
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
     [self cancelDeadlineTimeout];
 }

Sources/Sentry/include/HybridPublic/PrivateSentrySDKOnly.h

@@ -125,8 +125,7 @@ typedef void (^SentryOnAppStartMeasurementAvailable)(
  * associated with this profiler was sampled for proper bookkeeping to align automatic continuous
  * profiling to root spans, and provide the configuration options.
  */
-+ (void)discardProfilerForTrace:(SentryId *)traceId
-                   traceSampled:(BOOL)launchTraceSampledForContinuousProfilingV2;
++ (void)discardProfilerForTrace:(SentryId *)traceId traceSampled:(BOOL)isProfiling;
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
 
 @property (class, nullable, nonatomic, copy)

Sources/Sentry/include/SentryFileManager.h

@@ -143,7 +143,8 @@ SENTRY_EXTERN BOOL appLaunchProfileConfigFileExists(void);
  * Retrieve the contents of the launch profile config file, which stores the sample rates used to
  * decide whether or not to profile this launch.
  */
-SENTRY_EXTERN NSDictionary<NSString *, NSNumber *> *_Nullable appLaunchProfileConfiguration(void);
+SENTRY_EXTERN NSDictionary<NSString *, NSNumber *> *_Nullable sentry_appLaunchProfileConfiguration(
+    void);
 
 /**
  * Write a config file that stores the sample rates used to determine whether this launch should

Sources/Sentry/include/SentryProfiledTracerConcurrency.h

@@ -32,8 +32,8 @@ void sentry_captureTransactionWithProfile(SentryHub *hub, SentryDispatchQueueWra
  * @Returns An ID to use as a unique, unchanging ID for the tracer that started the profiler. It's
  * different from the profiler's internal ID.
  */
-SentryId *_Nullable sentry_startProfiler(SentryTracerConfiguration *configuration, SentryHub *hub,
-    SentryTransactionContext *transactionContext);
+SentryId *_Nullable sentry_startProfilerForTrace(SentryTracerConfiguration *configuration,
+    SentryHub *hub, SentryTransactionContext *transactionContext);
 
 /**
  * @note Only called for transaction-based profiling or continuous profiling V2 with trace lifecycle
@@ -52,16 +52,14 @@ SENTRY_EXTERN void sentry_stopProfilerDueToFinishedTransaction(
  * Associate the provided profiler and tracer so that profiling data may be retrieved by the tracer
  * when it is ready to transmit its envelope.
  */
-void sentry_trackProfilerForTracer(SentryProfiler *profiler, SentryId *internalTraceId);
-
-void sentry_discardProfilerHybrid(SentryId *internalTraceId, SentryHub *hub);
+void sentry_trackTransactionProfilerForTrace(SentryProfiler *profiler, SentryId *internalTraceId);
 
 /**
  * For transactions that will be discarded, clean up the bookkeeping state associated with them to
  * reclaim the memory they're using.
  */
-void sentry_discardProfiler(
-    SentryId *internalTraceId, SentryHub *hub, BOOL launchTraceSampledForContinuousProfilingV2);
+void sentry_discardProfilerCorrelatedToTrace(
+    SentryId *internalTraceId, SentryHub *hub, BOOL isProfiling);
 
 /**
  * Return the profiler instance associated with the tracer. If it was the last tracer for the