@logbrew/react-native 0.1.10 → 0.1.11

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/index.cjs

@@ -29,6 +29,7 @@ function createLogBrewReactNativeClient({
   clientKey,
   deliveryIntervalMs,
   deliveryQueueThreshold,
+  eventStore,
   maxBatchBytes,
   maxBatchEvents,
   maxQueueBytes,
@@ -48,6 +49,7 @@ function createLogBrewReactNativeClient({
     automaticDelivery,
     deliveryIntervalMs,
     deliveryQueueThreshold,
+    eventStore,
     maxBatchBytes,
     maxBatchEvents,
     maxQueueBytes,

package/index.d.cts

@@ -4,6 +4,7 @@ import type {
   DeliveryHealthSnapshot,
   DroppedEvent,
   EnvironmentAttributes,
+  EventStore,
   IssueAttributes,
   LogAttributes,
   LogBrewClient,
@@ -37,6 +38,8 @@ export type CreateLogBrewReactNativeClientConfig = {
   clientKey?: string;
   deliveryIntervalMs?: number;
   deliveryQueueThreshold?: number;
+  /** Advanced synchronous persistence seam. React Native apps normally use the native entry's persistentQueue mode. */
+  eventStore?: EventStore;
   maxBatchBytes?: number;
   maxBatchEvents?: number;
   maxQueueBytes?: number;

package/index.d.ts

@@ -4,6 +4,7 @@ import type {
   DeliveryHealthSnapshot,
   DroppedEvent,
   EnvironmentAttributes,
+  EventStore,
   IssueAttributes,
   LogAttributes,
   LogBrewClient,
@@ -37,6 +38,8 @@ export type CreateLogBrewReactNativeClientConfig = {
   clientKey?: string;
   deliveryIntervalMs?: number;
   deliveryQueueThreshold?: number;
+  /** Advanced synchronous persistence seam. React Native apps normally use the native entry's persistentQueue mode. */
+  eventStore?: EventStore;
   maxBatchBytes?: number;
   maxBatchEvents?: number;
   maxQueueBytes?: number;

package/index.js

@@ -29,6 +29,7 @@ export function createLogBrewReactNativeClient({
   clientKey,
   deliveryIntervalMs,
   deliveryQueueThreshold,
+  eventStore,
   maxBatchBytes,
   maxBatchEvents,
   maxQueueBytes,
@@ -48,6 +49,7 @@ export function createLogBrewReactNativeClient({
     automaticDelivery,
     deliveryIntervalMs,
     deliveryQueueThreshold,
+    eventStore,
     maxBatchBytes,
     maxBatchEvents,
     maxQueueBytes,

package/index.native.d.ts

@@ -1,5 +1,47 @@
-export * from "./index";
+import type { EventStore, LogBrewClient } from "@logbrew/sdk";
+import type { CreateLogBrewReactNativeClientConfig } from "./index.js";
+
+export * from "./index.js";
 export {
   installLogBrewReactNativeGlobalErrorHandler,
   installLogBrewReactNativePromiseRejectionTracker
 } from "./global-errors";
+
+export type ReactNativePersistentQueueMode = "auto" | "required" | "disabled";
+
+export type CreateNativeLogBrewReactNativeClientConfig =
+  Omit<CreateLogBrewReactNativeClientConfig, "eventStore"> & ({
+    /**
+     * `auto` uses the linked app-private native queue when available and otherwise uses memory.
+     * `required` fails client creation when the native queue is unavailable. `disabled` uses memory.
+     */
+    persistentQueue?: ReactNativePersistentQueueMode;
+    eventStore?: undefined;
+  } | {
+    /** Advanced app-owned synchronous persistence adapter. Mutually exclusive with persistentQueue. */
+    eventStore: EventStore;
+    persistentQueue?: never;
+  });
+
+export declare function createLogBrewReactNativeClient(
+  config: CreateNativeLogBrewReactNativeClientConfig
+): LogBrewClient;
+
+export declare function createDefaultLogBrewReactNativeClient(
+  config: CreateNativeLogBrewReactNativeClientConfig
+): LogBrewClient;
+
+export declare function purgeLogBrewReactNativePersistentQueue(
+  config: { apiKey?: string; clientKey?: string }
+): void;
+
+declare const defaultExport: Omit<
+  typeof import("./index.js").default,
+  "createLogBrewReactNativeClient" | "createDefaultLogBrewReactNativeClient"
+> & {
+  createLogBrewReactNativeClient: typeof createLogBrewReactNativeClient;
+  createDefaultLogBrewReactNativeClient: typeof createDefaultLogBrewReactNativeClient;
+  purgeLogBrewReactNativePersistentQueue: typeof purgeLogBrewReactNativePersistentQueue;
+};
+
+export default defaultExport;

package/index.native.js

@@ -6,9 +6,14 @@ import {
   captureReactNativeNetwork,
   captureScreenView,
   createAppStateListener,
-  createLogBrewReactNativeClient,
+  createLogBrewReactNativeClient as createPlatformNeutralClient,
   getReactNativeContext
 } from "./index.js";
+import baseDefault from "./index.js";
+import {
+  purgeReactNativePersistentQueue,
+  resolveReactNativePersistentEventStore
+} from "./persistent-delivery.native.js";
 export {
   installLogBrewReactNativeGlobalErrorHandler,
   installLogBrewReactNativePromiseRejectionTracker
@@ -16,6 +21,52 @@ export {
 
 export * from "./index.js";
 
+export function createLogBrewReactNativeClient(config = {}) {
+  const input = config !== null && typeof config === "object" ? config : {};
+  const {
+    apiKey,
+    clientKey,
+    eventStore,
+    maxQueueBytes,
+    maxQueueSize,
+    persistentQueue = "auto",
+    ...forwarded
+  } = input;
+  const hasExplicitPersistentQueue = Object.prototype.hasOwnProperty.call(
+    input,
+    "persistentQueue"
+  ) && input.persistentQueue !== undefined;
+  const authKey = clientKey ?? apiKey;
+  if (typeof authKey !== "string" || authKey.trim() === "") {
+    return createPlatformNeutralClient(input);
+  }
+  const resolved = resolveReactNativePersistentEventStore({
+    authKey,
+    eventStore,
+    maxQueueBytes,
+    maxQueueSize,
+    persistentQueue,
+    hasExplicitPersistentQueue
+  });
+  try {
+    return createPlatformNeutralClient({
+      ...forwarded,
+      apiKey,
+      clientKey,
+      eventStore: resolved.eventStore,
+      maxQueueBytes,
+      maxQueueSize
+    });
+  } catch (error) {
+    resolved.abort();
+    throw error;
+  }
+}
+
+export function purgeLogBrewReactNativePersistentQueue(config = {}) {
+  purgeReactNativePersistentQueue(config);
+}
+
 export function createDefaultLogBrewReactNativeClient(config = {}) {
   return createLogBrewReactNativeClient(config);
 }
@@ -70,3 +121,19 @@ export function createDefaultAppStateListener(client, options = {}) {
     ...options
   });
 }
+
+const defaultExport = {
+  ...baseDefault,
+  captureDefaultAppStateChange,
+  captureDefaultReactNativeAction,
+  captureDefaultReactNativeError,
+  captureDefaultReactNativeNetwork,
+  captureDefaultScreenView,
+  createDefaultAppStateListener,
+  createDefaultLogBrewReactNativeClient,
+  createLogBrewReactNativeClient,
+  getDefaultReactNativeContext,
+  purgeLogBrewReactNativePersistentQueue
+};
+
+export default defaultExport;

package/ios/LBRNEventRecordStore.h

@@ -0,0 +1,29 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+FOUNDATION_EXPORT NSString *const LBRNEventRecordPrefix;
+FOUNDATION_EXPORT NSString *const LBRNEventRecordSuffix;
+FOUNDATION_EXPORT NSString *const LBRNEventMarkerPrefix;
+FOUNDATION_EXPORT NSString *const LBRNEventMarkerSuffix;
+
+typedef BOOL (^LBRNEventDirectoryPreparation)(NSURL *directoryURL);
+
+@interface LBRNEventRecordStore : NSObject
+
+- (instancetype)initWithDirectoryURL:(NSURL *)directoryURL;
+- (instancetype)initWithDirectoryURL:(NSURL *)directoryURL
+                directoryPreparation:(LBRNEventDirectoryPreparation)directoryPreparation
+    NS_DESIGNATED_INITIALIZER;
+- (instancetype)init NS_UNAVAILABLE;
+
+- (NSDictionary *)loadRecords;
+- (NSDictionary *)appendSerializedEvent:(NSString *)serializedEvent
+                              eventBytes:(NSNumber *)eventBytes;
+- (NSDictionary *)acknowledgeRecordCount:(NSNumber *)count;
+- (NSDictionary *)purgeRecords;
+- (NSDictionary *)closeStore;
+
+@end
+
+NS_ASSUME_NONNULL_END