refactor: Convert SentryCoreDataTrackingIntegration to Swift

Sources/Sentry/SentryBaseIntegration.m

@@ -91,12 +91,6 @@ - (BOOL)shouldBeEnabledWithOptions:(SentryOptions *)options
         return NO;
     }
 
-    if ((integrationOptions & kIntegrationOptionEnableCoreDataTracing)
-        && !options.enableCoreDataTracing) {
-        [self logWithOptionName:@"enableCoreDataTracing"];
-        return NO;
-    }
-
     if ((integrationOptions & kIntegrationOptionEnableSwizzling) && !options.enableSwizzling) {
         [self logWithOptionName:@"enableSwizzling"];
         return NO;

Sources/Sentry/SentryCoreDataSwizzlingHelper.h

@@ -0,0 +1,17 @@
+#import "SentryDefines.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SentryCoreDataSwizzlingHelper : NSObject
+
++ (void)swizzleWithTracker:(SENTRY_SWIFT_MIGRATION_ID(SentryCoreDataTracker))tracker;
+
++ (void)unswizzle;
+
+#if SENTRY_TEST || SENTRY_TEST_CI
++ (BOOL)swizzlingActive;
+#endif
+
+@end
+
+NS_ASSUME_NONNULL_END

Sources/Sentry/SentryCoreDataSwizzlingHelper.m

@@ -0,0 +1,78 @@
+#import "SentryCoreDataSwizzlingHelper.h"
+#import "SentryCoreDataTracker.h"
+#import "SentrySwift.h"
+#import "SentrySwizzle.h"
+#import <CoreData/CoreData.h>
+#import <objc/runtime.h>
+
+@implementation SentryCoreDataSwizzlingHelper
+
+static __weak SentryCoreDataTracker *_tracker = nil;
+#if SENTRY_TEST || SENTRY_TEST_CI
+static BOOL swizzlingIsActive = FALSE;
+#endif
+
+// SentrySwizzleInstanceMethod declaration shadows a local variable. The swizzling is working
+// fine and we accept this warning.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
++ (void)swizzleWithTracker:(SentryCoreDataTracker *)tracker
+{
+    _tracker = tracker;
+#if SENTRY_TEST || SENTRY_TEST_CI
+    swizzlingIsActive = TRUE;
+#endif
+
+    SEL fetchSelector = NSSelectorFromString(@"executeFetchRequest:error:");
+    SentrySwizzleInstanceMethod(NSManagedObjectContext.class, fetchSelector,
+        SentrySWReturnType(NSArray *),
+        SentrySWArguments(NSFetchRequest * originalRequest, NSError * *error), SentrySWReplacement({
+            return _tracker != nil
+                ? [_tracker
+                      managedObjectContext:self
+                       executeFetchRequest:originalRequest
+                                     error:error
+                               originalImp:^NSArray *(NSFetchRequest *request, NSError **outError) {
+                                   return SentrySWCallOriginal(request, outError);
+                               }]
+                : SentrySWCallOriginal(originalRequest, error);
+        }),
+        SentrySwizzleModeOncePerClassAndSuperclasses, (void *)fetchSelector);
+
+    SEL saveSelector = NSSelectorFromString(@"save:");
+    SentrySwizzleInstanceMethod(NSManagedObjectContext.class, saveSelector,
+        SentrySWReturnType(BOOL), SentrySWArguments(NSError * *error), SentrySWReplacement({
+            return _tracker != nil ? [_tracker managedObjectContext:self
+                                                               save:error
+                                                        originalImp:^BOOL(NSError **outError) {
+                                                            return SentrySWCallOriginal(outError);
+                                                        }]
+                                   : SentrySWCallOriginal(error);
+        }),
+        SentrySwizzleModeOncePerClassAndSuperclasses, (void *)saveSelector);
+}
+
++ (void)unswizzle
+{
+#if SENTRY_TEST || SENTRY_TEST_CI
+    _tracker = nil;
+    swizzlingIsActive = FALSE;
+
+    // Unswizzling is only supported in test targets as it is considered unsafe for production.
+    SEL fetchSelector = NSSelectorFromString(@"executeFetchRequest:error:");
+    SentryUnswizzleInstanceMethod(
+        NSManagedObjectContext.class, fetchSelector, (void *)fetchSelector);
+
+    SEL saveSelector = NSSelectorFromString(@"save:");
+    SentryUnswizzleInstanceMethod(NSManagedObjectContext.class, saveSelector, (void *)saveSelector);
+#endif // SENTRY_TEST || SENTRY_TEST_CI
+}
+#pragma clang diagnostic pop
+
+#if SENTRY_TEST || SENTRY_TEST_CI
++ (BOOL)swizzlingActive
+{
+    return swizzlingIsActive;
+}
+#endif
+@end

Sources/Sentry/SentrySDKInternal.m

@@ -4,7 +4,6 @@
 #import "SentryAutoBreadcrumbTrackingIntegration.h"
 #import "SentryBreadcrumb.h"
 #import "SentryClient+Private.h"
-#import "SentryCoreDataTrackingIntegration.h"
 #import "SentryCrash.h"
 #import "SentryHub+Private.h"
 #import "SentryInternalDefines.h"
@@ -503,8 +502,7 @@ + (void)endSession
             [SentryAppStartTrackingIntegration class], [SentryPerformanceTrackingIntegration class],
         [SentryUIEventTrackingIntegration class],
 #endif // SENTRY_HAS_UIKIT
-        [SentryAutoBreadcrumbTrackingIntegration class], [SentryCoreDataTrackingIntegration class],
-        nil];
+        [SentryAutoBreadcrumbTrackingIntegration class], nil];
 
     return defaultIntegrations;
 }

Sources/Sentry/include/SentryCoreDataSwizzlingHelper.h

@@ -0,0 +1,17 @@
+#import "SentryDefines.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SentryCoreDataSwizzlingHelper : NSObject
+
++ (void)swizzleWithTracker:(SENTRY_SWIFT_MIGRATION_ID(SentryCoreDataTracker))tracker;
+
++ (void)unswizzle;
+
+#if SENTRY_TEST || SENTRY_TEST_CI
++ (BOOL)swizzlingActive;
+#endif
+
+@end
+
+NS_ASSUME_NONNULL_END

Sources/Sentry/include/SentryCoreDataTracker.h

@@ -3,14 +3,14 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-@protocol SentryProcessInfoSource;
 @class SentryDefaultThreadInspector;
 
 @interface SentryCoreDataTracker : NSObject
 SENTRY_NO_INIT
 
 - (instancetype)initWithThreadInspector:(SentryDefaultThreadInspector *)threadInspector
-                     processInfoWrapper:(id<SentryProcessInfoSource>)processInfoWrapper;
+                     processInfoWrapper:
+                         (SENTRY_SWIFT_MIGRATION_ID(id<SentryProcessInfoSource>))processInfoWrapper;
 
 - (NSArray *)managedObjectContext:(NSManagedObjectContext *)context
               executeFetchRequest:(NSFetchRequest *)request

Sources/Sentry/include/SentryPrivate.h

@@ -45,6 +45,8 @@
 #import "SentryANRTrackerV2.h"
 #import "SentryAsyncLog.h"
 #import "SentryContinuousProfiler.h"
+#import "SentryCoreDataSwizzlingHelper.h"
+#import "SentryCoreDataTracker.h"
 #import "SentryCrash.h"
 #import "SentryCrashDebug.h"
 #import "SentryCrashInstallation+Private.h"

Sources/Swift/Core/Integrations/Integrations.swift

@@ -53,6 +53,7 @@ private struct AnyIntegration {
             .init(SentryNetworkTrackingIntegration.self),
             .init(SentryHangTrackerIntegrationObjC.self),
             .init(SentryMetricsIntegration.self),
+            .init(SentryCoreDataTrackingIntegration.self),
             .init(SentryFileIOTrackingIntegration.self)
         ])
 

Sources/Swift/Integrations/Performance/CoreData/SentryCoreDataSwizzling.swift

@@ -0,0 +1,13 @@
+// swiftlint:disable missing_docs
+@_implementationOnly import _SentryPrivate
+
+final class SentryCoreDataSwizzling: NSObject {
+    func start(with tracker: Any) {
+        SentryCoreDataSwizzlingHelper.swizzle(withTracker: tracker)
+    }
+
+    func stop() {
+        SentryCoreDataSwizzlingHelper.unswizzle()
+    }
+}
+// swiftlint:enable missing_docs