@logbrew/react-native 0.1.22 → 0.1.24

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

@@ -2,7 +2,6 @@ package co.logbrew.reactnative;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.ReadableType;
@@ -12,43 +11,51 @@ import java.io.File;
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
-import java.util.ArrayList;
+import java.security.SecureRandom;
 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 {
   static final String NAME = "LogBrewFatalStore";
+  private static final SecureRandom SECURE_RANDOM = new SecureRandom();
 
-  private static final Set<String> RECORD_KEYS =
+  private static final Set<String> ANDROID_DIAGNOSTICS_KEYS =
       new HashSet<>(
           Arrays.asList(
-              "schemaVersion",
-              "id",
-              "timestamp",
-              "errorName",
-              "stackFrames",
-              "droppedRecords",
-              "corruptRecords"));
-  private static final Set<String> FRAME_KEYS =
-      new HashSet<>(Arrays.asList("filename", "line", "column"));
+              "anrThresholdMs",
+              "clientKey",
+              "environment",
+              "fatalHandlerOwnership",
+              "projectId",
+              "release",
+              "service"));
 
-  private final FatalRecordStore store;
   private final File eventStoreParent;
+  private final ReactApplicationContext context;
   private final Map<String, EventRecordStore> eventStores = new HashMap<>();
+  private AndroidDiagnosticsRuntime androidDiagnostics;
 
   FatalStoreModuleImpl(ReactApplicationContext context) {
+    this.context = context;
     File root = context.getNoBackupFilesDir();
     eventStoreParent = root;
-    store =
-        root == null
-            ? null
-            : new FatalRecordStore(
-                new File(root, "logbrew-fatal-js"),
-                new AndroidParentDirectorySync());
+  }
+
+  String secureRandomHex(double length) {
+    Integer byteCount = integer(length);
+    if (byteCount == null || byteCount < 1 || byteCount > 64) {
+      return "";
+    }
+    byte[] bytes = new byte[byteCount];
+    SECURE_RANDOM.nextBytes(bytes);
+    StringBuilder output = new StringBuilder(byteCount * 2);
+    for (byte value : bytes) {
+      output.append(String.format(java.util.Locale.ROOT, "%02x", value & 0xff));
+    }
+    return output.toString();
   }
 
   WritableMap loadEventRecords(String queueKey) {
@@ -106,127 +113,111 @@ final class FatalStoreModuleImpl {
       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");
+  synchronized WritableMap installAndroidDiagnostics(ReadableMap input) {
+    AndroidDiagnosticsInput configuration = readAndroidDiagnosticsInput(input);
+    EventRecordStore eventStore =
+        configuration == null ? null : eventStore(configuration.clientKey);
+    String queueHash =
+        configuration == null ? null : queueHash(configuration.clientKey);
+    if (eventStore == null || queueHash == null || eventStoreParent == null) {
+      return error("android_diagnostics_invalid_configuration");
+    }
+    if (androidDiagnostics != null && androidDiagnostics.installed()) {
+      return androidDiagnostics.matches(eventStore, configuration.configuration)
+          ? androidDiagnosticsReceipt("already_installed", androidDiagnostics.pending())
+          : error("android_diagnostics_owned");
+    }
+    File storageRoot = new File(eventStoreParent, "logbrew-android-diagnostics-v1-" + queueHash);
+    if ((!storageRoot.isDirectory() && !storageRoot.mkdirs()) || !storageRoot.isDirectory()) {
+      return error("android_diagnostics_storage_failed");
     }
     try {
-      FatalRecordStore.Record record = readRecord(input);
-      return record == null ? status("invalid_record") : resultMap(store.write(record));
+      androidDiagnostics =
+          new AndroidDiagnosticsRuntime(
+              context, storageRoot, eventStore, configuration.configuration);
+      String statusValue = androidDiagnostics.install();
+      return androidDiagnosticsResult(statusValue);
     } catch (RuntimeException error) {
-      return status("storage_error");
+      androidDiagnostics = null;
+      return error("android_diagnostics_install_failed");
     }
   }
 
-  WritableMap readFatalRecord() {
-    if (store == null) {
-      return status("storage_error");
-    }
-    try {
-      return resultMap(store.read());
-    } catch (RuntimeException error) {
-      return status("storage_error");
-    }
-  }
-
-  WritableMap acknowledgeFatalRecord(String recordId) {
-    if (store == null) {
-      return status("storage_error");
-    }
-    try {
-      return resultMap(store.acknowledge(recordId));
-    } catch (RuntimeException error) {
-      return status("storage_error");
+  synchronized WritableMap androidDiagnosticsStatus() {
+    if (androidDiagnostics == null || !androidDiagnostics.installed()) {
+      return androidDiagnosticsReceipt("not_installed", 0);
     }
+    return androidDiagnosticsResult("ready");
   }
 
-  WritableMap discardFatalRecord() {
-    if (store == null) {
-      return status("storage_error");
+  synchronized WritableMap uninstallAndroidDiagnostics() {
+    if (androidDiagnostics == null) {
+      return androidDiagnosticsReceipt("not_installed", 0);
     }
     try {
-      return resultMap(store.discard());
+      String statusValue = androidDiagnostics.uninstall();
+      WritableMap result = androidDiagnosticsResult(statusValue);
+      androidDiagnostics = null;
+      return result;
     } catch (RuntimeException error) {
-      return status("storage_error");
+      return error("android_diagnostics_uninstall_failed");
     }
   }
 
-  private static FatalRecordStore.Record readRecord(ReadableMap input) {
+  private static AndroidDiagnosticsInput readAndroidDiagnosticsInput(ReadableMap input) {
     if (input == null
-        || !hasExactKeys(input, RECORD_KEYS)
-        || !hasType(input, "schemaVersion", ReadableType.Number)
-        || !hasType(input, "id", ReadableType.String)
-        || !hasType(input, "timestamp", ReadableType.String)
-        || !hasType(input, "errorName", ReadableType.String)
-        || !hasType(input, "stackFrames", ReadableType.Array)
-        || !hasType(input, "droppedRecords", ReadableType.Number)
-        || !hasType(input, "corruptRecords", ReadableType.Number)) {
+        || !hasExactKeys(input, ANDROID_DIAGNOSTICS_KEYS)
+        || !hasType(input, "anrThresholdMs", ReadableType.Number)
+        || !hasType(input, "clientKey", ReadableType.String)
+        || !hasType(input, "environment", ReadableType.String)
+        || !hasType(input, "fatalHandlerOwnership", ReadableType.String)
+        || !hasType(input, "projectId", ReadableType.String)
+        || !hasType(input, "release", ReadableType.String)
+        || !hasType(input, "service", ReadableType.String)
+        || !"logbrew".equals(input.getString("fatalHandlerOwnership"))) {
       return null;
     }
-    Integer schemaVersion = integer(input, "schemaVersion");
-    Integer droppedRecords = integer(input, "droppedRecords");
-    Integer corruptRecords = integer(input, "corruptRecords");
-    if (schemaVersion == null || droppedRecords == null || corruptRecords == null) {
-      return null;
-    }
-
-    ReadableArray values = input.getArray("stackFrames");
-    if (values == null) {
-      return null;
-    }
-    List<FatalRecordStore.Frame> frames = new ArrayList<>(values.size());
-    for (int index = 0; index < values.size(); index += 1) {
-      if (values.getType(index) != ReadableType.Map) {
-        return null;
-      }
-      ReadableMap value = values.getMap(index);
-      FatalRecordStore.Frame frame = readFrame(value);
-      if (frame == null) {
-        return null;
-      }
-      frames.add(frame);
-    }
-    return new FatalRecordStore.Record(
-        schemaVersion,
-        input.getString("id"),
-        input.getString("timestamp"),
-        input.getString("errorName"),
-        frames,
-        droppedRecords,
-        corruptRecords);
-  }
-
-  private static FatalRecordStore.Frame readFrame(ReadableMap input) {
-    if (input == null
-        || !hasExactKeys(input, FRAME_KEYS)
-        || !hasType(input, "filename", ReadableType.String)
-        || !hasType(input, "line", ReadableType.Number)
-        || !hasType(input, "column", ReadableType.Number)) {
+    Integer threshold = integer(input, "anrThresholdMs");
+    String clientKey = input.getString("clientKey");
+    if (threshold == null || clientKey == null || clientKey.trim().isEmpty()) {
       return null;
     }
-    Integer line = integer(input, "line");
-    Integer column = integer(input, "column");
-    String filename = input.getString("filename");
-    if (line == null || column == null || filename == null) {
+    try {
+      return new AndroidDiagnosticsInput(
+          clientKey,
+          new AndroidNativeDiagnostics.Configuration(
+              input.getString("projectId"),
+              input.getString("release"),
+              input.getString("environment"),
+              input.getString("service"),
+              android.os.Build.VERSION.RELEASE,
+              android.os.Build.MODEL,
+              androidArchitecture(),
+              threshold));
+    } catch (IllegalArgumentException error) {
       return null;
     }
-    if (filename.startsWith("/")
-        && filename.indexOf('/', 1) < 0
-        && filename.length() > 1) {
-      filename = filename.substring(1);
-    }
-    return new FatalRecordStore.Frame(filename, line, column);
   }
 
   private static boolean hasType(ReadableMap map, String key, ReadableType type) {
     return map.hasKey(key) && !map.isNull(key) && map.getType(key) == type;
   }
 
+  private static String androidArchitecture() {
+    String[] values = android.os.Process.is64Bit()
+        ? android.os.Build.SUPPORTED_64_BIT_ABIS
+        : android.os.Build.SUPPORTED_32_BIT_ABIS;
+    String value = values.length == 0
+        ? ""
+        : values[0];
+    return "arm64-v8a".equals(value)
+        ? "arm64"
+        : "armeabi-v7a".equals(value) ? "arm" : value;
+  }
+
   private static boolean hasExactKeys(ReadableMap map, Set<String> expected) {
     Set<String> observed = new HashSet<>();
     ReadableMapKeySetIterator iterator = map.keySetIterator();
@@ -237,62 +228,31 @@ final class FatalStoreModuleImpl {
   }
 
   private static Integer integer(ReadableMap map, String key) {
-    double value = map.getDouble(key);
-    return Double.isFinite(value)
-            && value >= 0
-            && value <= Integer.MAX_VALUE
-            && value == Math.rint(value)
-        ? (int) value
-        : null;
+    return integer(map.getDouble(key));
   }
 
-  private static WritableMap resultMap(FatalRecordStore.Result result) {
-    if (result == null || result.status == null) {
-      return status("storage_error");
-    }
-    WritableMap output = status(result.status);
-    if (result.recordId != null) {
-      output.putString("recordId", result.recordId);
-    }
-    if (result.droppedRecords > 0) {
-      output.putInt("droppedRecords", result.droppedRecords);
-    }
-    if (result.corruptRecords > 0) {
-      output.putInt("corruptRecords", result.corruptRecords);
-    }
-    if (result.record != null) {
-      output.putMap("record", recordMap(result.record));
-    }
+  private static WritableMap status(String value) {
+    WritableMap output = Arguments.createMap();
+    output.putString("status", value);
     return output;
   }
 
-  private static WritableMap recordMap(FatalRecordStore.Record record) {
-    WritableMap output = Arguments.createMap();
-    output.putInt("schemaVersion", record.schemaVersion);
-    output.putString("id", record.id);
-    output.putString("timestamp", record.timestamp);
-    output.putString("errorName", record.errorName);
-    output.putArray("stackFrames", frameMaps(record.stackFrames));
-    output.putInt("droppedRecords", record.droppedRecords);
-    output.putInt("corruptRecords", record.corruptRecords);
+  private static WritableMap androidDiagnosticsReceipt(String value, int pending) {
+    WritableMap output = status(value);
+    output.putInt("pending", pending);
     return output;
   }
 
-  private static WritableArray frameMaps(List<FatalRecordStore.Frame> frames) {
-    WritableArray output = Arguments.createArray();
-    for (FatalRecordStore.Frame frame : frames) {
-      WritableMap value = Arguments.createMap();
-      value.putString("filename", frame.filename);
-      value.putInt("line", frame.line);
-      value.putInt("column", frame.column);
-      output.pushMap(value);
-    }
-    return output;
+  private WritableMap androidDiagnosticsResult(String status) {
+    int pending = androidDiagnostics.pending();
+    return pending < 0
+        ? error("android_diagnostics_storage_failed")
+        : androidDiagnosticsReceipt(status, pending);
   }
 
-  private static WritableMap status(String value) {
-    WritableMap output = Arguments.createMap();
-    output.putString("status", value);
+  private static WritableMap error(String code) {
+    WritableMap output = status("error");
+    output.putString("code", code);
     return output;
   }
 
@@ -356,4 +316,15 @@ final class FatalStoreModuleImpl {
     }
     return output;
   }
+
+  private static final class AndroidDiagnosticsInput {
+    final String clientKey;
+    final AndroidNativeDiagnostics.Configuration configuration;
+
+    AndroidDiagnosticsInput(
+        String clientKey, AndroidNativeDiagnostics.Configuration configuration) {
+      this.clientKey = clientKey;
+      this.configuration = configuration;
+    }
+  }
 }

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

@@ -18,23 +18,8 @@ final class FatalStoreModule extends NativeLogBrewFatalStoreSpec {
   }
 
   @Override
-  public WritableMap writeFatalRecord(ReadableMap record) {
-    return implementation.writeFatalRecord(record);
-  }
-
-  @Override
-  public WritableMap readFatalRecord() {
-    return implementation.readFatalRecord();
-  }
-
-  @Override
-  public WritableMap acknowledgeFatalRecord(String recordId) {
-    return implementation.acknowledgeFatalRecord(recordId);
-  }
-
-  @Override
-  public WritableMap discardFatalRecord() {
-    return implementation.discardFatalRecord();
+  public String secureRandomHex(double length) {
+    return implementation.secureRandomHex(length);
   }
 
   @Override
@@ -62,4 +47,19 @@ final class FatalStoreModule extends NativeLogBrewFatalStoreSpec {
   public WritableMap closeEventStore(String queueKey) {
     return implementation.closeEventStore(queueKey);
   }
+
+  @Override
+  public WritableMap installAndroidDiagnostics(ReadableMap configuration) {
+    return implementation.installAndroidDiagnostics(configuration);
+  }
+
+  @Override
+  public WritableMap androidDiagnosticsStatus() {
+    return implementation.androidDiagnosticsStatus();
+  }
+
+  @Override
+  public WritableMap uninstallAndroidDiagnostics() {
+    return implementation.uninstallAndroidDiagnostics();
+  }
 }

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

@@ -20,23 +20,8 @@ final class FatalStoreModule extends ReactContextBaseJavaModule {
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
-  public WritableMap writeFatalRecord(ReadableMap record) {
-    return implementation.writeFatalRecord(record);
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  public WritableMap readFatalRecord() {
-    return implementation.readFatalRecord();
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  public WritableMap acknowledgeFatalRecord(String recordId) {
-    return implementation.acknowledgeFatalRecord(recordId);
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  public WritableMap discardFatalRecord() {
-    return implementation.discardFatalRecord();
+  public String secureRandomHex(double length) {
+    return implementation.secureRandomHex(length);
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
@@ -64,4 +49,19 @@ final class FatalStoreModule extends ReactContextBaseJavaModule {
   public WritableMap closeEventStore(String queueKey) {
     return implementation.closeEventStore(queueKey);
   }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap installAndroidDiagnostics(ReadableMap configuration) {
+    return implementation.installAndroidDiagnostics(configuration);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap androidDiagnosticsStatus() {
+    return implementation.androidDiagnosticsStatus();
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap uninstallAndroidDiagnostics() {
+    return implementation.uninstallAndroidDiagnostics();
+  }
 }

package/android-native-diagnostics.d.ts

@@ -0,0 +1,29 @@
+export type LogBrewAndroidNativeDiagnosticsConfiguration = Readonly<{
+  anrThresholdMs?: number;
+  clientKey: string;
+  environment: string;
+  fatalHandlerOwnership: "logbrew";
+  projectId: string;
+  release: string;
+  service: string;
+}>;
+
+export type LogBrewAndroidNativeDiagnosticsReceipt = Readonly<{
+  pending: number;
+  status:
+    | "already_installed"
+    | "installed"
+    | "not_installed"
+    | "ready"
+    | "uninstalled";
+}>;
+
+export declare function installLogBrewAndroidNativeDiagnostics(
+  configuration: LogBrewAndroidNativeDiagnosticsConfiguration
+): LogBrewAndroidNativeDiagnosticsReceipt;
+
+export declare function getLogBrewAndroidNativeDiagnosticsStatus():
+  LogBrewAndroidNativeDiagnosticsReceipt;
+
+export declare function uninstallLogBrewAndroidNativeDiagnostics():
+  LogBrewAndroidNativeDiagnosticsReceipt;

package/android-native-diagnostics.js

@@ -0,0 +1,176 @@
+import { SdkError } from "@logbrew/sdk";
+import { NativeModules, Platform, TurboModuleRegistry } from "react-native";
+
+const INSTALL_KEYS = new Set([
+  "anrThresholdMs",
+  "clientKey",
+  "environment",
+  "fatalHandlerOwnership",
+  "projectId",
+  "release",
+  "service"
+]);
+const RECEIPT_KEYS = new Set(["pending", "status"]);
+
+export function installLogBrewAndroidNativeDiagnostics(configuration = {}) {
+  requireAndroid();
+  return receipt(
+    "install",
+    call("installAndroidDiagnostics", normalizeConfiguration(configuration)),
+    new Set(["already_installed", "installed"])
+  );
+}
+
+export function getLogBrewAndroidNativeDiagnosticsStatus() {
+  requireAndroid();
+  return receipt(
+    "status",
+    call("androidDiagnosticsStatus"),
+    new Set(["not_installed", "ready"])
+  );
+}
+
+export function uninstallLogBrewAndroidNativeDiagnostics() {
+  requireAndroid();
+  return receipt(
+    "uninstall",
+    call("uninstallAndroidDiagnostics"),
+    new Set(["not_installed", "uninstalled"])
+  );
+}
+
+function normalizeConfiguration(value) {
+  if (!isObject(value)) {
+    throw configurationError("configuration must be an object");
+  }
+  for (const key of Object.keys(value)) {
+    if (!INSTALL_KEYS.has(key)) {
+      throw configurationError("configuration contains an unsupported key");
+    }
+  }
+  if (value.fatalHandlerOwnership !== "logbrew") {
+    throw configurationError(
+      "fatalHandlerOwnership must be logbrew after removing every other Android fatal handler"
+    );
+  }
+  const projectId = exactText(value.projectId, 64, "projectId");
+  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");
+  }
+  const threshold = value.anrThresholdMs ?? 5000;
+  if (!Number.isSafeInteger(threshold) || threshold < 2000 || threshold > 60000) {
+    throw configurationError("anrThresholdMs must be an integer from 2000 through 60000");
+  }
+  return {
+    anrThresholdMs: threshold,
+    clientKey: exactText(value.clientKey, 4096, "clientKey"),
+    environment: exactText(value.environment, 128, "environment"),
+    fatalHandlerOwnership: "logbrew",
+    projectId,
+    release: exactText(value.release, 256, "release"),
+    service: exactScope(value.service, "service")
+  };
+}
+
+function exactScope(value, name) {
+  const text = exactText(value, 128, name);
+  if (!/^[A-Za-z0-9][A-Za-z0-9._/-]{0,127}$/u.test(text)
+    || text.includes("..")
+    || text.includes("//")) {
+    throw configurationError(`${name} must be a bounded deployment identifier`);
+  }
+  return text;
+}
+
+function exactText(value, maximumBytes, name) {
+  if (typeof value !== "string"
+    || value.length === 0
+    || value.trim() !== value
+    || controlCharacter(value)
+    || utf8Length(value) > maximumBytes) {
+    throw configurationError(`${name} must be a bounded non-empty string`);
+  }
+  return value;
+}
+
+function requireAndroid() {
+  if (Platform?.OS !== "android") {
+    throw new SdkError(
+      "unsupported_platform",
+      "LogBrew Android native diagnostics require an Android native build"
+    );
+  }
+}
+
+function call(method, ...args) {
+  let nativeModule;
+  try {
+    nativeModule = TurboModuleRegistry?.get?.("LogBrewFatalStore")
+      ?? NativeModules?.LogBrewFatalStore;
+  } catch {
+    nativeModule = undefined;
+  }
+  if (typeof nativeModule?.[method] !== "function") {
+    throw new SdkError(
+      "native_diagnostics_unavailable",
+      `linked LogBrew Android diagnostics do not implement ${method}`
+    );
+  }
+  try {
+    return nativeModule[method](...args);
+  } catch {
+    throw new SdkError(
+      "native_diagnostics_failed",
+      `LogBrew Android native diagnostics ${method} failed`
+    );
+  }
+}
+
+function receipt(operation, value, statuses) {
+  const keys = isObject(value) ? Object.keys(value) : [];
+  if (isObject(value)
+    && value.status === "error"
+    && typeof value.code === "string"
+    && /^[a-z0-9_]{1,128}$/u.test(value.code)) {
+    throw new SdkError(
+      value.code,
+      `LogBrew Android native diagnostics ${operation} failed with ${value.code}`
+    );
+  }
+  if (!isObject(value)
+    || keys.length !== RECEIPT_KEYS.size
+    || !keys.every((key) => RECEIPT_KEYS.has(key))
+    || !statuses.has(value.status)
+    || !Number.isSafeInteger(value.pending)
+    || value.pending < 0) {
+    throw new SdkError(
+      "native_diagnostics_invalid_response",
+      `LogBrew Android native diagnostics ${operation} returned an invalid response`
+    );
+  }
+  return Object.freeze({ pending: value.pending, status: value.status });
+}
+
+function isObject(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+
+function controlCharacter(value) {
+  return Array.from(value).some((character) => {
+    const code = character.codePointAt(0);
+    return code <= 31 || (code >= 127 && code <= 159);
+  });
+}
+
+function utf8Length(value) {
+  let length = 0;
+  for (const character of value) {
+    const code = character.codePointAt(0);
+    length += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
+  }
+  return length;
+}
+
+function configurationError(message) {
+  return new SdkError("configuration_error", `LogBrew Android native diagnostics ${message}`);
+}