@logbrew/react-native 0.1.23 → 0.1.24

package/README.md

@@ -6,7 +6,7 @@
 
 React Native helpers for the public LogBrew JavaScript SDK.
 
-This package keeps event validation, retry, flush, and shutdown behavior in `@logbrew/sdk`. It adds mobile helpers for screen views, app-state changes, product actions, API milestones, bounded issue breadcrumbs, typed handled and unhandled JavaScript errors, Promise rejection tracking, provider and hook usage, W3C trace correlation and propagation, lifecycle spans, resource spans, reversible instrumentation, and opt-in Apple native crash and app-hang diagnostics.
+This package keeps event validation, retry, flush, and shutdown behavior in `@logbrew/sdk`. It adds mobile helpers for screen views, app-state changes, product actions, API milestones, bounded issue breadcrumbs, typed handled and unhandled JavaScript errors, Promise rejection tracking, provider and hook usage, W3C trace correlation and propagation, lifecycle spans, resource spans, reversible instrumentation, and opt-in native crash and app-hang diagnostics.
 
 ## Install
 
@@ -267,16 +267,73 @@ errorHandler.remove();
 
 Installation is idempotent for the active React Native `ErrorUtils` object. The wrapper captures a fixed-content, path-bounded issue for nonfatal global JavaScript errors and then calls the handler that was installed before it. Capture and diagnostic callback failures cannot prevent that prior handler from running. `remove()` reinstates the previous handler only while LogBrew still owns the global slot, so a later integration is not overwritten.
 
-The React Native conditional export obtains LogBrew's synchronous native fatal store through the supported TurboModule or `NativeModules` seam. Before chaining a fatal report, it writes one bounded record to app-private storage that is excluded from operating-system archives. On a later installation it performs stable-ID at-least-once replay, and acknowledgement happens only after local queue admission is observable through the SDK queue counters. Filtered, dropped, unknown-admission, persistence-failed, and acknowledgement-failed records are retained. A failed acknowledgement is retried without admitting the same ID twice in one JavaScript runtime. Use `fatalHealth()` for frozen bounded counters and status, or `discardPendingFatalRecord()` for an explicit rollback discard. The Node ESM and CommonJS entries never import React Native; non-React-Native callers must inject `fatalStore` explicitly.
-
-Automatic events exclude the original error message, raw stack, arbitrary metadata, full URLs, hosts, query strings, local absolute paths, payloads, and native error text. `onDiagnostic` receives only a fixed code. This error-handler integration does not claim mathematically exactly-once delivery, native crash capture, ANR or hang detection, general offline queueing by the fatal-record slot, or symbolication. The client-level persistent queue above owns normal event restart delivery.
+The React Native conditional export admits fatal JavaScript reports directly
+into the same app-private persistent queue used by normal delivery, then calls
+the previous handler. Queue admission is synchronous and must increase the
+pending count without increasing the dropped count. Otherwise capture fails
+closed and reports a fixed diagnostic code. The next process provides
+stable-ID at-least-once replay. Its acknowledgement happens only after local queue admission
+is observable through the SDK queue counters. Normal batch acknowledgement
+removes the event only after accepted delivery. Use
+`persistentQueue: "required"` when fatal
+survival is required. `fatalHealth()` exposes frozen bounded counters and
+status. The Node ESM and CommonJS entries never import React Native;
+non-React-Native callers may still inject the documented advanced `fatalStore`
+adapter.
+
+Automatic events exclude the original error message, raw stack, arbitrary metadata, full URLs, hosts, query strings, local absolute paths, payloads, and native error text. `onDiagnostic` receives only a fixed code. This error-handler integration does not claim mathematically exactly-once delivery, native crash capture, ANR or hang detection, or symbolication. The client-level persistent queue owns restart delivery.
 
 ### Apple native crash and app-hang diagnostics
 
 Apple native diagnostics are an iOS-only, opt-in build feature. They capture a
 fatal native process crash and replay one privacy-bounded issue after the next
 launch. Set `hangThresholdSeconds` to also capture recovered or ongoing UIKit
-main-thread hangs. Android native crash and ANR capture are not included.
+main-thread hangs.
+
+### Android native crash and ANR diagnostics
+
+Android diagnostics are opt-in and require a native build. They persist Java
+crashes, one NDK fault frame, and main-thread hangs to the normal app-private
+event queue. NDK evidence enters that queue on the next launch and remains
+until queue admission succeeds. Native signal records retain the project,
+release, environment, and service active at crash time, so an app update before
+relaunch cannot reassign the crash to a newer build.
+
+Remove other Android fatal handlers, then install before creating the client or
+registering the React root:
+
+```js
+import {
+  createLogBrewReactNativeClient,
+  installLogBrewAndroidNativeDiagnostics
+} from "@logbrew/react-native";
+
+installLogBrewAndroidNativeDiagnostics({
+  clientKey: process.env.EXPO_PUBLIC_LOGBREW_CLIENT_KEY,
+  projectId: "550e8400-e29b-41d4-a716-446655440000",
+  release: "com.example.app@1.2.3+45",
+  environment: "production",
+  service: "android-app",
+  fatalHandlerOwnership: "logbrew",
+  anrThresholdMs: 5000
+});
+
+const client = createLogBrewReactNativeClient({
+  clientKey: process.env.EXPO_PUBLIC_LOGBREW_CLIENT_KEY,
+  persistentQueue: "required"
+});
+```
+
+Capture excludes messages, thread names, console output, local variables,
+request data, authentication values, device identifiers, and raw tombstones. Java and
+hang reports keep at most 32 frames; NDK reports keep one build ID and offset.
+
+`uninstallLogBrewAndroidNativeDiagnostics()` reinstates prior
+handlers, stops the watchdog, and leaves queued events available. After closing
+the client, purge only for an explicit discard. Upload exact-release Android
+symbols with `logbrew debug-artifacts upload`, require build-ID/architecture
+lookup, and preserve the old integration until the target app proves crash
+replay, hang capture, and symbolicated hosted readback.
 
 For Expo prebuild or development builds, add the config plugin:
 

package/android/CMakeLists.txt

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.22.1)
+project(logbrew_android_diagnostics LANGUAGES CXX)
+
+add_library(logbrew_android_diagnostics SHARED src/main/cpp/android_diagnostics.cpp)
+target_compile_features(logbrew_android_diagnostics PRIVATE cxx_std_17)
+target_compile_options(logbrew_android_diagnostics PRIVATE -Wall -Wextra -Werror -fno-exceptions -fno-rtti)
+target_link_libraries(logbrew_android_diagnostics PRIVATE dl)

package/android/build.gradle

@@ -26,6 +26,18 @@ android {
     targetSdkVersion rootProject.ext.has("targetSdkVersion")
         ? rootProject.ext.get("targetSdkVersion")
         : 35
+    externalNativeBuild {
+      cmake {
+        cppFlags "-std=c++17"
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+      version "3.22.1"
+    }
   }
 
   sourceSets {

package/android/src/main/cpp/android_diagnostics.cpp

@@ -0,0 +1,363 @@
+#include <jni.h>
+
+#include <array>
+#include <atomic>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
+#include <dlfcn.h>
+#include <elf.h>
+#include <fcntl.h>
+#include <link.h>
+#include <signal.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <ucontext.h>
+
+namespace {
+constexpr uint32_t kMagic = 0x4c424e53;
+constexpr uint32_t kVersion = 1;
+constexpr size_t kIdBytes = 96;
+constexpr size_t kUuidBytes = 36;
+constexpr size_t kArchBytes = 16;
+constexpr size_t kOffsetBytes = 16;
+constexpr size_t kProjectChars = 36;
+constexpr size_t kReleaseChars = 256;
+constexpr size_t kEnvironmentChars = 128;
+constexpr size_t kServiceChars = 128;
+constexpr size_t kMaxModules = 192;
+constexpr std::array<int, 6> kSignals = {SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV, SIGTRAP};
+
+#pragma pack(push, 1)
+struct SignalRecord {
+  uint32_t magic;
+  uint32_t version;
+  uint32_t signal;
+  uint64_t timestamp_ms;
+  char event_id[kIdBytes];
+  char image_uuid[kUuidBytes];
+  char architecture[kArchBytes];
+  char instruction_offset[kOffsetBytes];
+  uint16_t project_id[kProjectChars];
+  uint16_t release[kReleaseChars];
+  uint16_t environment[kEnvironmentChars];
+  uint16_t service[kServiceChars];
+  uint32_t checksum;
+};
+#pragma pack(pop)
+static_assert(sizeof(SignalRecord) == 1284, "signal record layout drifted");
+
+struct Module {
+  uintptr_t start;
+  uintptr_t end;
+  std::array<uint8_t, 16> build_id;
+  bool has_build_id;
+};
+
+std::array<Module, kMaxModules> g_modules{};
+size_t g_module_count = 0;
+std::array<struct sigaction, kSignals.size()> g_previous_actions{};
+std::array<char, 1024> g_record_path{};
+SignalRecord g_record_template{};
+std::atomic<bool> g_installed{false};
+std::atomic_flag g_handling = ATOMIC_FLAG_INIT;
+
+uint32_t crc32(const uint8_t* bytes, size_t length) {
+  uint32_t value = 0xffffffffU;
+  for (size_t index = 0; index < length; ++index) {
+    value ^= bytes[index];
+    for (int bit = 0; bit < 8; ++bit) {
+      value = (value >> 1U) ^ (0xedb88320U & (0U - (value & 1U)));
+    }
+  }
+  return value ^ 0xffffffffU;
+}
+
+size_t align4(size_t value) {
+  return (value + 3U) & ~size_t{3U};
+}
+
+bool read_build_id(const dl_phdr_info* info, std::array<uint8_t, 16>* output) {
+  for (ElfW(Half) index = 0; index < info->dlpi_phnum; ++index) {
+    const ElfW(Phdr)& header = info->dlpi_phdr[index];
+    if (header.p_type != PT_NOTE || header.p_memsz < sizeof(ElfW(Nhdr))) {
+      continue;
+    }
+    const auto* cursor = reinterpret_cast<const uint8_t*>(info->dlpi_addr + header.p_vaddr);
+    const auto* end = cursor + header.p_memsz;
+    while (cursor + sizeof(ElfW(Nhdr)) <= end) {
+      const auto* note = reinterpret_cast<const ElfW(Nhdr)*>(cursor);
+      cursor += sizeof(ElfW(Nhdr));
+      const size_t name_bytes = align4(note->n_namesz);
+      const size_t value_bytes = align4(note->n_descsz);
+      if (cursor + name_bytes + value_bytes > end) {
+        break;
+      }
+      const uint8_t* name = cursor;
+      const uint8_t* value = cursor + name_bytes;
+      if (note->n_type == NT_GNU_BUILD_ID
+          && note->n_namesz >= 3
+          && std::memcmp(name, "GNU", 3) == 0
+          && note->n_descsz >= output->size()) {
+        std::memcpy(output->data(), value, output->size());
+        return true;
+      }
+      cursor += name_bytes + value_bytes;
+    }
+  }
+  return false;
+}
+
+int collect_module(dl_phdr_info* info, size_t, void*) {
+  if (g_module_count == g_modules.size()) {
+    return 1;
+  }
+  uintptr_t start = UINTPTR_MAX;
+  uintptr_t end = 0;
+  for (ElfW(Half) index = 0; index < info->dlpi_phnum; ++index) {
+    const ElfW(Phdr)& header = info->dlpi_phdr[index];
+    if (header.p_type != PT_LOAD) {
+      continue;
+    }
+    const uintptr_t segment_start = info->dlpi_addr + header.p_vaddr;
+    start = segment_start < start ? segment_start : start;
+    const uintptr_t segment_end = segment_start + header.p_memsz;
+    end = segment_end > end ? segment_end : end;
+  }
+  if (start == UINTPTR_MAX || end <= start) {
+    return 0;
+  }
+  Module module{};
+  module.start = start;
+  module.end = end;
+  module.has_build_id = read_build_id(info, &module.build_id);
+  g_modules[g_module_count++] = module;
+  return 0;
+}
+
+uintptr_t program_counter(void* context) {
+  const auto* machine = reinterpret_cast<const ucontext_t*>(context);
+#if defined(__aarch64__)
+  return machine->uc_mcontext.pc;
+#elif defined(__arm__)
+  return machine->uc_mcontext.arm_pc;
+#elif defined(__x86_64__)
+  return machine->uc_mcontext.gregs[REG_RIP];
+#elif defined(__i386__)
+  return machine->uc_mcontext.gregs[REG_EIP];
+#else
+  return 0;
+#endif
+}
+
+const char* architecture() {
+#if defined(__aarch64__)
+  return "arm64";
+#elif defined(__arm__)
+  return "arm";
+#elif defined(__x86_64__)
+  return "x86_64";
+#elif defined(__i386__)
+  return "x86";
+#else
+  return "";
+#endif
+}
+
+const Module* module_for(uintptr_t address) {
+  for (size_t index = 0; index < g_module_count; ++index) {
+    const Module& module = g_modules[index];
+    if (module.has_build_id && address >= module.start && address < module.end) {
+      return &module;
+    }
+  }
+  return nullptr;
+}
+
+void uuid_string(const std::array<uint8_t, 16>& bytes, char* output) {
+  static constexpr char hex[] = "0123456789abcdef";
+  size_t destination = 0;
+  for (size_t index = 0; index < bytes.size(); ++index) {
+    if (index == 4 || index == 6 || index == 8 || index == 10) {
+      output[destination++] = '-';
+    }
+    output[destination++] = hex[bytes[index] >> 4U];
+    output[destination++] = hex[bytes[index] & 0x0fU];
+  }
+}
+
+void offset_string(uintptr_t value, char* output) {
+  static constexpr char hex[] = "0123456789abcdef";
+  for (int index = 15; index >= 0; --index) {
+    output[index] = hex[value & 0x0fU];
+    value >>= 4U;
+  }
+}
+
+void write_record(int signal_number, void* context) {
+  const uintptr_t address = program_counter(context);
+  const Module* module = module_for(address);
+  if (module == nullptr || address < module->start) {
+    return;
+  }
+  SignalRecord record = g_record_template;
+  record.signal = static_cast<uint32_t>(signal_number);
+  timespec now{};
+  if (clock_gettime(CLOCK_REALTIME, &now) != 0) {
+    return;
+  }
+  record.timestamp_ms = static_cast<uint64_t>(now.tv_sec) * 1000U
+      + static_cast<uint64_t>(now.tv_nsec / 1000000U);
+  uuid_string(module->build_id, record.image_uuid);
+  const char* arch = architecture();
+  size_t arch_length = 0;
+  while (arch[arch_length] != '\0') {
+    ++arch_length;
+  }
+  std::memcpy(record.architecture, arch, arch_length);
+  offset_string(address - module->start, record.instruction_offset);
+  record.checksum = crc32(reinterpret_cast<const uint8_t*>(&record), sizeof(record) - 4);
+
+  const int descriptor = open(
+      g_record_path.data(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW, 0600);
+  if (descriptor < 0) {
+    return;
+  }
+  const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&record);
+  size_t written = 0;
+  while (written < sizeof(record)) {
+    const ssize_t count = write(descriptor, bytes + written, sizeof(record) - written);
+    if (count <= 0) {
+      break;
+    }
+    written += static_cast<size_t>(count);
+  }
+  if (written == sizeof(record)) {
+    fsync(descriptor);
+  }
+  close(descriptor);
+}
+
+void chain_signal(int signal_number) {
+  for (size_t index = 0; index < kSignals.size(); ++index) {
+    if (kSignals[index] == signal_number) {
+      sigaction(signal_number, &g_previous_actions[index], nullptr);
+      break;
+    }
+  }
+  syscall(SYS_tgkill, getpid(), gettid(), signal_number);
+}
+
+void signal_handler(int signal_number, siginfo_t*, void* context) {
+  if (!g_handling.test_and_set()) {
+    write_record(signal_number, context);
+  }
+  chain_signal(signal_number);
+}
+
+bool copy_jstring(JNIEnv* environment, jstring value, char* output, size_t capacity) {
+  if (value == nullptr) {
+    return false;
+  }
+  const char* bytes = environment->GetStringUTFChars(value, nullptr);
+  if (bytes == nullptr) {
+    return false;
+  }
+  const size_t length = std::strlen(bytes);
+  const bool valid = length > 0 && length < capacity;
+  if (valid) {
+    std::memset(output, 0, capacity);
+    std::memcpy(output, bytes, length);
+  }
+  environment->ReleaseStringUTFChars(value, bytes);
+  return valid;
+}
+
+bool copy_jstring_utf16(
+    JNIEnv* environment, jstring value, uint16_t* output, size_t capacity) {
+  if (value == nullptr) {
+    return false;
+  }
+  const jsize length = environment->GetStringLength(value);
+  if (length <= 0 || static_cast<size_t>(length) > capacity) {
+    return false;
+  }
+  std::memset(output, 0, capacity * sizeof(uint16_t));
+  environment->GetStringRegion(value, 0, length, reinterpret_cast<jchar*>(output));
+  return !environment->ExceptionCheck();
+}
+}  // namespace
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_co_logbrew_reactnative_AndroidDiagnosticsRuntime_nativeInstall(
+    JNIEnv* environment,
+    jclass,
+    jstring record_path,
+    jstring event_id,
+    jstring project_id,
+    jstring release,
+    jstring deployment_environment,
+    jstring service) {
+  bool expected = false;
+  if (!g_installed.compare_exchange_strong(expected, true)) {
+    return JNI_FALSE;
+  }
+  if (!copy_jstring(environment, record_path, g_record_path.data(), g_record_path.size())
+      || !copy_jstring(
+          environment,
+          event_id,
+          g_record_template.event_id,
+          sizeof(g_record_template.event_id))
+      || !copy_jstring_utf16(
+          environment,
+          project_id,
+          g_record_template.project_id,
+          kProjectChars)
+      || !copy_jstring_utf16(
+          environment, release, g_record_template.release, kReleaseChars)
+      || !copy_jstring_utf16(
+          environment,
+          deployment_environment,
+          g_record_template.environment,
+          kEnvironmentChars)
+      || !copy_jstring_utf16(
+          environment, service, g_record_template.service, kServiceChars)) {
+    g_installed.store(false);
+    return JNI_FALSE;
+  }
+  g_record_template.magic = kMagic;
+  g_record_template.version = kVersion;
+  g_module_count = 0;
+  dl_iterate_phdr(collect_module, nullptr);
+  struct sigaction action {};
+  sigemptyset(&action.sa_mask);
+  action.sa_sigaction = signal_handler;
+  action.sa_flags = SA_SIGINFO | SA_ONSTACK;
+  for (size_t index = 0; index < kSignals.size(); ++index) {
+    if (sigaction(kSignals[index], &action, &g_previous_actions[index]) != 0) {
+      for (size_t rollback = 0; rollback < index; ++rollback) {
+        sigaction(kSignals[rollback], &g_previous_actions[rollback], nullptr);
+      }
+      g_installed.store(false);
+      return JNI_FALSE;
+    }
+  }
+  return JNI_TRUE;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_co_logbrew_reactnative_AndroidDiagnosticsRuntime_nativeUninstall(JNIEnv*, jclass) {
+  if (!g_installed.exchange(false)) {
+    return;
+  }
+  for (size_t index = 0; index < kSignals.size(); ++index) {
+    struct sigaction current {};
+    if (sigaction(kSignals[index], nullptr, &current) == 0
+        && (current.sa_flags & SA_SIGINFO) != 0
+        && current.sa_sigaction == signal_handler) {
+      sigaction(kSignals[index], &g_previous_actions[index], nullptr);
+    }
+  }
+  g_handling.clear();
+}

package/android/src/main/java/co/logbrew/reactnative/AndroidDiagnosticsRuntime.java

@@ -0,0 +1,214 @@
+package co.logbrew.reactnative;
+
+import android.app.ActivityManager;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import java.io.File;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.LongConsumer;
+
+final class AndroidDiagnosticsRuntime implements Thread.UncaughtExceptionHandler {
+  private static final boolean SIGNAL_CAPTURE_AVAILABLE = loadSignalCapture();
+
+  private final AndroidNativeDiagnostics diagnostics;
+  private final Thread.UncaughtExceptionHandler previousHandler;
+  private final AndroidNativeDiagnostics.Configuration configuration;
+  private final String signalRecordPath;
+
+  AndroidDiagnosticsRuntime(
+      Context context,
+      File storageRoot,
+      EventRecordStore eventStore,
+      AndroidNativeDiagnostics.Configuration configuration) {
+    this.configuration = configuration;
+    previousHandler = Thread.getDefaultUncaughtExceptionHandler();
+    MainThreadScheduler scheduler = new MainThreadScheduler(context);
+    AndroidNativeSignalStore signalStore =
+        new AndroidNativeSignalStore(new File(storageRoot, "logbrew-android-native-v1.signal"));
+    diagnostics =
+        new AndroidNativeDiagnostics(
+            eventStore,
+            signalStore,
+            configuration,
+            scheduler,
+            () -> {},
+            this::chain,
+            scheduler.mainThread::getStackTrace);
+    signalRecordPath = signalStore.path();
+  }
+
+  synchronized String install() {
+    if (diagnostics.installed) {
+      return "already_installed";
+    }
+    if (pending() < 0) {
+      throw new IllegalStateException("event queue unavailable");
+    }
+    String status = diagnostics.install();
+    Thread.setDefaultUncaughtExceptionHandler(this);
+    if (!diagnostics.signalStore.prepare(new AndroidParentDirectorySync())
+        || !SIGNAL_CAPTURE_AVAILABLE
+        || !nativeInstall(
+            signalRecordPath,
+            diagnostics.nextNativeEventId(),
+            configuration.projectId,
+            configuration.release,
+            configuration.environment,
+            configuration.service)) {
+      Thread.setDefaultUncaughtExceptionHandler(previousHandler);
+      diagnostics.uninstall();
+      throw new IllegalStateException("signal capture unavailable");
+    }
+    return status;
+  }
+
+  synchronized String uninstall() {
+    if (!diagnostics.installed) {
+      return "not_installed";
+    }
+    if (SIGNAL_CAPTURE_AVAILABLE) {
+      nativeUninstall();
+    }
+    if (Thread.getDefaultUncaughtExceptionHandler() == this) {
+      Thread.setDefaultUncaughtExceptionHandler(previousHandler);
+    }
+    diagnostics.uninstall();
+    return "uninstalled";
+  }
+
+  synchronized int pending() {
+    EventRecordStore.Result result = diagnostics.eventStore.load();
+    return "loaded".equals(result.status) ? result.records.size() : -1;
+  }
+
+  synchronized boolean installed() {
+    return diagnostics.installed;
+  }
+
+  synchronized boolean matches(
+      EventRecordStore eventStore, AndroidNativeDiagnostics.Configuration configuration) {
+    return diagnostics.eventStore == eventStore && diagnostics.configurationMatches(configuration);
+  }
+
+  @Override
+  public void uncaughtException(Thread thread, Throwable error) {
+    diagnostics.handleUncaught(thread, error);
+  }
+
+  private void chain(Thread thread, Throwable error) {
+    if (previousHandler != null && previousHandler != this) {
+      previousHandler.uncaughtException(thread, error);
+      return;
+    }
+    android.os.Process.killProcess(android.os.Process.myPid());
+    System.exit(10);
+  }
+
+  private static boolean loadSignalCapture() {
+    try {
+      System.loadLibrary("logbrew_android_diagnostics");
+      return true;
+    } catch (LinkageError error) {
+      return false;
+    }
+  }
+
+  private static native boolean nativeInstall(
+      String recordPath,
+      String eventId,
+      String projectId,
+      String release,
+      String environment,
+      String service);
+
+  private static native void nativeUninstall();
+
+  private static final class MainThreadScheduler implements AndroidNativeDiagnostics.Scheduler {
+    private final Context context;
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+    private final Thread mainThread = Looper.getMainLooper().getThread();
+    private final AtomicLong heartbeatMs = new AtomicLong(SystemClock.elapsedRealtime());
+    private final AtomicBoolean reported = new AtomicBoolean();
+    private ScheduledExecutorService executor;
+
+    MainThreadScheduler(Context context) {
+      this.context = context.getApplicationContext();
+    }
+
+    @Override
+    public synchronized void start(
+        long thresholdMs, LongConsumer report) {
+      stop();
+      heartbeatMs.set(SystemClock.elapsedRealtime());
+      mainHandler.post(this::heartbeat);
+      executor =
+          Executors.newSingleThreadScheduledExecutor(
+              runnable -> {
+                Thread thread = new Thread(runnable, "LogBrew-ANR-Watchdog");
+                thread.setDaemon(true);
+                return thread;
+              });
+      long intervalMs = Math.max(500, thresholdMs / 2);
+      executor.scheduleWithFixedDelay(
+          () -> {
+            long now = SystemClock.elapsedRealtime();
+            long elapsedMs = now - heartbeatMs.get();
+            boolean debugging = android.os.Debug.isDebuggerConnected()
+                || android.os.Debug.waitingForDebugger();
+            if (AndroidNativeDiagnostics.shouldReportHang(
+                    elapsedMs, thresholdMs, debugging, processNotResponding())
+                && reported.compareAndSet(false, true)) {
+              report.accept(elapsedMs);
+            }
+            mainHandler.post(this::heartbeat);
+          },
+          thresholdMs,
+          intervalMs,
+          TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public synchronized void stop() {
+      if (executor != null) {
+        executor.shutdownNow();
+        executor = null;
+      }
+    }
+
+    private void heartbeat() {
+      heartbeatMs.set(SystemClock.elapsedRealtime());
+      reported.set(false);
+    }
+
+    private boolean processNotResponding() {
+      ActivityManager manager =
+          (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+      if (manager == null) {
+        return false;
+      }
+      try {
+        java.util.List<ActivityManager.ProcessErrorStateInfo> states =
+            manager.getProcessesInErrorState();
+        if (states != null) {
+          int processId = android.os.Process.myPid();
+          for (ActivityManager.ProcessErrorStateInfo state : states) {
+            if (state != null
+                && state.pid == processId
+                && state.condition == ActivityManager.ProcessErrorStateInfo.NOT_RESPONDING) {
+              return true;
+            }
+          }
+        }
+      } catch (RuntimeException ignored) {
+        return false;
+      }
+      return false;
+    }
+  }
+}