Fix: Dont create transaction for unused ViewControllers

CHANGELOG.md

@@ -18,6 +18,7 @@ via the option `swizzleClassNameExclude`.
 - Add TTID/TTFD spans when loadView gets skipped (#4415)
 - Finish TTID correctly when viewWillAppear is skipped (#4417)
 - Swizzling RootUIViewController if ignored by `swizzleClassNameExclude` (#4407)
+- Do not create transaction for unused view controllers (#4437)
 - Data race in SentrySwizzleInfo.originalCalled (#4434)
 
 ### Improvements

Sources/Sentry/SentrySpan.m

@@ -96,7 +96,7 @@ - (instancetype)initWithContext:(SentrySpanContext *)context
         _spanId = context.spanId;
         _sampled = context.sampled;
         _origin = context.origin;
-
+        _shouldIgnore = NO;
 #if SENTRY_TARGET_PROFILING_SUPPORTED
         _isContinuousProfiling = [SentrySDK.options isContinuousProfilingEnabled];
         if (_isContinuousProfiling) {

Sources/Sentry/SentryTracer.m

@@ -94,7 +94,7 @@ @implementation SentryTracer {
 #endif // SENTRY_HAS_UIKIT
     NSMutableDictionary<NSString *, SentryMeasurementValue *> *_measurements;
     dispatch_block_t _idleTimeoutBlock;
-    NSMutableArray<id<SentrySpan>> *_children;
+    NSMutableArray<SentrySpan *> *_children;
     BOOL _startTimeChanged;
     NSObject *_idleTimeoutLock;
 
@@ -506,12 +506,12 @@ - (BOOL)hasUnfinishedChildSpansToWaitFor
     }
 
     @synchronized(_children) {
-        for (id<SentrySpan> span in _children) {
+        for (SentrySpan *span in _children) {
             if (self.shouldIgnoreWaitForChildrenCallback != nil
                 && self.shouldIgnoreWaitForChildrenCallback(span)) {
                 continue;
             }
-            if (![span isFinished])
+            if (!span.shouldIgnore && ![span isFinished])
                 return YES;
         }
         return NO;
@@ -604,6 +604,9 @@ - (void)finishInternal
     }
 
     SentryTransaction *transaction = [self toTransaction];
+    if (transaction == nil) {
+        return;
+    }
 
 #if SENTRY_TARGET_PROFILING_SUPPORTED
     if (self.isProfiling) {
@@ -638,8 +641,9 @@ - (void)trimEndTimestamp
     NSDate *oldest = self.startTimestamp;
 
     @synchronized(_children) {
-        for (id<SentrySpan> childSpan in _children) {
-            if ([oldest compare:childSpan.timestamp] == NSOrderedAscending) {
+        for (SentrySpan *childSpan in _children) {
+            if (!childSpan.shouldIgnore &&
+                [oldest compare:childSpan.timestamp] == NSOrderedAscending) {
                 oldest = childSpan.timestamp;
             }
         }
@@ -656,8 +660,13 @@ - (void)updateStartTime:(NSDate *)startTime
     _startTimeChanged = YES;
 }
 
-- (SentryTransaction *)toTransaction
+- (nullable SentryTransaction *)toTransaction
 {
+    if (self.shouldIgnore) {
+        // If this transaction was marked as "not used" we drop it.
+        SENTRY_LOG_WARN(@"Transaction '%@' was not used.", self.transactionContext.name);
+        return nil;
+    }
 
     NSUInteger capacity;
 #if SENTRY_HAS_UIKIT
@@ -672,7 +681,11 @@ - (SentryTransaction *)toTransaction
     NSMutableArray<id<SentrySpan>> *spans = [[NSMutableArray alloc] initWithCapacity:capacity];
 
     @synchronized(_children) {
-        [spans addObjectsFromArray:_children];
+        for (SentrySpan *child in _children) {
+            if (child.shouldIgnore == NO) {
+                [spans addObject:child];
+            }
+        }
     }
 
 #if SENTRY_HAS_UIKIT

Sources/Sentry/SentryUIViewControllerPerformanceTracker.m

@@ -125,6 +125,9 @@ - (void)createTransaction:(UIViewController *)controller
         SENTRY_LOG_DEBUG(@"Started span with id %@ to track view controller %@.",
             spanId.sentrySpanIdString, name);
 
+        SentrySpan *span = [self.tracker getSpan:spanId];
+        span.shouldIgnore = YES;
+
         // Use the target itself to store the spanId to avoid using a global mapper.
         objc_setAssociatedObject(controller, &SENTRY_UI_PERFORMANCE_TRACKER_SPAN_ID, spanId,
             OBJC_ASSOCIATION_RETAIN_NONATOMIC);
@@ -264,13 +267,13 @@ - (void)finishTransaction:(UIViewController *)controller
         };
 
         [self.tracker activateSpan:spanId duringBlock:duringBlock];
-        id<SentrySpan> vcSpan = [self.tracker getSpan:spanId];
+        SentrySpan *vcSpan = [self.tracker getSpan:spanId];
         // If the current controller span has no parent,
         // it means it is the root transaction and need to be pop from the queue.
         if (vcSpan.parentSpanId == nil) {
             [self.tracker popActiveSpan];
         }
-
+        vcSpan.shouldIgnore = NO;
         // If we are still tracking this UIViewController finish the transaction
         // and remove associated span id.
         [self.tracker finishSpan:spanId withStatus:status];

Sources/Sentry/include/SentrySpan.h

@@ -84,6 +84,14 @@ SENTRY_NO_INIT
  */
 @property (nullable, nonatomic, strong) NSArray<SentryFrame *> *frames;
 
+/**
+ * Indicates whether this span should be ignored when finishing a transaction.
+ * Ignored spans are not included in the transaction and not taken in account
+ * when trimming transaction timeout.
+ * Default value is @c NO
+ */
+@property (nonatomic) BOOL shouldIgnore;
+
 /**
  * Init a @c SentrySpan with given transaction and context.
  * @param transaction The @c SentryTracer managing the transaction this span is associated with.

Tests/SentryTests/Integrations/Performance/UIViewController/SentryUIViewControllerPerformanceTrackerTests.swift

@@ -132,6 +132,7 @@ class SentryUIViewControllerPerformanceTrackerTests: XCTestCase {
             callbackExpectation.fulfill()
         }
         let tracer = try XCTUnwrap(transactionSpan as? SentryTracer)
+        XCTAssertTrue(tracer.shouldIgnore)
         XCTAssertEqual(tracer.transactionContext.name, fixture.viewControllerName)
         XCTAssertEqual(tracer.transactionContext.nameSource, .component)
         XCTAssertEqual(tracer.transactionContext.origin, origin)
@@ -193,6 +194,7 @@ class SentryUIViewControllerPerformanceTrackerTests: XCTestCase {
 
         lifecycleEndingMethod(sut, viewController, tracker, callbackExpectation, tracer)
 
+        XCTAssertFalse(tracer.shouldIgnore)
         XCTAssertEqual(Dynamic(transactionSpan).children.asArray!.count, 8)
         XCTAssertTrue(tracer.isFinished)
         XCTAssertEqual(finishStatus.rawValue, tracer.status.rawValue)

Tests/SentryTests/Transaction/SentryTracerTests.swift

@@ -1211,6 +1211,24 @@ class SentryTracerTests: XCTestCase {
         }
     }
 
+    func testRemoveChildWithShouldIgnoreTrue() throws {
+        let sut = fixture.getSut()
+        let child = try XCTUnwrap(sut.startChild(operation: fixture.transactionOperation) as? SentrySpan)
+        child.shouldIgnore = true
+
+        sut.finish()
+        let transaction = try XCTUnwrap(fixture.hub.capturedTransactionsWithScope.first?.transaction as? [String: Any])
+        let spans = try XCTUnwrap(transaction["spans"]! as? [[String: Any]])
+        XCTAssertEqual(spans.count, 0)
+    }
+
+    func testDontCaptureWithShouldIgnoreTrue() throws {
+        let sut = fixture.getSut()
+        sut.shouldIgnore = true
+        sut.finish()
+        XCTAssertEqual(fixture.hub.capturedTransactionsWithScope.count, 0)
+    }
+
 #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
 
     func testChangeStartTimeStamp_OnlyFramesDelayAdded() throws {