fix(crash-reporting): keep backtrace reporter registration open when not opting out

Registering the policy-only `BacktraceReportingFeature` unconditionally claimed the single
registration slot, so the `get(feature:) == nil` guard in `register(backtraceReporter:)`
silently dropped any reporter registered afterwards — losing `binary_images` from logs and
RUM view events for apps using a custom plugin with no backtrace reporter. Record the
policy only when App Hang backtraces are actually turned off, leaving the default path
behaving exactly as it did before.

Restore `register(backtraceReporter:)` as its own symbol and add the
`appHangBacktraceEnabled` variant as an overload, so the existing compound name and mangled
symbol stay unchanged for XCFramework consumers. `DatadogInternal` is not part of
`DATADOG_MODULES`, so `make api-surface-verify` does not catch this class of change.

Tests: the App Hang integration test picked its RUM / Crash Reporting enablement order with
`oneOf`, so the lazy per-hang read of the opt-out was only exercised on about half the runs;
split it into two deterministic tests. Add coverage for the reporter-less default path, for
the public plugin+configuration overload forwarding its argument, and for the Objective-C
configuration default and setter.

Author: Valpertui

Datadog/IntegrationUnitTests/RUM/AppHangsMonitoringTests.swift

@@ -116,19 +116,28 @@ class AppHangsMonitoringTests: XCTestCase {
         #endif
     }
 
-    func testGivenAppHangBacktracesDisabledInCrashReporting_whenMainThreadHangs_itTracksAppHangWithNoStackTrace() throws {
+    func testGivenAppHangBacktracesDisabledInCrashReporting_whenRUMIsEnabledFirst_itTracksAppHangWithNoStackTrace() throws {
+        try assertAppHangIsTrackedWithNoStackTrace { crashReportingConfig in
+            RUM.enable(with: self.rumConfig, in: self.core)
+            CrashReporting.enable(with: crashReportingConfig, in: self.core)
+        }
+    }
+
+    func testGivenAppHangBacktracesDisabledInCrashReporting_whenCrashReportingIsEnabledFirst_itTracksAppHangWithNoStackTrace() throws {
+        try assertAppHangIsTrackedWithNoStackTrace { crashReportingConfig in
+            CrashReporting.enable(with: crashReportingConfig, in: self.core)
+            RUM.enable(with: self.rumConfig, in: self.core)
+        }
+    }
+
+    /// Asserts that a hang is tracked with no stack trace, with the SDK enabled by `enableSDK`.
+    ///
+    /// Both enablement orders get their own test rather than being picked at random: only the RUM-first order
+    /// proves that the opt-out is read per hang instead of being captured when RUM is enabled, so randomizing
+    /// would let that regression pass half of the runs.
+    private func assertAppHangIsTrackedWithNoStackTrace(enableSDK: (CrashReporting.Configuration) -> Void) throws {
         // Given (initialize SDK on the main thread)
-        let crashReportingConfig = CrashReporting.Configuration(appHangBacktraceEnabled: false)
-        oneOf([ // no matter of RUM or CR initialization order
-            {
-                RUM.enable(with: self.rumConfig, in: self.core)
-                CrashReporting.enable(with: crashReportingConfig, in: self.core)
-            },
-            {
-                CrashReporting.enable(with: crashReportingConfig, in: self.core)
-                RUM.enable(with: self.rumConfig, in: self.core)
-            },
-        ])
+        enableSDK(CrashReporting.Configuration(appHangBacktraceEnabled: false))
 
         // When
         mainQueue.sync {

DatadogCore/Tests/Objc/ObjcAPITests/DDConfiguration+apiTests.m

@@ -73,6 +73,13 @@ - (void)testDDConfigurationBuilderAPI {
 
 - (void)testDatadogCrashReporterAPI {
     [DDCrashReporter enable];
+
+    DDCrashReporterConfiguration *configuration = [DDCrashReporterConfiguration new];
+    XCTAssertTrue(configuration.appHangBacktraceEnabled, @"App Hang backtraces are enabled by default");
+    configuration.appHangBacktraceEnabled = NO;
+    XCTAssertFalse(configuration.appHangBacktraceEnabled, @"The setter must write through to the wrapped configuration");
+
+    [DDCrashReporter enableWith:configuration];
 }
 
 #pragma clang diagnostic pop

DatadogCrashReporting/Sources/CrashReporting.swift

@@ -122,10 +122,14 @@ public final class CrashReporting {
                 backtraceReporter: backtraceReporter,
                 appHangBacktraceEnabled: configuration.appHangBacktraceEnabled
             )
-        } else {
-            // A custom plugin may provide no backtrace reporter. Register the policy anyway, so that opting out of
-            // App Hang backtraces stays reportable as such rather than as "Crash Reporting was never enabled".
-            try core.register(appHangBacktraceEnabled: configuration.appHangBacktraceEnabled)
+        } else if !configuration.appHangBacktraceEnabled {
+            // A custom plugin may provide no backtrace reporter. Record the opt-out anyway, so that it stays
+            // reportable as such rather than as "Crash Reporting was never enabled".
+            //
+            // Only when opting out: registering unconditionally would claim the single `BacktraceReportingFeature`
+            // slot with a reporter-less Feature, and the `get(feature:) == nil` guard in `register(backtraceReporter:)`
+            // would then silently drop any reporter registered later.
+            try core.register(appHangBacktraceEnabled: false)
         }
 
         reporter.sendCrashReportIfFound()

DatadogCrashReporting/Tests/CrashReportingFeatureTests.swift

@@ -143,6 +143,42 @@ class CrashReportingFeatureTests: XCTestCase {
         )
     }
 
+    func testGivenPluginWithNoBacktraceReporter_whenAppHangBacktracesAreEnabled_itLeavesRegistrationOpenForALaterReporter() throws {
+        // Given
+        let core = FeatureRegistrationCoreMock()
+        let plugin = CrashReportingPluginMock()
+        plugin.injectedBacktraceReporter = nil
+
+        // When
+        try CrashReporting.enableOrThrow(with: plugin, in: core)
+
+        // Then
+        XCTAssertTrue(core.isAppHangBacktraceEnabled)
+
+        try core.register(backtraceReporter: BacktraceReporterMock())
+        XCTAssertNotNil(
+            try core.backtraceReporter.generateBacktrace(),
+            "Nothing must claim the backtrace reporter registration when there is no opt-out to record, otherwise "
+            + "the `already registered` guard silently drops a reporter registered later"
+        )
+    }
+
+    func testWhenEnablingWithPluginThroughThePublicAPI_itForwardsTheConfiguration() throws {
+        // Given
+        let core = FeatureRegistrationCoreMock()
+        let plugin = CrashReportingPluginMock()
+        plugin.injectedBacktraceReporter = BacktraceReporterMock()
+
+        // When (through the public API, so that the overload's own argument forwarding is covered)
+        CrashReporting.enable(with: plugin, configuration: .init(appHangBacktraceEnabled: false), in: core)
+
+        // Then
+        XCTAssertFalse(
+            core.isAppHangBacktraceEnabled,
+            "The public overload must forward its `configuration`, not a default-constructed one"
+        )
+    }
+
     // MARK: - Crash Report Reading Tests
 
     func testItSendsLaunchReportWhenNoPendingCrash() {

DatadogInternal/Sources/BacktraceReporting/BacktraceReporter.swift

@@ -85,11 +85,17 @@ internal struct CoreBacktraceReporter: BacktraceReporting, @unchecked Sendable {
 
 /// Adds capability of reporting backtraces.
 extension DatadogCoreProtocol {
+    /// Registers backtrace reporter in Core.
+    /// - Parameter backtraceReporter: the implementation of backtrace reporter.
+    public func register(backtraceReporter: BacktraceReporting) throws {
+        try register(backtraceReporter: backtraceReporter, appHangBacktraceEnabled: true)
+    }
+
     /// Registers backtrace reporter in Core.
     /// - Parameters:
     ///   - backtraceReporter: the implementation of backtrace reporter.
-    ///   - appHangBacktraceEnabled: whether backtraces may be generated for App Hangs detected by RUM. Default: `true`.
-    public func register(backtraceReporter: BacktraceReporting, appHangBacktraceEnabled: Bool = true) throws {
+    ///   - appHangBacktraceEnabled: whether backtraces may be generated for App Hangs detected by RUM.
+    public func register(backtraceReporter: BacktraceReporting, appHangBacktraceEnabled: Bool) throws {
         guard get(feature: BacktraceReportingFeature.self) == nil else {
             DD.logger.debug("Backtrace reporter is already registered to this core. Skipping registration of next one.")
             return
@@ -123,10 +129,10 @@ extension DatadogCoreProtocol {
 
     /// Whether backtraces may be generated for App Hangs detected by RUM.
     ///
-    /// It is `false` only when a backtrace reporter was registered with App Hang backtraces turned off. Before any
-    /// reporter is registered it is `true`: in that state backtrace generation is *unavailable* rather than
-    /// *disabled*, and callers must keep distinguishing the two. Read it at the moment a backtrace is needed, as
-    /// the reporter may be registered after the reading Feature was enabled.
+    /// It is `false` only when Crash Reporting was enabled with App Hang backtraces turned off — whether or not a
+    /// backtrace reporter came with it. Until then it is `true`: in that state backtrace generation may still be
+    /// *unavailable* rather than *disabled*, and callers must keep distinguishing the two. Read it at the moment a
+    /// backtrace is needed, as the reporter may be registered after the reading Feature was enabled.
     public var isAppHangBacktraceEnabled: Bool {
         // `self.` is required: a bare `get(...)` here parses as a `get` accessor.
         self.get(feature: BacktraceReportingFeature.self)?.appHangBacktraceEnabled ?? true