chore: dispatchAsyncOnMainQueue to dispatchAsyncOnMainQueueIfNotMainThread (#6132)

itaybre · web-flow · commit 60f11fb1bd37 · 2025-10-03T11:30:11.000-03:00
* fix: Always execute async even if called from main thread

* Update changelog

* Update changelog number

* Rename old method to `dispatchAsyncOnMainQueueIfNotMainThread` to reflect the behavior

* delete `DispatchAsyncOnMainQueue`

* Fix tests
diff --git a/SentryTestUtils/TestSentryDispatchQueueWrapper.swift b/SentryTestUtils/TestSentryDispatchQueueWrapper.swift
@@ -34,7 +34,7 @@ import Foundation
     public var blockOnMainInvocations = Invocations<() -> Void>()
     public var blockBeforeMainBlock: () -> Bool = { true }
 
-    public override func dispatchAsyncOnMainQueue(block: @escaping () -> Void) {
+    public override func dispatchAsyncOnMainQueueIfNotMainThread(block: @escaping () -> Void) {
         blockOnMainInvocations.record(block)
         if blockBeforeMainBlock() {
             block()
diff --git a/Sources/Sentry/Profiling/SentryContinuousProfiler.mm b/Sources/Sentry/Profiling/SentryContinuousProfiler.mm
@@ -197,17 +197,19 @@ + (nullable SentryId *)currentProfilerID
  */
 + (void)scheduleTimer
 {
-    sentry_dispatchAsyncOnMain(SentryDependencyContainer.sharedInstance.dispatchQueueWrapper, ^{
-        std::lock_guard<std::mutex> l(_threadUnsafe_gContinuousProfilerLock);
-        if (_chunkTimer != nil) {
-            SENTRY_LOG_WARN(@"There was already a timer in flight, but this codepath shouldn't be "
-                            @"taken if there is no profiler running.");
-            return;
-        }
-
-        _chunkTimer = sentry_scheduledTimerWithTarget(
-            kSentryProfilerChunkExpirationInterval, self, @selector(timerExpired), nil, YES);
-    });
+    sentry_dispatchAsyncOnMainIfNotMainThread(
+        SentryDependencyContainer.sharedInstance.dispatchQueueWrapper, ^{
+            std::lock_guard<std::mutex> l(_threadUnsafe_gContinuousProfilerLock);
+            if (_chunkTimer != nil) {
+                SENTRY_LOG_WARN(
+                    @"There was already a timer in flight, but this codepath shouldn't be "
+                    @"taken if there is no profiler running.");
+                return;
+            }
+
+            _chunkTimer = sentry_scheduledTimerWithTarget(
+                kSentryProfilerChunkExpirationInterval, self, @selector(timerExpired), nil, YES);
+        });
 }
 
 + (void)timerExpired
diff --git a/Sources/Sentry/Profiling/SentryProfilerState.mm b/Sources/Sentry/Profiling/SentryProfilerState.mm
@@ -72,7 +72,8 @@ - (instancetype)init
     if (self = [super init]) {
         _mutableState = [[SentryProfilerMutableState alloc] init];
         _mainThreadID = 0;
-        sentry_dispatchAsyncOnMain(SentryDependencyContainer.sharedInstance.dispatchQueueWrapper,
+        sentry_dispatchAsyncOnMainIfNotMainThread(
+            SentryDependencyContainer.sharedInstance.dispatchQueueWrapper,
             ^{ [self cacheMainThreadID]; });
     }
     return self;
diff --git a/Sources/Sentry/Profiling/SentryProfilingSwiftHelpers.m b/Sources/Sentry/Profiling/SentryProfilingSwiftHelpers.m
@@ -105,9 +105,10 @@
 }
 
 void
-sentry_dispatchAsyncOnMain(SentryDispatchQueueWrapper *wrapper, dispatch_block_t block)
+sentry_dispatchAsyncOnMainIfNotMainThread(
+    SentryDispatchQueueWrapper *wrapper, dispatch_block_t block)
 {
-    [wrapper dispatchAsyncOnMainQueue:block];
+    [wrapper dispatchAsyncOnMainQueueIfNotMainThread:block];
 }
 
 void
diff --git a/Sources/Sentry/Profiling/SentryTraceProfiler.mm b/Sources/Sentry/Profiling/SentryTraceProfiler.mm
@@ -84,15 +84,16 @@ + (void)recordMetrics
  */
 + (void)scheduleTimeoutTimer
 {
-    sentry_dispatchAsyncOnMain(SentryDependencyContainer.sharedInstance.dispatchQueueWrapper, ^{
-        std::lock_guard<std::mutex> l(_threadUnsafe_gTraceProfilerLock);
-        if (_sentry_threadUnsafe_traceProfileTimeoutTimer != nil) {
-            return;
-        }
-
-        _sentry_threadUnsafe_traceProfileTimeoutTimer = sentry_scheduledTimer(
-            kSentryProfilerTimeoutInterval, NO, ^{ [self timeoutTimerExpired]; });
-    });
+    sentry_dispatchAsyncOnMainIfNotMainThread(
+        SentryDependencyContainer.sharedInstance.dispatchQueueWrapper, ^{
+            std::lock_guard<std::mutex> l(_threadUnsafe_gTraceProfilerLock);
+            if (_sentry_threadUnsafe_traceProfileTimeoutTimer != nil) {
+                return;
+            }
+
+            _sentry_threadUnsafe_traceProfileTimeoutTimer = sentry_scheduledTimer(
+                kSentryProfilerTimeoutInterval, NO, ^{ [self timeoutTimerExpired]; });
+        });
 }
 
 + (void)timeoutTimerExpired
diff --git a/Sources/Sentry/SentryANRTrackerV1.m b/Sources/Sentry/SentryANRTrackerV1.m
@@ -87,7 +87,7 @@ - (void)detectANRs
 
         atomic_fetch_add_explicit(&ticksSinceUiUpdate, 1, memory_order_relaxed);
 
-        [self.dispatchQueueWrapper dispatchAsyncOnMainQueue:^{
+        [self.dispatchQueueWrapper dispatchAsyncOnMainQueueIfNotMainThread:^{
             atomic_store_explicit(&ticksSinceUiUpdate, 0, memory_order_relaxed);
 
             bool isReported = atomic_load_explicit(&reported, memory_order_relaxed);
diff --git a/Sources/Sentry/SentryFramesTracker.m b/Sources/Sentry/SentryFramesTracker.m
@@ -113,7 +113,7 @@ - (void)resetProfilingTimestamps
     // The DisplayLink callback always runs on the main thread. We dispatch this to the main thread
     // instead to avoid using locks in the DisplayLink callback.
     [self.dispatchQueueWrapper
-        dispatchAsyncOnMainQueue:^{ [self resetProfilingTimestampsInternal]; }];
+        dispatchAsyncOnMainQueueIfNotMainThread:^{ [self resetProfilingTimestampsInternal]; }];
 }
 
 - (void)resetProfilingTimestampsInternal
@@ -306,14 +306,15 @@ - (SentryFramesDelayResult *)getFramesDelay:(uint64_t)startSystemTimestamp
 - (void)addListener:(id<SentryFramesTrackerListener>)listener
 {
     // Adding listeners on the main thread to avoid race condition with new frame callback
-    [self.dispatchQueueWrapper dispatchAsyncOnMainQueue:^{ [self.listeners addObject:listener]; }];
+    [self.dispatchQueueWrapper
+        dispatchAsyncOnMainQueueIfNotMainThread:^{ [self.listeners addObject:listener]; }];
 }
 
 - (void)removeListener:(id<SentryFramesTrackerListener>)listener
 {
     // Removing listeners on the main thread to avoid race condition with new frame callback
     [self.dispatchQueueWrapper
-        dispatchAsyncOnMainQueue:^{ [self.listeners removeObject:listener]; }];
+        dispatchAsyncOnMainQueueIfNotMainThread:^{ [self.listeners removeObject:listener]; }];
 }
 
 - (void)pause
diff --git a/Sources/Sentry/SentrySDKInternal.m b/Sources/Sentry/SentrySDKInternal.m
@@ -268,29 +268,30 @@ + (void)startWithOptions:(SentryOptions *)options
         = options.initialScope([[SentryScope alloc] initWithMaxBreadcrumbs:options.maxBreadcrumbs]);
 
     SENTRY_LOG_DEBUG(@"Dispatching init work required to run on main thread.");
-    [SentryDependencyContainer.sharedInstance.dispatchQueueWrapper dispatchAsyncOnMainQueue:^{
-        SENTRY_LOG_DEBUG(@"SDK main thread init started...");
+    [SentryDependencyContainer.sharedInstance.dispatchQueueWrapper
+        dispatchAsyncOnMainQueueIfNotMainThread:^{
+            SENTRY_LOG_DEBUG(@"SDK main thread init started...");
 
         // The UIDeviceWrapper needs to start before the Hub, because the Hub
         // enriches the scope, which calls the UIDeviceWrapper.
 #if SENTRY_HAS_UIKIT
-        [SentryDependencyContainer.sharedInstance.uiDeviceWrapper start];
+            [SentryDependencyContainer.sharedInstance.uiDeviceWrapper start];
 #endif // TARGET_OS_IOS && SENTRY_HAS_UIKIT
 
-        // The Hub needs to be initialized with a client so that closing a session
-        // can happen.
-        SentryHub *hub = [[SentryHub alloc] initWithClient:newClient andScope:scope];
-        [SentrySDKInternal setCurrentHub:hub];
+            // The Hub needs to be initialized with a client so that closing a session
+            // can happen.
+            SentryHub *hub = [[SentryHub alloc] initWithClient:newClient andScope:scope];
+            [SentrySDKInternal setCurrentHub:hub];
 
-        [SentryDependencyContainer.sharedInstance.crashWrapper startBinaryImageCache];
-        [SentryDependencyContainer.sharedInstance.binaryImageCache start:options.debug];
+            [SentryDependencyContainer.sharedInstance.crashWrapper startBinaryImageCache];
+            [SentryDependencyContainer.sharedInstance.binaryImageCache start:options.debug];
 
-        [SentrySDKInternal installIntegrations];
+            [SentrySDKInternal installIntegrations];
 
 #if SENTRY_TARGET_PROFILING_SUPPORTED
-        sentry_sdkInitProfilerTasks(options, hub);
+            sentry_sdkInitProfilerTasks(options, hub);
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
-    }];
+        }];
 
     SENTRY_LOG_DEBUG(@"SDK initialized! Version: %@", SentryMeta.versionString);
 }
diff --git a/Sources/Sentry/SentrySubClassFinder.m b/Sources/Sentry/SentrySubClassFinder.m
@@ -88,7 +88,7 @@ - (void)actOnSubclassesOfViewControllerInImage:(NSString *)imageName block:(void
         }
 
         free(classes);
-        [self.dispatchQueue dispatchAsyncOnMainQueue:^{
+        [self.dispatchQueue dispatchAsyncOnMainQueueIfNotMainThread:^{
             for (NSString *className in classesToSwizzle) {
                 block(NSClassFromString(className));
             }
diff --git a/Sources/Sentry/SentryTimeToDisplayTracker.m b/Sources/Sentry/SentryTimeToDisplayTracker.m
@@ -134,7 +134,8 @@ - (void)reportFullyDisplayed
     SENTRY_LOG_DEBUG(@"Reporting full display for %@", _name);
     // All other accesses to _fullyDisplayedReported run on the main thread.
     // To avoid using locks, we execute this on the main queue instead.
-    [_dispatchQueueWrapper dispatchAsyncOnMainQueue:^{ self->_fullyDisplayedReported = YES; }];
+    [_dispatchQueueWrapper
+        dispatchAsyncOnMainQueueIfNotMainThread:^{ self->_fullyDisplayedReported = YES; }];
 }
 
 - (void)finishSpansIfNotFinished
diff --git a/Sources/Sentry/_SentryDispatchQueueWrapperInternal.m b/Sources/Sentry/_SentryDispatchQueueWrapperInternal.m
@@ -36,16 +36,7 @@ - (instancetype)initWithName:(const char *)name relativePriority:(int)relativePr
     return self;
 }
 
-- (void)dispatchAsyncWithBlock:(void (^)(void))block
-{
-    dispatch_async(_queue, ^{
-        @autoreleasepool {
-            block();
-        }
-    });
-}
-
-- (void)dispatchAsyncOnMainQueue:(void (^)(void))block
+- (void)dispatchAsyncOnMainQueueIfNotMainThread:(void (^)(void))block
 {
     if ([NSThread isMainThread]) {
         block();
@@ -58,6 +49,15 @@ - (void)dispatchAsyncOnMainQueue:(void (^)(void))block
     }
 }
 
+- (void)dispatchAsyncWithBlock:(void (^)(void))block
+{
+    dispatch_async(_queue, ^{
+        @autoreleasepool {
+            block();
+        }
+    });
+}
+
 - (void)dispatchSync:(void (^)(void))block
 {
     dispatch_sync(_queue, block);
diff --git a/Sources/Sentry/include/SentryProfilingSwiftHelpers.h b/Sources/Sentry/include/SentryProfilingSwiftHelpers.h
@@ -36,7 +36,8 @@ SentrySpanId *_Nullable sentry_getParentSpanID(SentryTransactionContext *context
 SentryId *sentry_getTraceID(SentryTransactionContext *context);
 BOOL sentry_isNotSampled(SentryTransactionContext *context);
 void sentry_dispatchAsync(SentryDispatchQueueWrapper *wrapper, dispatch_block_t block);
-void sentry_dispatchAsyncOnMain(SentryDispatchQueueWrapper *wrapper, dispatch_block_t block);
+void sentry_dispatchAsyncOnMainIfNotMainThread(
+    SentryDispatchQueueWrapper *wrapper, dispatch_block_t block);
 void sentry_addObserver(id observer, SEL selector, NSNotificationName name, _Nullable id object);
 void sentry_removeObserver(id observer);
 void sentry_postNotification(NSNotification *notification);
diff --git a/Sources/Sentry/include/_SentryDispatchQueueWrapperInternal.h b/Sources/Sentry/include/_SentryDispatchQueueWrapperInternal.h
@@ -21,9 +21,6 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)dispatchSync:(void (^)(void))block;
 
-- (void)dispatchAsyncOnMainQueue:(void (^)(void))block
-    NS_SWIFT_NAME(dispatchAsyncOnMainQueue(block:));
-
 - (void)dispatchSyncOnMainQueue:(void (^)(void))block
     NS_SWIFT_NAME(dispatchSyncOnMainQueue(block:));
 
@@ -33,6 +30,9 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)dispatchOnce:(dispatch_once_t *)predicate block:(void (^)(void))block;
 
+- (void)dispatchAsyncOnMainQueueIfNotMainThread:(void (^)(void))block
+    NS_SWIFT_NAME(dispatchAsyncOnMainQueueIfNotMainThread(block:));
+
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/Sources/Swift/Core/Helper/SentryUIDeviceWrapper.swift b/Sources/Swift/Core/Helper/SentryUIDeviceWrapper.swift
@@ -33,7 +33,7 @@ import UIKit
     }
 
     @objc public func start() {
-        queueWrapper.dispatchAsyncOnMainQueue { [weak self] in
+        queueWrapper.dispatchAsyncOnMainQueueIfNotMainThread { [weak self] in
             guard let self else { return }
 #if os(iOS)
             if !UIDevice.current.isGeneratingDeviceOrientationNotifications {
@@ -57,7 +57,7 @@ import UIKit
         let needsCleanup = self.cleanupDeviceOrientationNotifications
         let needsDisablingBattery = self.cleanupBatteryMonitoring
         let device = UIDevice.current
-        queueWrapper.dispatchAsyncOnMainQueue {
+        queueWrapper.dispatchAsyncOnMainQueueIfNotMainThread {
             if needsCleanup {
                 device.endGeneratingDeviceOrientationNotifications()
             }
diff --git a/Sources/Swift/Helper/SentryDispatchQueueWrapper.swift b/Sources/Swift/Helper/SentryDispatchQueueWrapper.swift
@@ -32,9 +32,9 @@
         internalWrapper.dispatchSync(block)
     }
     
-    @objc(dispatchAsyncOnMainQueue:)
-    public func dispatchAsyncOnMainQueue(block: @escaping () -> Void) {
-        internalWrapper.dispatchAsyncOnMainQueue(block: block)
+    @objc(dispatchAsyncOnMainQueueIfNotMainThread:)
+    public func dispatchAsyncOnMainQueueIfNotMainThread(block: @escaping () -> Void) {
+        internalWrapper.dispatchAsyncOnMainQueueIfNotMainThread(block: block)
     }
 
     @objc(dispatchSyncOnMainQueue:)
diff --git a/Tests/SentryTests/Networking/SentryDispatchQueueWrapperTests.swift b/Tests/SentryTests/Networking/SentryDispatchQueueWrapperTests.swift
@@ -2,7 +2,7 @@ import _SentryPrivate
 @_spi(Private) @testable import Sentry
 import XCTest
 
-class SentryDispatchQueueWrapperTests: XCTestCase {
+class SentryDispatchQueueWrapperSwiftTests: XCTestCase {
 
     func testDispatchOnce() {
         var a = 0
@@ -28,4 +28,44 @@ class SentryDispatchQueueWrapperTests: XCTestCase {
         XCTAssertFalse(secondWasCalled)
         XCTAssertTrue(thirdWasCalled)
     }
+    
+    func testDispatchAsyncOnMainQueueIfNotMainThreadOnMain() {
+        let expectation = XCTestExpectation()
+        
+        var flag = false
+        
+        let sut = SentryDispatchQueueWrapper()
+        sut.dispatchAsyncOnMainQueueIfNotMainThread {
+            XCTAssertTrue(Thread.isMainThread)
+            XCTAssertFalse(flag, "Block did not run synchronously")
+            
+            expectation.fulfill()
+        }
+        flag = true
+        
+        wait(for: [expectation], timeout: 2)
+    }
+    
+    func testDispatchAsyncOnMainQueueIfNotMainThreadFromBackground() {
+        let expectation = XCTestExpectation()
+        
+        DispatchQueue.global().async {
+            let innerExpectation = XCTestExpectation(description: "Expectation on background thread")
+            
+            var flag = false
+            let sut = SentryDispatchQueueWrapper()
+            sut.dispatchAsyncOnMainQueueIfNotMainThread {
+                XCTAssertTrue(Thread.isMainThread)
+                XCTAssertTrue(flag, "Block did not run asynchronously")
+                
+                innerExpectation.fulfill()
+            }
+            flag = true
+            
+            self.wait(for: [innerExpectation], timeout: 2)
+            expectation.fulfill()
+        }
+        
+        wait(for: [expectation], timeout: 2)
+    }
 }
diff --git a/Tests/SentryTests/SentrySDKInternalTests.swift b/Tests/SentryTests/SentrySDKInternalTests.swift
@@ -566,7 +566,7 @@ class SentrySDKInternalTests: XCTestCase {
             }
 
             // Since the SDK uses the dispatchqueue on the main queue, wait until it clears to fulfill the expectation
-            SentryDependencyContainer.sharedInstance().dispatchQueueWrapper.dispatchAsyncOnMainQueue {
+            SentryDependencyContainer.sharedInstance().dispatchQueueWrapper.dispatchAsyncOnMainQueueIfNotMainThread {
                 expectation.fulfill()
             }
         }
@@ -773,7 +773,7 @@ class SentrySDKInternalTests: XCTestCase {
             }
 
             // Since the SDK uses the dispatchqueue on the main queue, wait until it clears to fulfill the expectation
-            SentryDependencyContainer.sharedInstance().dispatchQueueWrapper.dispatchAsyncOnMainQueue {
+            SentryDependencyContainer.sharedInstance().dispatchQueueWrapper.dispatchAsyncOnMainQueueIfNotMainThread {
                 expectation.fulfill()
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -105,9 +105,10 @@`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`void`
`108`		`-sentry_dispatchAsyncOnMain(SentryDispatchQueueWrapper *wrapper, dispatch_block_t block)`
	`108`	`+sentry_dispatchAsyncOnMainIfNotMainThread(`
	`109`	`+ SentryDispatchQueueWrapper *wrapper, dispatch_block_t block)`
`109`	`110`	`{`
`110`		`- [wrapper dispatchAsyncOnMainQueue:block];`
	`111`	`+ [wrapper dispatchAsyncOnMainQueueIfNotMainThread:block];`
`111`	`112`	`}`
`112`	`113`
`113`	`114`	`void`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ - (void)resetProfilingTimestamps`
`113`	`113`	`// The DisplayLink callback always runs on the main thread. We dispatch this to the main thread`
`114`	`114`	`// instead to avoid using locks in the DisplayLink callback.`
`115`	`115`	`[self.dispatchQueueWrapper`
`116`		`- dispatchAsyncOnMainQueue:^{ [self resetProfilingTimestampsInternal]; }];`
	`116`	`+ dispatchAsyncOnMainQueueIfNotMainThread:^{ [self resetProfilingTimestampsInternal]; }];`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`- (void)resetProfilingTimestampsInternal`
`@@ -306,14 +306,15 @@ - (SentryFramesDelayResult *)getFramesDelay:(uint64_t)startSystemTimestamp`
`306`	`306`	`- (void)addListener:(id<SentryFramesTrackerListener>)listener`
`307`	`307`	`{`
`308`	`308`	`// Adding listeners on the main thread to avoid race condition with new frame callback`
`309`		`- [self.dispatchQueueWrapper dispatchAsyncOnMainQueue:^{ [self.listeners addObject:listener]; }];`
	`309`	`+ [self.dispatchQueueWrapper`
	`310`	`+ dispatchAsyncOnMainQueueIfNotMainThread:^{ [self.listeners addObject:listener]; }];`
`310`	`311`	`}`
`311`	`312`
`312`	`313`	`- (void)removeListener:(id<SentryFramesTrackerListener>)listener`
`313`	`314`	`{`
`314`	`315`	`// Removing listeners on the main thread to avoid race condition with new frame callback`
`315`	`316`	`[self.dispatchQueueWrapper`
`316`		`- dispatchAsyncOnMainQueue:^{ [self.listeners removeObject:listener]; }];`
	`317`	`+ dispatchAsyncOnMainQueueIfNotMainThread:^{ [self.listeners removeObject:listener]; }];`
`317`	`318`	`}`
`318`	`319`
`319`	`320`	`- (void)pause`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ - (void)actOnSubclassesOfViewControllerInImage:(NSString *)imageName block:(void`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`free(classes);`
`91`		`- [self.dispatchQueue dispatchAsyncOnMainQueue:^{`
	`91`	`+ [self.dispatchQueue dispatchAsyncOnMainQueueIfNotMainThread:^{`
`92`	`92`	`for (NSString *className in classesToSwizzle) {`
`93`	`93`	`block(NSClassFromString(className));`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,8 @@ - (void)reportFullyDisplayed`
`134`	`134`	`SENTRY_LOG_DEBUG(@"Reporting full display for %@", _name);`
`135`	`135`	`// All other accesses to _fullyDisplayedReported run on the main thread.`
`136`	`136`	`// To avoid using locks, we execute this on the main queue instead.`
`137`		`- [_dispatchQueueWrapper dispatchAsyncOnMainQueue:^{ self->_fullyDisplayedReported = YES; }];`
	`137`	`+ [_dispatchQueueWrapper`
	`138`	`+ dispatchAsyncOnMainQueueIfNotMainThread:^{ self->_fullyDisplayedReported = YES; }];`
`138`	`139`	`}`
`139`	`140`
`140`	`141`	`- (void)finishSpansIfNotFinished`