@react-native-firebase/crashlytics 26.4.0 → 27.1.0

package/android/src/test/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsFatalExitTest.java

@@ -0,0 +1,189 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.TimeoutException;
+import org.junit.Test;
+
+/**
+ * Plain JUnit (AndroidTest-AD-1) for the JS-fatal record → barrier → terminate ordering. A fake
+ * clock/sleeper/terminator stand in for time and {@code System.exit}, so no test ends the JVM.
+ */
+public class ReactNativeFirebaseCrashlyticsFatalExitTest {
+  private static final long TIMEOUT = 2000;
+
+  private final List<String> events = Collections.synchronizedList(new ArrayList<>());
+  private final List<Long> sleeps = new ArrayList<>();
+  private long now = 10_000;
+
+  private ReactNativeFirebaseCrashlyticsFatalExit fatalExit(
+      ReactNativeFirebaseCrashlyticsFatalExit.Barrier barrier,
+      ReactNativeFirebaseCrashlyticsFatalExit.Sleeper sleeper) {
+    return new ReactNativeFirebaseCrashlyticsFatalExit(
+        barrier, sleeper, () -> now, () -> events.add("exit"), TIMEOUT);
+  }
+
+  private ReactNativeFirebaseCrashlyticsFatalExit.Sleeper advancingSleeper() {
+    return millis -> {
+      sleeps.add(millis);
+      now += millis;
+    };
+  }
+
+  @Test
+  public void barrierSuccess_terminatesAfterRecordAndBarrierWithoutWaiting() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(
+            timeoutMs -> {
+              assertEquals(TIMEOUT, timeoutMs);
+              events.add("barrier");
+            },
+            advancingSleeper());
+
+    assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+
+    assertEquals(Arrays.asList("record", "barrier", "exit"), events);
+    assertTrue(sleeps.isEmpty());
+  }
+
+  @Test
+  public void recordThrows_stillWaitsOnBarrierAndTerminates() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(timeoutMs -> events.add("barrier"), advancingSleeper());
+
+    assertTrue(
+        fatalExit.recordThenTerminate(
+            () -> {
+              events.add("record");
+              throw new IllegalStateException("record failed");
+            }));
+
+    assertEquals(Arrays.asList("record", "barrier", "exit"), events);
+    assertFalse(fatalExit.recordThenTerminate(() -> events.add("second")));
+    assertEquals(Arrays.asList("record", "barrier", "exit"), events);
+  }
+
+  @Test
+  public void barrierTimeout_terminatesOnceTheBoundHasElapsed() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(
+            timeoutMs -> {
+              now += timeoutMs;
+              throw new TimeoutException("barrier timed out");
+            },
+            advancingSleeper());
+
+    assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+
+    assertEquals(Arrays.asList("record", "exit"), events);
+    assertTrue("bound already used up by the barrier", sleeps.isEmpty());
+  }
+
+  @Test
+  public void reflectionFailure_waitsOutTheRemainingBoundThenTerminates() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(
+            timeoutMs -> {
+              now += 300;
+              throw new NoSuchFieldException("crashlyticsWorkers");
+            },
+            advancingSleeper());
+
+    assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+
+    assertEquals(Collections.singletonList(TIMEOUT - 300), sleeps);
+    assertEquals(Arrays.asList("record", "exit"), events);
+  }
+
+  @Test
+  public void linkageError_fallsBackToTheBoundedWait() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(
+            timeoutMs -> {
+              throw new NoSuchFieldError("core");
+            },
+            advancingSleeper());
+
+    assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+
+    assertEquals(Collections.singletonList(TIMEOUT), sleeps);
+    assertEquals(Arrays.asList("record", "exit"), events);
+  }
+
+  @Test
+  public void interruptedFallbackWait_keepsWaitingUntilTheBound() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(
+            timeoutMs -> {
+              throw new InterruptedException("barrier interrupted");
+            },
+            millis -> {
+              sleeps.add(millis);
+              if (sleeps.size() == 1) {
+                now += 500;
+                throw new InterruptedException("sleep interrupted");
+              }
+              now += millis;
+            });
+
+    assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+
+    assertEquals(Arrays.asList(TIMEOUT, TIMEOUT - 500), sleeps);
+    assertEquals(Arrays.asList("record", "exit"), events);
+  }
+
+  @Test
+  public void secondFatalWhileTerminating_neitherRecordsNorTerminatesAgain() {
+    ReactNativeFirebaseCrashlyticsFatalExit[] holder =
+        new ReactNativeFirebaseCrashlyticsFatalExit[1];
+    List<Boolean> nestedResults = new ArrayList<>();
+    holder[0] =
+        fatalExit(
+            timeoutMs -> {
+              // A second JS fatal arrives while the first one is waiting on the barrier.
+              nestedResults.add(holder[0].recordThenTerminate(() -> events.add("record-2")));
+            },
+            advancingSleeper());
+
+    assertTrue(holder[0].recordThenTerminate(() -> events.add("record-1")));
+    assertFalse(holder[0].recordThenTerminate(() -> events.add("record-3")));
+
+    assertEquals(Collections.singletonList(false), nestedResults);
+    assertEquals(Arrays.asList("record-1", "exit"), events);
+  }
+
+  @Test
+  public void create_wiresTheProductionTimeoutClockAndSleeper() throws Exception {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        ReactNativeFirebaseCrashlyticsFatalExit.create();
+
+    assertEquals(2000, ReactNativeFirebaseCrashlyticsFatalExit.TIMEOUT_MS);
+    assertEquals(ReactNativeFirebaseCrashlyticsFatalExit.TIMEOUT_MS, fatalExit.timeoutMs);
+    long before = fatalExit.clock.nowMillis();
+    fatalExit.sleeper.sleep(5);
+    assertTrue(fatalExit.clock.nowMillis() >= before + 5);
+  }
+}

package/android/src/test/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsInternalTest.java

@@ -0,0 +1,199 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import com.google.firebase.crashlytics.internal.common.CrashlyticsCore;
+import com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorker;
+import com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorkers;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+/**
+ * JVM coverage for {@link ReactNativeFirebaseCrashlyticsInternal} against the real Crashlytics
+ * worker classes. Robolectric supplies the Android runtime the SDK classes load against;
+ * AndroidTest-AD-1. {@code Tasks.await} must not run on the (Robolectric) main thread, so waits
+ * happen on a pool thread.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class ReactNativeFirebaseCrashlyticsInternalTest {
+  private final ExecutorService pool = Executors.newCachedThreadPool();
+
+  @After
+  public void tearDown() {
+    pool.shutdownNow();
+  }
+
+  /**
+   * A FirebaseCrashlytics whose core uses {@code workers}. Built by reflection because the real
+   * graph is impractical in a unit test: {@code CrashlyticsCore}'s only constructor takes ten SDK
+   * collaborators (FirebaseApp, file store, native component, ...) and {@code
+   * FirebaseCrashlytics}'s constructor is private. So a mock core gets its {@code private final}
+   * workers field set.
+   */
+  static FirebaseCrashlytics crashlyticsWith(CrashlyticsWorkers workers) throws Exception {
+    CrashlyticsCore core = mock(CrashlyticsCore.class);
+    Field field = CrashlyticsCore.class.getDeclaredField("crashlyticsWorkers");
+    field.setAccessible(true);
+    field.set(core, workers);
+    return crashlyticsWithCore(core);
+  }
+
+  static FirebaseCrashlytics crashlyticsWithCore(CrashlyticsCore core) throws Exception {
+    Constructor<FirebaseCrashlytics> constructor =
+        FirebaseCrashlytics.class.getDeclaredConstructor(CrashlyticsCore.class);
+    constructor.setAccessible(true);
+    return constructor.newInstance(core);
+  }
+
+  private <T> T awaitOnPool(Task<T> task) throws Exception {
+    return pool.submit(() -> Tasks.await(task, 5, TimeUnit.SECONDS)).get(10, TimeUnit.SECONDS);
+  }
+
+  @Test
+  public void barrier_completesAfterAnEventWriteQueuedByAnEarlierCommonTask() throws Exception {
+    CrashlyticsWorkers workers = new CrashlyticsWorkers(pool, pool);
+    CountDownLatch barrierCreated = new CountDownLatch(1);
+    AtomicBoolean eventWritten = new AtomicBoolean(false);
+
+    // Same shape as CrashlyticsCore.logException → SessionReportingCoordinator.persistEvent: a
+    // common task that queues the actual write on diskWrite.
+    workers.common.submit(
+        () -> {
+          try {
+            barrierCreated.await(5, TimeUnit.SECONDS);
+          } catch (InterruptedException e) {
+            throw new IllegalStateException(e);
+          }
+          workers.diskWrite.submit(
+              () -> {
+                try {
+                  Thread.sleep(150);
+                } catch (InterruptedException e) {
+                  throw new IllegalStateException(e);
+                }
+                eventWritten.set(true);
+              });
+        });
+
+    Task<?> barrier =
+        ReactNativeFirebaseCrashlyticsInternal.pendingEventWritesBarrier(crashlyticsWith(workers));
+    assertFalse(barrier.isComplete());
+    barrierCreated.countDown();
+
+    awaitOnPool(barrier);
+    assertTrue(eventWritten.get());
+  }
+
+  /** Every member the barrier reflects exists on the SDK version these tests compile against. */
+  @Test
+  public void reflectedMembers_existOnTheRealSdkClasses() throws Exception {
+    assertNotNull(
+        FirebaseCrashlytics.class.getDeclaredField(
+            ReactNativeFirebaseCrashlyticsInternal.CORE_FIELD));
+    assertNotNull(
+        CrashlyticsCore.class.getDeclaredField(
+            ReactNativeFirebaseCrashlyticsInternal.WORKERS_FIELD));
+    assertNotNull(
+        CrashlyticsWorkers.class.getDeclaredField(
+            ReactNativeFirebaseCrashlyticsInternal.COMMON_FIELD));
+    assertNotNull(
+        CrashlyticsWorkers.class.getDeclaredField(
+            ReactNativeFirebaseCrashlyticsInternal.DISK_WRITE_FIELD));
+    assertNotNull(
+        CrashlyticsWorker.class.getMethod(
+            ReactNativeFirebaseCrashlyticsInternal.SUBMIT_TASK_METHOD, Callable.class));
+    assertNotNull(
+        CrashlyticsWorker.class.getMethod(
+            ReactNativeFirebaseCrashlyticsInternal.SUBMIT_METHOD, Runnable.class));
+  }
+
+  @Test
+  public void barrier_nullCore_throws() throws Exception {
+    FirebaseCrashlytics crashlytics = crashlyticsWithCore(null);
+    NullPointerException thrown =
+        assertThrows(
+            NullPointerException.class,
+            () -> ReactNativeFirebaseCrashlyticsInternal.pendingEventWritesBarrier(crashlytics));
+    assertEquals("core", thrown.getMessage());
+  }
+
+  @Test
+  public void barrier_unsetWorkersField_throws() throws Exception {
+    FirebaseCrashlytics crashlytics = crashlyticsWithCore(mock(CrashlyticsCore.class));
+    NullPointerException thrown =
+        assertThrows(
+            NullPointerException.class,
+            () -> ReactNativeFirebaseCrashlyticsInternal.pendingEventWritesBarrier(crashlytics));
+    assertEquals("crashlyticsWorkers", thrown.getMessage());
+  }
+
+  @SuppressWarnings("unused")
+  private static class FieldOnBase {
+    private final Object workers = "from base";
+  }
+
+  private static final class SubclassWithoutTheField extends FieldOnBase {}
+
+  @Test
+  public void read_findsAFieldDeclaredOnASuperclass() throws Exception {
+    assertEquals(
+        "from base",
+        ReactNativeFirebaseCrashlyticsInternal.read(new SubclassWithoutTheField(), "workers"));
+  }
+
+  @Test
+  public void read_missingField_throwsNoSuchField() {
+    NoSuchFieldException thrown =
+        assertThrows(
+            NoSuchFieldException.class,
+            () -> ReactNativeFirebaseCrashlyticsInternal.read(new Object(), "crashlyticsWorkers"));
+    assertEquals("crashlyticsWorkers", thrown.getMessage());
+  }
+
+  @SuppressWarnings("unused")
+  private static final class WorkersWithoutSubmitMethods {
+    private final Object common = new Object();
+    private final Object diskWrite = new Object();
+  }
+
+  @Test
+  public void barrierOn_missingWorkerMethod_throwsNoSuchMethod() {
+    assertThrows(
+        NoSuchMethodException.class,
+        () -> ReactNativeFirebaseCrashlyticsInternal.barrierOn(new WorkersWithoutSubmitMethods()));
+  }
+}

package/android/src/test/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsNativeHelperTest.java

@@ -0,0 +1,108 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.verify;
+
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
+import org.robolectric.RobolectricTestRunner;
+
+/**
+ * JVM coverage for {@link ReactNativeFirebaseCrashlyticsNativeHelper}. Stubs {@link
+ * FirebaseCrashlytics#getInstance()} via mockito-mockstatic so the helper can be exercised without
+ * initializing the Firebase SDK. Robolectric supplies an Android runtime for Firebase class
+ * loading; AndroidTest-AD-1.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class ReactNativeFirebaseCrashlyticsNativeHelperTest {
+
+  @Test
+  public void javaStaticShapePreservedForNativeCallers() throws Exception {
+    assertTrue(Modifier.isPublic(ReactNativeFirebaseCrashlyticsNativeHelper.class.getModifiers()));
+    assertTrue(Modifier.isFinal(ReactNativeFirebaseCrashlyticsNativeHelper.class.getModifiers()));
+    assertSame(
+        ReactNativeFirebaseCrashlyticsNativeHelper.INSTANCE,
+        ReactNativeFirebaseCrashlyticsNativeHelper.INSTANCE);
+
+    Method record =
+        ReactNativeFirebaseCrashlyticsNativeHelper.class.getMethod(
+            "recordNativeException", Throwable.class);
+    Method log = ReactNativeFirebaseCrashlyticsNativeHelper.class.getMethod("log", String.class);
+    Method setCustomKey =
+        ReactNativeFirebaseCrashlyticsNativeHelper.class.getMethod(
+            "setCustomKey", String.class, String.class);
+
+    for (Method method : Arrays.asList(record, log, setCustomKey)) {
+      assertTrue(method.getName(), Modifier.isStatic(method.getModifiers()));
+      assertTrue(method.getName(), Modifier.isPublic(method.getModifiers()));
+    }
+  }
+
+  @Test
+  public void recordNativeException_forwardsToFirebaseCrashlytics() {
+    FirebaseCrashlytics crashlytics = mock(FirebaseCrashlytics.class);
+    Throwable throwable = new RuntimeException("native-boom");
+
+    try (MockedStatic<FirebaseCrashlytics> firebaseCrashlytics =
+        mockStatic(FirebaseCrashlytics.class)) {
+      firebaseCrashlytics.when(FirebaseCrashlytics::getInstance).thenReturn(crashlytics);
+
+      ReactNativeFirebaseCrashlyticsNativeHelper.recordNativeException(throwable);
+
+      verify(crashlytics).recordException(throwable);
+    }
+  }
+
+  @Test
+  public void log_forwardsToFirebaseCrashlytics() {
+    FirebaseCrashlytics crashlytics = mock(FirebaseCrashlytics.class);
+
+    try (MockedStatic<FirebaseCrashlytics> firebaseCrashlytics =
+        mockStatic(FirebaseCrashlytics.class)) {
+      firebaseCrashlytics.when(FirebaseCrashlytics::getInstance).thenReturn(crashlytics);
+
+      ReactNativeFirebaseCrashlyticsNativeHelper.log("native-log");
+
+      verify(crashlytics).log("native-log");
+    }
+  }
+
+  @Test
+  public void setCustomKey_forwardsToFirebaseCrashlytics() {
+    FirebaseCrashlytics crashlytics = mock(FirebaseCrashlytics.class);
+
+    try (MockedStatic<FirebaseCrashlytics> firebaseCrashlytics =
+        mockStatic(FirebaseCrashlytics.class)) {
+      firebaseCrashlytics.when(FirebaseCrashlytics::getInstance).thenReturn(crashlytics);
+
+      ReactNativeFirebaseCrashlyticsNativeHelper.setCustomKey("k", "v");
+
+      verify(crashlytics).setCustomKey("k", "v");
+    }
+  }
+}

package/dist/module/version.js

@@ -1,5 +1,5 @@
 "use strict";
 
 // Generated by genversion.
-export const version = '26.4.0';
+export const version = '27.1.0';
 //# sourceMappingURL=version.js.map

package/dist/typescript/lib/index.d.ts

@@ -1,7 +1,7 @@
 import type { FirebaseApp } from '@react-native-firebase/app';
 import './types/internal';
 import type { Crashlytics } from './types/crashlytics';
-export declare const SDK_VERSION = "26.4.0";
+export declare const SDK_VERSION = "27.1.0";
 export declare function getCrashlytics(app?: FirebaseApp): Crashlytics;
 export declare function checkForUnsentReports(crashlytics: Crashlytics): Promise<boolean>;
 export declare function deleteUnsentReports(crashlytics: Crashlytics): Promise<void>;

package/dist/typescript/lib/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "26.4.0";
+export declare const version = "27.1.0";
 //# sourceMappingURL=version.d.ts.map

package/ios/RNFBCrashlytics/RNFBCrashlyticsDebuggerProbe.swift

@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Darwin
+import Foundation
+
+/**
+ * Debugger-attach detection previously inline in `RNFBCrashlyticsModule.mm`
+ * (`-isDebuggerAttached`).
+ *
+ * Pre-port contracts:
+ * - Once-token / dispatch_once-style caching of the result
+ * - `sysctl` `CTL_KERN` / `KERN_PROC` / `KERN_PROC_PID` / `getpid()` → `kinfo_proc`
+ * - `sysctl` failure → ELog-equivalent + treat as not attached (then still evaluate
+ *   `P_TRACED` on the returned buffer, matching the pre-port control flow)
+ * - `P_TRACED` bit set → true
+ *
+ * Foundation + Darwin only so unit tests do not link Firebase / React.
+ */
+@objc(RNFBCrashlyticsDebuggerProbe)
+public final class RNFBCrashlyticsDebuggerProbe: NSObject {
+
+  /// Injectable `sysctl` seam for unit tests. Production uses `makeDefaultSysctl()`.
+  typealias SysctlProbe = (
+    _ name: UnsafeMutablePointer<Int32>,
+    _ namelen: u_int,
+    _ oldp: UnsafeMutableRawPointer?,
+    _ oldlenp: UnsafeMutablePointer<Int>,
+    _ newp: UnsafeMutableRawPointer?,
+    _ newlen: Int
+  ) -> Int32
+
+  private static let lock = NSLock()
+  private static var cachedResult: Bool?
+  /// Mirrors `static dispatch_once_t` — evaluate at most once in production path.
+  private static var onceTokenConsumed = false
+
+  /// Test hook: replace `sysctl`. Restored by `resetForTesting()`.
+  static var sysctlImpl: SysctlProbe = makeDefaultSysctl()
+
+  private static func makeDefaultSysctl() -> SysctlProbe {
+    { name, namelen, oldp, oldlenp, newp, newlen in
+      Darwin.sysctl(name, namelen, oldp, oldlenp, newp, newlen)
+    }
+  }
+
+  /// Pre-port `-isDebuggerAttached` (once-cached).
+  @objc
+  public static func isDebuggerAttached() -> Bool {
+    lock.lock()
+    defer { lock.unlock() }
+    if onceTokenConsumed, let cached = cachedResult {
+      return cached
+    }
+    let value = evaluateIsDebuggerAttached(using: sysctlImpl)
+    cachedResult = value
+    onceTokenConsumed = true
+    return value
+  }
+
+  /// Clears once-cache and restores the default `sysctl` implementation (tests only).
+  static func resetForTesting() {
+    lock.lock()
+    defer { lock.unlock() }
+    cachedResult = nil
+    onceTokenConsumed = false
+    sysctlImpl = makeDefaultSysctl()
+  }
+
+  /// Evaluates without consuming the production once-cache (tests only).
+  static func evaluateUncachedForTesting(using probe: SysctlProbe) -> Bool {
+    evaluateIsDebuggerAttached(using: probe)
+  }
+
+  /// Core logic matching the pre-port `dispatch_once` body.
+  private static func evaluateIsDebuggerAttached(using probe: SysctlProbe) -> Bool {
+    var debuggerIsAttached = false
+
+    var info = kinfo_proc()
+    var infoSize = MemoryLayout<kinfo_proc>.size
+    var name: [Int32] = [
+      CTL_KERN,
+      KERN_PROC,
+      KERN_PROC_PID,
+      getpid(),
+    ]
+
+    // `name` is always 4 elements — `baseAddress` is non-nil.
+    let sysctlResult = name.withUnsafeMutableBufferPointer { nameBuf -> Int32 in
+      probe(nameBuf.baseAddress!, 4, &info, &infoSize, nil, 0)
+    }
+
+    if sysctlResult == -1 {
+      // ELog is NSLog with function/line prefix (RNFBSharedUtils.h).
+      let err = String(cString: strerror(errno))
+      NSLog(
+        "%@ [Line %d] Crashlytics ERROR: Checking for a running debugger via sysctl() failed: %@",
+        #function, #line, err)
+      debuggerIsAttached = false
+    }
+
+    if !debuggerIsAttached && (info.kp_proc.p_flag & P_TRACED) != 0 {
+      debuggerIsAttached = true
+    }
+
+    return debuggerIsAttached
+  }
+}