@logbrew/react-native 0.1.10 → 0.1.12

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

@@ -9,10 +9,15 @@ import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 final class FatalStoreModuleImpl {
@@ -32,9 +37,12 @@ final class FatalStoreModuleImpl {
       new HashSet<>(Arrays.asList("filename", "line", "column"));
 
   private final FatalRecordStore store;
+  private final File eventStoreParent;
+  private final Map<String, EventRecordStore> eventStores = new HashMap<>();
 
   FatalStoreModuleImpl(ReactApplicationContext context) {
     File root = context.getNoBackupFilesDir();
+    eventStoreParent = root;
     store =
         root == null
             ? null
@@ -43,6 +51,66 @@ final class FatalStoreModuleImpl {
                 new AndroidParentDirectorySync());
   }
 
+  WritableMap loadEventRecords(String queueKey) {
+    try {
+      EventRecordStore eventStore = eventStore(queueKey);
+      return eventStore == null ? status("storage_error") : eventResultMap(eventStore.load());
+    } catch (RuntimeException error) {
+      return status("storage_error");
+    }
+  }
+
+  WritableMap appendEventRecord(String queueKey, String serializedEvent, double eventBytes) {
+    try {
+      EventRecordStore eventStore = eventStore(queueKey);
+      Integer byteCount = integer(eventBytes);
+      return eventStore == null || byteCount == null
+          ? status("storage_error")
+          : eventResultMap(eventStore.append(serializedEvent, byteCount));
+    } catch (RuntimeException error) {
+      return status("storage_error");
+    }
+  }
+
+  WritableMap acknowledgeEventRecords(String queueKey, double count) {
+    try {
+      EventRecordStore eventStore = eventStore(queueKey);
+      Integer recordCount = integer(count);
+      return eventStore == null || recordCount == null
+          ? status("storage_error")
+          : eventResultMap(eventStore.acknowledge(recordCount));
+    } catch (RuntimeException error) {
+      return status("storage_error");
+    }
+  }
+
+  WritableMap purgeEventRecords(String queueKey) {
+    try {
+      EventRecordStore eventStore = eventStore(queueKey);
+      return eventStore == null ? status("storage_error") : eventResultMap(eventStore.purge());
+    } catch (RuntimeException error) {
+      return status("storage_error");
+    }
+  }
+
+  synchronized WritableMap closeEventStore(String queueKey) {
+    String queueHash = queueHash(queueKey);
+    if (queueHash == null) {
+      return status("storage_error");
+    }
+    EventRecordStore eventStore = eventStores.get(queueHash);
+    if (eventStore == null) {
+      return status("closed");
+    }
+    try {
+      return eventResultMap(eventStore.close());
+    } catch (RuntimeException error) {
+      return status("storage_error");
+    } finally {
+      eventStores.remove(queueHash);
+    }
+  }
+
   WritableMap writeFatalRecord(ReadableMap input) {
     if (store == null) {
       return status("storage_error");
@@ -227,4 +295,65 @@ final class FatalStoreModuleImpl {
     output.putString("status", value);
     return output;
   }
+
+  private synchronized EventRecordStore eventStore(String queueKey) {
+    String queueHash = queueHash(queueKey);
+    if (eventStoreParent == null || queueHash == null) {
+      return null;
+    }
+    EventRecordStore existing = eventStores.get(queueHash);
+    if (existing != null) {
+      return existing;
+    }
+    EventRecordStore created =
+        new EventRecordStore(
+            new File(eventStoreParent, "logbrew-events-v1-" + queueHash),
+            new AndroidParentDirectorySync());
+    eventStores.put(queueHash, created);
+    return created;
+  }
+
+  private static String queueHash(String queueKey) {
+    if (queueKey == null || queueKey.trim().isEmpty()) {
+      return null;
+    }
+    byte[] keyBytes = queueKey.getBytes(StandardCharsets.UTF_8);
+    if (keyBytes.length == 0 || keyBytes.length > 4096) {
+      return null;
+    }
+    try {
+      byte[] digest = MessageDigest.getInstance("SHA-256").digest(keyBytes);
+      StringBuilder value = new StringBuilder(digest.length * 2);
+      for (byte item : digest) {
+        value.append(String.format(java.util.Locale.ROOT, "%02x", item & 0xff));
+      }
+      return value.toString();
+    } catch (NoSuchAlgorithmException impossible) {
+      return null;
+    }
+  }
+
+  private static Integer integer(double value) {
+    return Double.isFinite(value)
+            && value >= 0
+            && value <= Integer.MAX_VALUE
+            && value == Math.rint(value)
+        ? (int) value
+        : null;
+  }
+
+  private static WritableMap eventResultMap(EventRecordStore.Result result) {
+    WritableMap output = status(result.status);
+    if ("loaded".equals(result.status)) {
+      WritableArray records = Arguments.createArray();
+      for (EventRecordStore.Record record : result.records) {
+        WritableMap value = Arguments.createMap();
+        value.putString("serializedEvent", record.serializedEvent);
+        value.putInt("eventBytes", record.eventBytes);
+        records.pushMap(value);
+      }
+      output.putArray("records", records);
+    }
+    return output;
+  }
 }

package/android/src/newarch/java/co/logbrew/reactnative/FatalStoreModule.java

@@ -36,4 +36,30 @@ final class FatalStoreModule extends NativeLogBrewFatalStoreSpec {
   public WritableMap discardFatalRecord() {
     return implementation.discardFatalRecord();
   }
+
+  @Override
+  public WritableMap loadEventRecords(String queueKey) {
+    return implementation.loadEventRecords(queueKey);
+  }
+
+  @Override
+  public WritableMap appendEventRecord(
+      String queueKey, String serializedEvent, double eventBytes) {
+    return implementation.appendEventRecord(queueKey, serializedEvent, eventBytes);
+  }
+
+  @Override
+  public WritableMap acknowledgeEventRecords(String queueKey, double count) {
+    return implementation.acknowledgeEventRecords(queueKey, count);
+  }
+
+  @Override
+  public WritableMap purgeEventRecords(String queueKey) {
+    return implementation.purgeEventRecords(queueKey);
+  }
+
+  @Override
+  public WritableMap closeEventStore(String queueKey) {
+    return implementation.closeEventStore(queueKey);
+  }
 }

package/android/src/oldarch/java/co/logbrew/reactnative/FatalStoreModule.java

@@ -38,4 +38,30 @@ final class FatalStoreModule extends ReactContextBaseJavaModule {
   public WritableMap discardFatalRecord() {
     return implementation.discardFatalRecord();
   }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap loadEventRecords(String queueKey) {
+    return implementation.loadEventRecords(queueKey);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap appendEventRecord(
+      String queueKey, String serializedEvent, double eventBytes) {
+    return implementation.appendEventRecord(queueKey, serializedEvent, eventBytes);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap acknowledgeEventRecords(String queueKey, double count) {
+    return implementation.acknowledgeEventRecords(queueKey, count);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap purgeEventRecords(String queueKey) {
+    return implementation.purgeEventRecords(queueKey);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap closeEventStore(String queueKey) {
+    return implementation.closeEventStore(queueKey);
+  }
 }

package/apple-native-diagnostics.d.ts

@@ -0,0 +1,52 @@
+type LogBrewAppleNativeDiagnosticsAuth =
+  | { apiKey: string; clientKey?: never }
+  | { clientKey: string; apiKey?: never };
+
+export type LogBrewAppleNativeDiagnosticsConfiguration =
+  LogBrewAppleNativeDiagnosticsAuth & {
+    projectId: string;
+    release: string;
+    environment: string;
+    service: string;
+    /** Explicitly confirms LogBrew is the process's only native fatal-handler owner. */
+    fatalHandlerOwnership: "logbrew";
+    /** Enable app-hang capture with a threshold from 1 through 30 seconds. Omit to disable. */
+    hangThresholdSeconds?: number;
+    /** Event ingestion endpoint. Defaults to the hosted LogBrew endpoint. */
+    endpoint?: string;
+  };
+
+export type LogBrewAppleNativeDiagnosticsStatus = Readonly<{
+  status: "already_installed" | "installed" | "not_installed" | "ready";
+  lifecycle: "failed" | "idle" | "installed" | "replaying" | "stopped" | "unknown";
+  pending: number;
+  acknowledged: number;
+  discarded: number;
+}>;
+
+export type LogBrewAppleNativeDiagnosticsReplayResult = Readonly<{
+  status: "replayed";
+  attempted: number;
+  acknowledged: number;
+  discarded: number;
+  pending: number;
+}>;
+
+export declare function installLogBrewAppleNativeDiagnostics(
+  configuration: LogBrewAppleNativeDiagnosticsConfiguration
+): LogBrewAppleNativeDiagnosticsStatus;
+
+export declare function replayLogBrewAppleNativeDiagnostics(): Promise<
+  LogBrewAppleNativeDiagnosticsReplayResult
+>;
+
+export declare function getLogBrewAppleNativeDiagnosticsStatus():
+  LogBrewAppleNativeDiagnosticsStatus;
+
+declare const defaultExport: {
+  getLogBrewAppleNativeDiagnosticsStatus: typeof getLogBrewAppleNativeDiagnosticsStatus;
+  installLogBrewAppleNativeDiagnostics: typeof installLogBrewAppleNativeDiagnostics;
+  replayLogBrewAppleNativeDiagnostics: typeof replayLogBrewAppleNativeDiagnostics;
+};
+
+export default defaultExport;

package/apple-native-diagnostics.js

@@ -0,0 +1,286 @@
+import { SdkError } from "@logbrew/sdk";
+import { NativeModules, Platform, TurboModuleRegistry } from "react-native";
+
+const INSTALL_STATUSES = new Set(["already_installed", "installed"]);
+const LIFECYCLE_STATUSES = new Set([
+  "failed",
+  "idle",
+  "installed",
+  "replaying",
+  "stopped",
+  "unknown"
+]);
+
+export function installLogBrewAppleNativeDiagnostics(configuration = {}) {
+  requireApplePlatform();
+  const nativeModule = requireNativeModule();
+  const payload = normalizeConfiguration(configuration);
+  const result = callNative(nativeModule, "installNativeDiagnostics", payload);
+  return requireStatusResult("install", result, INSTALL_STATUSES);
+}
+
+export async function replayLogBrewAppleNativeDiagnostics() {
+  requireApplePlatform();
+  const nativeModule = requireNativeModule();
+  let result;
+  try {
+    result = await callNative(nativeModule, "replayNativeDiagnostics");
+  } catch (error) {
+    if (error instanceof SdkError) {
+      throw error;
+    }
+    throw new SdkError(
+      "native_diagnostics_failed",
+      "LogBrew Apple native diagnostics replay failed"
+    );
+  }
+  return requireReplayResult(result);
+}
+
+export function getLogBrewAppleNativeDiagnosticsStatus() {
+  requireApplePlatform();
+  const nativeModule = requireNativeModule();
+  const result = callNative(nativeModule, "nativeDiagnosticsStatus");
+  return requireStatusResult("status", result, new Set(["not_installed", "ready"]));
+}
+
+function normalizeConfiguration(configuration) {
+  if (!configuration
+    || Array.isArray(configuration)
+    || typeof configuration !== "object") {
+    throw configurationError("configuration must be an object");
+  }
+  const allowedKeys = new Set([
+    "apiKey",
+    "clientKey",
+    "endpoint",
+    "environment",
+    "fatalHandlerOwnership",
+    "hangThresholdSeconds",
+    "projectId",
+    "release",
+    "service"
+  ]);
+  for (const key of Object.keys(configuration)) {
+    if (!allowedKeys.has(key)) {
+      throw configurationError(`configuration contains unsupported key ${JSON.stringify(key)}`);
+    }
+  }
+  if (Object.prototype.hasOwnProperty.call(configuration, "apiKey")
+    && Object.prototype.hasOwnProperty.call(configuration, "clientKey")) {
+    throw configurationError("apiKey and clientKey are mutually exclusive");
+  }
+  const authKey = exactString(
+    "apiKey or clientKey",
+    configuration.clientKey ?? configuration.apiKey,
+    4096
+  );
+  const projectId = exactString("projectId", configuration.projectId, 64);
+  if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/u.test(projectId)) {
+    throw configurationError("projectId must be a lowercase UUID");
+  }
+  if (configuration.fatalHandlerOwnership !== "logbrew") {
+    throw configurationError(
+      "fatalHandlerOwnership must be the exact string logbrew after confirming no other native fatal handler is installed"
+    );
+  }
+
+  const payload = {
+    apiKey: authKey,
+    environment: exactString("environment", configuration.environment),
+    fatalHandlerOwnership: "logbrew",
+    projectId,
+    release: exactString("release", configuration.release),
+    service: exactString("service", configuration.service)
+  };
+  if (configuration.endpoint !== undefined) {
+    payload.endpoint = exactDeliveryEndpoint(configuration.endpoint);
+  }
+  if (configuration.hangThresholdSeconds !== undefined) {
+    const threshold = configuration.hangThresholdSeconds;
+    if (typeof threshold !== "number"
+      || !Number.isFinite(threshold)
+      || threshold < 1
+      || threshold > 30) {
+      throw configurationError("hangThresholdSeconds must be a finite number from 1 through 30");
+    }
+    payload.hangThresholdSeconds = threshold;
+  }
+  return payload;
+}
+
+function requireApplePlatform() {
+  if (Platform?.OS !== "ios") {
+    throw new SdkError(
+      "unsupported_platform",
+      "LogBrew Apple native diagnostics are available only in an iOS native build"
+    );
+  }
+}
+
+function requireNativeModule() {
+  let nativeModule;
+  try {
+    nativeModule = TurboModuleRegistry?.get?.("LogBrewAppleDiagnostics")
+      ?? NativeModules?.LogBrewAppleDiagnostics;
+  } catch {
+    nativeModule = undefined;
+  }
+  if (!nativeModule) {
+    throw new SdkError(
+      "native_diagnostics_unavailable",
+      "LogBrew Apple native diagnostics require the AppleDiagnostics CocoaPods subspec; Expo projects can add @logbrew/react-native/expo"
+    );
+  }
+  return nativeModule;
+}
+
+function callNative(nativeModule, method, ...args) {
+  if (typeof nativeModule?.[method] !== "function") {
+    throw new SdkError(
+      "native_diagnostics_unavailable",
+      `linked LogBrew Apple diagnostics do not implement ${method}`
+    );
+  }
+  try {
+    return nativeModule[method](...args);
+  } catch {
+    throw new SdkError(
+      "native_diagnostics_failed",
+      `LogBrew Apple native diagnostics ${method} failed`
+    );
+  }
+}
+
+function requireStatusResult(operation, result, allowedStatuses) {
+  if (isErrorResult(result)) {
+    throw new SdkError(
+      result.code,
+      `LogBrew Apple native diagnostics ${operation} failed with ${result.code}`
+    );
+  }
+  if (!isPlainObject(result)
+    || !allowedStatuses.has(result.status)
+    || !LIFECYCLE_STATUSES.has(result.lifecycle)
+    || !isCount(result.pending)
+    || !isCount(result.acknowledged)
+    || !isCount(result.discarded)) {
+    throw new SdkError(
+      "native_diagnostics_invalid_response",
+      `LogBrew Apple native diagnostics ${operation} returned an invalid response`
+    );
+  }
+  return Object.freeze({
+    acknowledged: result.acknowledged,
+    discarded: result.discarded,
+    lifecycle: result.lifecycle,
+    pending: result.pending,
+    status: result.status
+  });
+}
+
+function requireReplayResult(result) {
+  if (isErrorResult(result)) {
+    throw new SdkError(
+      result.code,
+      `LogBrew Apple native diagnostics replay failed with ${result.code}`
+    );
+  }
+  if (!isPlainObject(result)
+    || result.status !== "replayed"
+    || !isCount(result.attempted)
+    || !isCount(result.acknowledged)
+    || !isCount(result.discarded)
+    || !isCount(result.pending)
+    || result.acknowledged + result.discarded > result.attempted) {
+    throw new SdkError(
+      "native_diagnostics_invalid_response",
+      "LogBrew Apple native diagnostics replay returned an invalid response"
+    );
+  }
+  return Object.freeze({
+    acknowledged: result.acknowledged,
+    attempted: result.attempted,
+    discarded: result.discarded,
+    pending: result.pending,
+    status: result.status
+  });
+}
+
+function isErrorResult(result) {
+  return isPlainObject(result)
+    && result.status === "error"
+    && typeof result.code === "string"
+    && /^[a-z0-9_]{1,128}$/u.test(result.code);
+}
+
+function isPlainObject(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+
+function isCount(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function exactString(name, value, maxBytes = 256) {
+  if (typeof value !== "string"
+    || value.length === 0
+    || value.trim() !== value
+    || hasControlCharacter(value)
+    || utf8Length(value) > maxBytes) {
+    throw configurationError(`${name} must be a non-empty bounded string without surrounding whitespace or control characters`);
+  }
+  return value;
+}
+
+function exactDeliveryEndpoint(value) {
+  const endpoint = exactString("endpoint", value, 2048);
+  let parsed;
+  try {
+    parsed = new URL(endpoint);
+  } catch {
+    throw configurationError("endpoint must be an absolute HTTPS URL");
+  }
+  if (parsed.protocol !== "https:") {
+    throw configurationError("endpoint must use HTTPS");
+  }
+  if (parsed.username
+    || parsed.password
+    || parsed.search
+    || parsed.hash
+    || endpoint !== `${parsed.origin}${parsed.pathname}`) {
+    throw configurationError("endpoint must be a plain HTTPS path without embedded auth, query, or fragment values");
+  }
+  return endpoint;
+}
+
+function hasControlCharacter(value) {
+  for (const scalar of value) {
+    const codePoint = scalar.codePointAt(0);
+    if (codePoint <= 0x1f || codePoint === 0x7f) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function utf8Length(value) {
+  let bytes = 0;
+  for (const scalar of value) {
+    const codePoint = scalar.codePointAt(0);
+    bytes += codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
+  }
+  return bytes;
+}
+
+function configurationError(message) {
+  return new SdkError("configuration_error", `LogBrew Apple native diagnostics ${message}`);
+}
+
+const logBrewAppleNativeDiagnostics = {
+  getLogBrewAppleNativeDiagnosticsStatus,
+  installLogBrewAppleNativeDiagnostics,
+  replayLogBrewAppleNativeDiagnostics
+};
+
+export default logBrewAppleNativeDiagnostics;

package/expo.cjs

@@ -0,0 +1,46 @@
+const PLUGIN_NAME = "@logbrew/react-native/expo";
+const START_MARKER = "  # @generated by @logbrew/react-native/expo";
+const END_MARKER = "  # @end @logbrew/react-native/expo";
+const POD_BLOCK = [
+  START_MARKER,
+  "  logbrew_react_native_path = File.dirname(`node --print \"require.resolve('@logbrew/react-native')\"`)",
+  "  pod 'LogBrewReactNative/AppleNativeDiagnostics', :path => logbrew_react_native_path",
+  END_MARKER
+].join("\n");
+
+function withLogBrewReactNative(config, options = {}) {
+  const { withPodfile } = require("expo/config-plugins");
+  return withPodfile(config, (podfileConfig) => {
+    podfileConfig.modResults.contents = modifyPodfile(
+      podfileConfig.modResults.contents,
+      options?.appleNativeDiagnostics !== false
+    );
+    return podfileConfig;
+  });
+}
+
+function modifyPodfile(contents, enabled = true) {
+  if (typeof contents !== "string") {
+    throw new TypeError(`${PLUGIN_NAME} expected Podfile text`);
+  }
+  const withoutManagedBlock = contents.replace(
+    new RegExp(`${escapePattern(START_MARKER)}[\\s\\S]*?${escapePattern(END_MARKER)}\\n?`, "gu"),
+    ""
+  );
+  if (!enabled) {
+    return withoutManagedBlock;
+  }
+  const targetPattern = /^(target\s+['"][^'"]+['"]\s+do\s*)$/mu;
+  if (!targetPattern.test(withoutManagedBlock)) {
+    throw new Error(`${PLUGIN_NAME} could not locate an iOS application target in the Podfile`);
+  }
+  return withoutManagedBlock.replace(targetPattern, `$1\n${POD_BLOCK}`);
+}
+
+function escapePattern(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+
+module.exports = withLogBrewReactNative;
+module.exports.modifyPodfile = modifyPodfile;
+module.exports.withLogBrewReactNative = withLogBrewReactNative;

package/expo.d.ts

@@ -0,0 +1,16 @@
+export type LogBrewExpoPluginOptions = {
+  /** Add the opt-in Apple native crash and app-hang CocoaPods subspec. Defaults to true. */
+  appleNativeDiagnostics?: boolean;
+};
+
+export type ExpoConfigLike = Record<string, unknown>;
+export type LogBrewExpoConfigPlugin = (
+  config: ExpoConfigLike,
+  options?: LogBrewExpoPluginOptions
+) => ExpoConfigLike;
+
+export declare const withLogBrewReactNative: LogBrewExpoConfigPlugin;
+export declare function modifyPodfile(contents: string, enabled?: boolean): string;
+
+declare const defaultExport: LogBrewExpoConfigPlugin;
+export default defaultExport;

package/expo.js

@@ -0,0 +1,5 @@
+import plugin from "./expo.cjs";
+
+export const modifyPodfile = plugin.modifyPodfile;
+export const withLogBrewReactNative = plugin.withLogBrewReactNative;
+export default plugin;

package/fatal-replay.cjs

@@ -293,7 +293,11 @@ function fatalStackFrames(error, stackFrame) {
     const frame = stackFrame(line);
     const filename = frame ? normalizedStoredFatalFilename(frame.filename) : undefined;
     if (filename && validFatalFilename(filename)) {
-      frames.push(Object.freeze({ ...frame, filename }));
+      frames.push(Object.freeze({
+        column: frame.column,
+        filename,
+        line: frame.line
+      }));
       if (frames.length === MAX_FATAL_STACK_FRAMES) {
         break;
       }
@@ -304,6 +308,13 @@ function fatalStackFrames(error, stackFrame) {
 
 function fatalEventAttributes(record, eventMessage) {
   return Object.freeze({
+    exception: Object.freeze({
+      type: record.errorName,
+      mechanism: Object.freeze({
+        type: "react_native_error_utils",
+        handled: false
+      })
+    }),
     level: "fatal",
     message: eventMessage,
     metadata: Object.freeze({

package/global-errors.cjs

@@ -196,7 +196,9 @@ function createAutomaticErrorEvent(error) {
   }
   const event = createReactNativeErrorEvent(sanitizedError, {
     id: nextEventId(),
-    includeStack: false
+    handled: false,
+    includeStack: false,
+    mechanism: "react_native_error_utils"
   });
   return {
     ...event,