getsentry · NinjaLikesCheez · Jul 16, 2026 · Jul 16, 2026 · Jul 16, 2026 · Jul 16, 2026
@@ -4,6 +4,7 @@
 
 ### Features
 
+- Install KSCrash crash handler in `Sentry+KSCrash` with production-safe monitors matching SentryCrash's existing monitor set (#8469)
 - Add `options.dataCollection` to configure data collection behaviour (#8448)
   - Allows dictionary initialization for `options.dataCollection` (#8371)
   - Renamed `options.dataCollection.queryParams` to `options.dataCollection.urlQueryParams` (#8414)

@@ -25,7 +25,6 @@ class TestCleanup: NSObject {
         SentrySDK.close()
         SentrySDKInternal.setCurrentHub(nil)
         SentrySDKInternal.lastRunStatusCalled = false
-        SentrySDKInternal.crashReporterInstalled = false
         SentrySDKInternal.fatalDetected = false
         SentrySDKInternal.startInvocations = 0
         SentrySDKInternal.setDetectedStartUpCrash(false)

@@ -28,7 +28,15 @@ MACH_O_TYPE = mh_dylib
 // see https://github.com/getsentry/sentry-cocoa/pull/8426 for more context
 ARCHS[sdk=appletvos*] = $(ARCHS_STANDARD)
 ARCHS[sdk=watchos*] = $(ARCHS_STANDARD)
-ARCHS[sdk=maccatalyst*] = $(ARCHS_STANDARD)
+
+// Mac Catalyst is not affected by iOSPackagesShouldBuildARM64e, so KSCrash SPM packages
+// never produce arm64e slices for maccatalyst. Mac Catalyst also doesn't have
+// it's own SDK name, we so we need to do some working around to use the one
+// build setting that shows Mac Catalyst is being build for: IS_MACCATALYST.
+// Key off it via nested macro substitution instead.
+SENTRY_KSCRASH_ARM64E_IF_NOT_CATALYST_YES =
+SENTRY_KSCRASH_ARM64E_IF_NOT_CATALYST_NO = arm64e
+ARCHS[sdk=macosx*] = arm64 x86_64 $(SENTRY_KSCRASH_ARM64E_IF_NOT_CATALYST_$(IS_MACCATALYST))
 
 // Both this target and the base Sentry target share PRODUCT_MODULE_NAME=Sentry. Xcode's
 // explicit module scanner can't tell them apart and emits a spurious missing-dependency

@@ -17,6 +17,14 @@
 #import "SentrySwift.h"
 #import "SentryTransactionContext.h"
 
+#if ENABLE_KSCRASH
+// Forward declared from SentryKSCrash+Query.swift
+@interface SentryKSCrashQuery <NSObject>
+@property (nonatomic, readonly) BOOL installed;
+@property (nonatomic, readonly) BOOL crashedLastLaunch;
+@end
+#endif // ENABLE_KSCRASH
+
 #if TARGET_OS_OSX
 #    import "SentryCrashExceptionApplication.h"
 #endif // TARGET_OS_MAC
@@ -38,7 +46,6 @@ @implementation SentrySDKInternal
 static SentryHubInternal *_Nullable currentHub;
 static NSObject *currentHubLock;
 static BOOL lastRunStatusCalled;
-static BOOL crashReporterInstalled;
 static BOOL fatalDetected;
 static SentryAppStartMeasurement *_Nullable sentrySDKappStartMeasurement;
 static NSObject *sentrySDKappStartMeasurementLock;
@@ -143,12 +150,11 @@ + (void)setLastRunStatusCalled:(BOOL)value
 
 + (BOOL)crashReporterInstalled
 {
-    return crashReporterInstalled;
-}
-
-+ (void)setCrashReporterInstalled:(BOOL)value
-{
-    crashReporterInstalled = value;
+#if ENABLE_KSCRASH
+    return SentryDependencyContainer.sharedInstance.kscrashQuery.installed;
+#else
+    return SentryDependencyContainer.sharedInstance.crashWrapper.installed;
+#endif
 }
 
 + (BOOL)fatalDetected
@@ -276,7 +282,7 @@ + (void)startWithOptions:(SentryOptions *)options
             // The .didCrash case is handled by SentryClient.prepareEvent when
             // a fatal event arrives. Here we report .didNotCrash if no
             // integration set fatalDetected during init.
-            if (crashReporterInstalled && !fatalDetected) {
+            if ([SentrySDKInternal crashReporterInstalled] && !fatalDetected) {
                 lastRunStatusCalled = YES;
                 if (nil != options.onLastRunStatusDetermined) {
                     options.onLastRunStatusDetermined(SentryLastRunStatusDidNotCrash, nil);
@@ -502,12 +508,19 @@ + (BOOL)crashedLastRun
 
 + (NSInteger)lastRunStatus
 {
-    if (!crashReporterInstalled) {
+    if (![SentrySDKInternal crashReporterInstalled]) {
         return SentryLastRunStatusUnknown;
     }
+
+#if ENABLE_KSCRASH
+    if (SentryDependencyContainer.sharedInstance.kscrashQuery.crashedLastLaunch) {
+        return SentryLastRunStatusDidCrash;
+    }
+#else
     if (SentryDependencyContainer.sharedInstance.crashWrapper.crashedLastLaunch) {
         return SentryLastRunStatusDidCrash;
     }
+#endif
     return SentryLastRunStatusDidNotCrash;
 }
 
@@ -604,7 +617,6 @@ + (void)close
 
         [SentrySDKInternal setCurrentHub:nil];
 
-        crashReporterInstalled = NO;
         fatalDetected = NO;
         lastRunStatusCalled = NO;
 

@@ -189,6 +189,8 @@ SENTRY_NO_INIT
 /** If true, the application crashed on the previous launch. */
 @property (nonatomic, readonly, assign) BOOL crashedLastLaunch;
 
+@property (nonatomic, readonly) BOOL installed;
+
 /** The total number of unsent reports. Note: This is an expensive operation. */
 @property (nonatomic, readonly, assign) int reportCount;
 

@@ -290,6 +290,8 @@ - (BOOL)install
                              object:nil];
 #endif // SENTRY_HAS_NSEXTENSION
 
+    _installed = true;
+
     return true;
 }
 
@@ -300,6 +302,7 @@ - (void)uninstall
     self.monitoringFromUninstalledToRestore = YES;
     self.onCrash = NULL;
     sentrycrash_uninstall();
+    _installed = false;
 
 #if SENTRY_HAS_UIKIT
     id<SentryNSNotificationCenterWrapper> notificationCenter

@@ -54,7 +54,7 @@ private struct AnyIntegration {
         #endif
 
         #if ENABLE_KSCRASH
-        integrations.append(.init(SentryKSCrashIntegration.self))
+        integrations.append(.init(SentryKSCrash.Integration.self))
         #else
         integrations.append(.init(SentryCrashIntegration.self))
         #endif

@@ -0,0 +1,47 @@
+#if ENABLE_KSCRASH
+// swiftlint:disable:next no_implementation_only_import
+@_implementationOnly import KSCrashInstallations
+
+extension SentryKSCrash {
+    protocol Installing {
+        /// Install the crash handler.
+        /// - Parameters:
+        ///   - installPath: The base directory for crash report storage.
+        ///   - monitors: Monitor types to enable.
+        ///   - enableSwapCxaThrow: Whether to swap `__cxa_throw` for better C++ stacks.
+        /// - Throws: Any error from `KSCrash.installWithConfiguration(_:error:)`.
+        func install(installPath: String, monitors: UInt, enableSwapCxaThrow: Bool) throws
+
+        /// Whether the previous run crashed.
+        var crashedLastLaunch: Bool { get }
+
+        var installed: Bool { get }
+    }
+
+    /// Configures and installs a crash handler
+    struct Installer: SentryKSCrash.Installing {
+        func install(installPath: String, monitors: UInt, enableSwapCxaThrow: Bool) throws {
+            let config = KSCrashConfiguration()
+            config.installPath = installPath
+            config.monitors = MonitorType(rawValue: monitors)
+            config.enableSwapCxaThrow = enableSwapCxaThrow
+            do {
+                try KSCrash.shared.install(with: config)
+            } catch let error as NSError
+                        where error.domain == "KSCrashErrorDomain" && error.code == 1 /* KSCrashInstallErrorAlreadyInstalled */ {
+                // KSCrash holds a process-lifetime C flag, so install() fails on every
+                // subsequent call within the same process (common during tests and SDK re-init).
+                // The crash handler is already running — treat this as success.
+                SentrySDKLog.debug("KSCrash already installed; continuing.")
+            }
+        }
+
+        var crashedLastLaunch: Bool { KSCrash.shared.crashedLastLaunch }
+
+        var installed: Bool {
+            // From KSCrash docs: 'If the crash reporter is not installed, this will be `nil`'
+            KSCrash.shared.reportStore != nil
+        }
+    }
+}
+#endif
@@ -0,0 +1,76 @@
+#if ENABLE_KSCRASH
+// swiftlint:disable:next no_implementation_only_import
+@_implementationOnly import KSCrashInstallations
+internal import _SentryPrivate
+import Foundation
+
+// MARK: - Integration
+extension SentryKSCrash {
+    typealias DependencyProvider = SentryKSCrash.InstallerProvider
+
+    /// Crash detectors matching SentryCrash's production monitor set:
+    /// Mach exceptions, signals, C++ exceptions, and NSExceptions.
+    /// KSCrash unconditionally adds its Required monitors (System, AppState,
+    /// UserInfo, Resource) on top of whatever is passed here.
+    static let productionSafeMonitors: UInt = MonitorType([
+        .machException,
+        .signal,
+        .cppException,
+        .nsException
+    ]).rawValue
+
+    final class Integration<Dependencies: DependencyProvider>: NSObject, SwiftIntegration {
+        private weak var options: Options?
+
+        // MARK: - Initialization
+
+        init?(with options: Options, dependencies: Dependencies) {
+            guard options.enableCrashHandler else {
+                SentrySDKLog.debug("Not going to enable \(Self.name) because enableCrashHandler is disabled.")
+                return nil
+            }
+
+            self.options = options
+            super.init()
+
+            let installer = dependencies.getKSCrashInstaller()
+
+            // To match KSCrash & SentryCrash, we need to add 'KSCrash/<bundlename>' to the cacheDirectoryPath
+            let installPath = Self.installPath(for: options.cacheDirectoryPath, bundleInfo: Bundle.main.infoDictionary)
+
+            do {
+                try installer.install(
+                    installPath: installPath.path,
+                    monitors: productionSafeMonitors,
+                    enableSwapCxaThrow: options.experimental.enableUnhandledCPPExceptionsV2
+                )
+            } catch {
+                SentrySDKLog.error("KSCrash install failed: \(error)")
+                return nil
+            }
+
+            if installer.crashedLastLaunch {
+                SentrySDKInternal.fatalDetected = true
+            }
+        }
+
+        // MARK: - SwiftIntegration
+        static var name: String {
+            "SentryKSCrashIntegration"
+        }
+
+        func uninstall() {}
+
+        // MARK: - Helpers
+        /// Get the install path for the crash reporter
+        /// This method exists to centralize path building to save rebuilding it manually in tests
+        static func installPath(for cacheDirectoryPath: String, bundleInfo: [String: Any]?) -> URL {
+            let bundleName = bundleInfo?["CFBundleName"] as? String ?? "Unknown"
+            return URL(fileURLWithPath: cacheDirectoryPath)
+                .appendingPathComponent("KSCrash")
+                .appendingPathComponent(bundleName.replacingOccurrences(of: "/", with: "-"))
+                .absoluteURL
+        }
+    }
+}
+#endif
@@ -0,0 +1,46 @@
+#if ENABLE_KSCRASH
+// swiftlint:disable:next no_implementation_only_import
+@_implementationOnly import KSCrashInstallations
+internal import _SentryPrivate
+
+extension SentryKSCrash {
+    protocol QueryProvider {
+        associatedtype Querying: SentryKSCrash.Querying
+
+        var kscrashQuery: Querying { get }
+    }
+}
+
+extension SentryKSCrash {
+    /// Allows querying the state of the crash reporter
+    @objc(SentryKSCrashQuerying)
+    public protocol Querying: NSObjectProtocol {
+        /// Whether KSCrash has been successfully installed this session.
+        @objc var installed: Bool { get }
+        /// Whether KSCrash crashed on the previous launch.
+        @objc var crashedLastLaunch: Bool { get }
+    }
+}
+
+extension SentryKSCrash {
+    /// An ObjC-accessible class that surfaces live KSCrash crash state to ObjC callers
+    /// without adding `@objc` to `SentryKSCrash.Installer`.
+    @_spi(Private)
+    @objc(SentryKSCrashQuery)
+    final public class Query: NSObject, Querying {
+        private let installer: any Installing
+
+        init(installer: some Installing) {
+            self.installer = installer
+        }
+
+        // swiftlint:disable missing_docs
+        @objc
+        public var installed: Bool { installer.installed }
+
+        @objc
+        public var crashedLastLaunch: Bool { installer.crashedLastLaunch }
+        //swiftlint:enable missing_docs
+    }
+}
+#endif
@@ -0,0 +1,12 @@
+#if ENABLE_KSCRASH
+/// All types related to KSCrash should live under this type
+@_spi(Private) public enum SentryKSCrash {
+    /// Provides a `KSCrashInstalling` instance for dependency injection.
+    protocol InstallerProvider {
+        /// The installer used to set up KSCrash crash reporting.
+        associatedtype Installing: SentryKSCrash.Installing
+
+        func getKSCrashInstaller() -> Installing
+    }
+}
+#endif
@@ -156,7 +156,6 @@ final class SentryCrashIntegration<Dependencies: CrashIntegrationProvider>: NSOb
         // SentrySDK.lastRunStatus returns a definitive answer and the integration
         // installer can determine the .didNotCrash case. We can't use
         // isIntegrationInstalled because it's set after init returns.
-        SentrySDKInternal.crashReporterInstalled = true
         if SentryDependencyContainer.sharedInstance().crashWrapper.crashedLastLaunch {
             SentrySDKInternal.fatalDetected = true
         }

@@ -2,6 +2,7 @@
 import Foundation
 
 @_spi(Private) @objc public protocol SentryCrashReporter: NSObjectProtocol {
+    @objc var installed: Bool { get }
     @objc var crashedLastLaunch: Bool { get }
     @objc var durationFromCrashStateInitToLastCrash: TimeInterval { get }
     @objc var activeDurationSinceLastCrash: TimeInterval { get }

@@ -73,7 +73,11 @@ private final class CrashReportFilterBridge: NSObject, SentryCrashReportFilter {
     @objc public func install() {
         sentryCrash.install()
     }
-
+
+    @objc public var installed: Bool {
+        sentryCrash.installed
+    }
+
     @objc public func uninstall() {
         sentryCrash.uninstall()
     }