fix tests and location of stop readings

SentryTestUtils/TestDispatchSourceWrapper.swift

@@ -10,6 +10,7 @@ public class TestDispatchSourceWrapper: SentryDispatchSourceWrapper {
     public init(eventHandler: @escaping () -> Void) {
         self.overrides.eventHandler = eventHandler
         super.init()
+        eventHandler() // SentryDispatchSourceWrapper constructs a timer so that it fires with no initial delay
     }
 
     public override func cancel() {

Sources/Sentry/SentryDispatchSourceWrapper.m

@@ -15,8 +15,7 @@ - (instancetype)initTimerWithInterval:(uint64_t)interval
         _queueWrapper = queueWrapper;
         _source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queueWrapper.queue);
         dispatch_source_set_event_handler(_source, eventHandler);
-        dispatch_source_set_timer(
-            _source, dispatch_time(DISPATCH_TIME_NOW, interval), interval, leeway);
+        dispatch_source_set_timer(_source, dispatch_time(DISPATCH_TIME_NOW, 0), interval, leeway);
         dispatch_resume(_source);
     }
     return self;

Sources/Sentry/SentryProfiler.mm

@@ -320,6 +320,7 @@ + (void)startWithTracer:(SentryId *)traceId
     if (_gCurrentProfiler && [_gCurrentProfiler isRunning]) {
         SENTRY_LOG_DEBUG(@"A profiler is already running.");
         trackProfilerForTracer(_gCurrentProfiler, traceId);
+        // record a new metric sample for every concurrent span start
         [_gCurrentProfiler->_metricProfiler recordMetrics];
         return;
     }
@@ -339,6 +340,15 @@ + (BOOL)isCurrentlyProfiling
     return [_gCurrentProfiler isRunning];
 }
 
++ (void)recordMetrics
+{
+    std::lock_guard<std::mutex> l(_gProfilerLock);
+    if (_gCurrentProfiler == nil) {
+        return;
+    }
+    [_gCurrentProfiler->_metricProfiler recordMetrics];
+}
+
 + (nullable SentryEnvelopeItem *)createProfilingEnvelopeItemForTransaction:
     (SentryTransaction *)transaction
 {
@@ -415,9 +425,6 @@ + (void)updateProfilePayload:(NSMutableDictionary<NSString *, id> *)payload
                                                       and:(uint64_t)endSystemTime
                                                     onHub:(SentryHub *)hub;
 {
-    if (self.isRunning) {
-        [_metricProfiler recordMetrics];
-    }
     return serializedProfileData([self._state copyProfilingData], startSystemTime, endSystemTime,
         self.profileId, profilerTruncationReasonName(_truncationReason),
         [_metricProfiler serializeBetween:startSystemTime and:endSystemTime],

Sources/Sentry/SentryTracer.m

@@ -599,6 +599,9 @@ - (SentryTransaction *)toTransaction
     transaction.transaction = self.transactionContext.name;
 #if SENTRY_TARGET_PROFILING_SUPPORTED
     transaction.startSystemTime = self.startSystemTime;
+    if (self.isProfiling) {
+        [SentryProfiler recordMetrics];
+    }
     transaction.endSystemTime = SentryDependencyContainer.sharedInstance.dateProvider.systemTime;
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
 

Sources/Sentry/include/SentryProfiler.h

@@ -64,6 +64,12 @@ SENTRY_EXTERN_C_END
  */
 + (BOOL)isCurrentlyProfiling;
 
+/**
+ * Immediately record a sample of profiling metrics. Helps get full coverage of concurrent spans
+ * when they're ended.
+ */
++ (void)recordMetrics;
+
 /**
  * Given a transaction, return an envelope item containing any corresponding profile data to be
  * attached to the transaction envelope.

Tests/SentryProfilerTests/SentryProfilerSwiftTests.swift

@@ -260,7 +260,7 @@ class SentryProfilerSwiftTests: XCTestCase {
         try fixture.gatherMockedMetrics(span: span)
         self.fixture.currentDateProvider.advanceBy(nanoseconds: 1.toNanoSeconds())
         span.finish()
-        try self.assertMetricsPayload(expectedUsageReadings: fixture.mockUsageReadingsPerBatch + 1)
+        try self.assertMetricsPayload(expectedUsageReadings: fixture.mockUsageReadingsPerBatch + 2) // including one sample at the start and the end
     }
 
     func testConcurrentProfilingTransactions() throws {
@@ -272,6 +272,7 @@ class SentryProfilerSwiftTests: XCTestCase {
             XCTAssertEqual(SentryProfiler.currentProfiledTracers(), UInt(0))
 
             for i in 0 ..< numberOfTransactions {
+                print("creating new concurrent transaction for test")
                 let span = try fixture.newTransaction()
 
                 // because energy readings are computed as the difference between sequential cumulative readings, we must increment the mock value by the expected result each iteration
@@ -289,10 +290,16 @@ class SentryProfilerSwiftTests: XCTestCase {
                 try fixture.gatherMockedMetrics(span: span)
                 XCTAssertTrue(SentryProfiler.isCurrentlyProfiling())
                 span.finish()
-                XCTAssertEqual(SentryProfiler.currentProfiledTracers(), UInt(numberOfTransactions - i - 1))
+                XCTAssertEqual(SentryProfiler.currentProfiledTracers(), UInt(numberOfTransactions - (i + 1)))
 
                 try self.assertValidProfileData()
-                try self.assertMetricsPayload(expectedUsageReadings: fixture.mockUsageReadingsPerBatch * (i + 1) + numberOfTransactions + i)
+
+                // this is a complicated number to come up with, see the explanation for each part...
+                let expectedUsageReadings = fixture.mockUsageReadingsPerBatch * (i + 1) // since we fire mock metrics readings for each concurrent span,
+                                                                                        // we need to accumulate across the number of spans each iteration
+                    + numberOfTransactions // and then, add the number of spans that were created to account for the start reading for each span
+                    + 1 // and the end reading for this span
+                try self.assertMetricsPayload(expectedUsageReadings: expectedUsageReadings, oneLessEnergyReading: i == 0)
             }
 
             XCTAssertFalse(SentryProfiler.isCurrentlyProfiling())