@logbrew/react-native 0.1.23 → 0.1.25

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

@@ -0,0 +1,368 @@
+package co.logbrew.reactnative;
+
+import java.nio.charset.StandardCharsets;
+import java.security.SecureRandom;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.LongConsumer;
+import java.util.function.Supplier;
+import java.util.regex.Pattern;
+
+final class AndroidNativeDiagnostics {
+  interface Scheduler {
+    void start(long thresholdMs, LongConsumer report);
+
+    void stop();
+  }
+
+  static final class Configuration {
+    private static final Pattern PROJECT_ID =
+        Pattern.compile("^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$");
+    final String projectId;
+    final String release;
+    final String environment;
+    final String service;
+    final String operatingSystemVersion;
+    final String deviceModel;
+    final String architecture;
+    final long anrThresholdMs;
+
+    Configuration(
+        String projectId,
+        String release,
+        String environment,
+        String service,
+        String operatingSystemVersion,
+        String deviceModel,
+        String architecture,
+        long anrThresholdMs) {
+      if (!PROJECT_ID.matcher(projectId).matches()
+          || !bounded(release, 256)
+          || !bounded(environment, 128)
+          || !bounded(service, 128)
+          || !bounded(operatingSystemVersion, 128)
+          || !bounded(deviceModel, 128)
+          || !isArchitecture(architecture)
+          || anrThresholdMs < 2_000
+          || anrThresholdMs > 60_000) {
+        throw new IllegalArgumentException("invalid Android diagnostics configuration");
+      }
+      this.projectId = projectId;
+      this.release = release;
+      this.environment = environment;
+      this.service = service;
+      this.operatingSystemVersion = operatingSystemVersion;
+      this.deviceModel = deviceModel;
+      this.architecture = architecture;
+      this.anrThresholdMs = anrThresholdMs;
+    }
+
+    private static boolean bounded(String value, int maximum) {
+      return value != null
+          && !value.isEmpty()
+          && value.length() <= maximum
+          && value.equals(value.trim())
+          && value.chars().noneMatch(
+              character -> character <= 31 || character >= 127 && character <= 159);
+    }
+
+    private static boolean isArchitecture(String value) {
+      return "arm".equals(value)
+          || "arm64".equals(value)
+          || "x86".equals(value)
+          || "x86_64".equals(value);
+    }
+
+    boolean matches(Configuration other) {
+      return other != null
+          && projectId.equals(other.projectId)
+          && release.equals(other.release)
+          && environment.equals(other.environment)
+          && service.equals(other.service)
+          && operatingSystemVersion.equals(other.operatingSystemVersion)
+          && deviceModel.equals(other.deviceModel)
+          && architecture.equals(other.architecture)
+          && anrThresholdMs == other.anrThresholdMs;
+    }
+  }
+
+  private static final int MAX_FRAMES = 32;
+  private static final AtomicLong SEQUENCE = new AtomicLong();
+
+  final EventRecordStore eventStore;
+  final AndroidNativeSignalStore signalStore;
+  private final Configuration configuration;
+  private final Scheduler scheduler;
+  private final Runnable afterPersist;
+  private final Thread.UncaughtExceptionHandler previousHandler;
+  private final Supplier<StackTraceElement[]> mainFrames;
+  private final String processNonce;
+  boolean installed;
+
+  AndroidNativeDiagnostics(
+      EventRecordStore eventStore,
+      AndroidNativeSignalStore signalStore,
+      Configuration configuration,
+      Scheduler scheduler,
+      Runnable afterPersist,
+      Thread.UncaughtExceptionHandler previousHandler,
+      Supplier<StackTraceElement[]> mainFrames) {
+    this.eventStore = eventStore;
+    this.signalStore = signalStore;
+    this.configuration = configuration;
+    this.scheduler = scheduler;
+    this.afterPersist = afterPersist;
+    this.previousHandler = previousHandler;
+    this.mainFrames = mainFrames;
+    processNonce = randomHex(8);
+  }
+
+  synchronized String install() {
+    if (installed) {
+      return "already_installed";
+    }
+    replaySignalRecord();
+    scheduler.start(configuration.anrThresholdMs, this::reportHang);
+    installed = true;
+    return "installed";
+  }
+
+  synchronized String uninstall() {
+    if (!installed) {
+      return "not_installed";
+    }
+    installed = false;
+    scheduler.stop();
+    return "uninstalled";
+  }
+
+  void handleUncaught(Thread thread, Throwable error) {
+    try {
+      append(javaCrashEvent(error));
+    } finally {
+      previousHandler.uncaughtException(thread, error);
+    }
+  }
+
+  private synchronized void reportHang(long durationMs) {
+    if (!installed) {
+      return;
+    }
+    long boundedDuration =
+        Math.max(configuration.anrThresholdMs, Math.min(durationMs, 300_000));
+    append(hangEvent(mainFrames.get(), boundedDuration));
+  }
+
+  static boolean shouldReportHang(
+      long elapsedMs, long thresholdMs, boolean debugging, boolean processNotResponding) {
+    return !debugging && processNotResponding && elapsedMs >= thresholdMs;
+  }
+
+  private void replaySignalRecord() {
+    AndroidNativeSignalStore.Record record = signalStore.read();
+    if (record != null && append(nativeCrashEvent(record))) {
+      signalStore.clear();
+    }
+  }
+
+  private boolean append(String serializedEvent) {
+    int bytes = serializedEvent.getBytes(StandardCharsets.UTF_8).length;
+    EventRecordStore.Result result = eventStore.append(serializedEvent, bytes);
+    if (!"appended".equals(result.status)) {
+      return false;
+    }
+    afterPersist.run();
+    return true;
+  }
+
+  private String javaCrashEvent(Throwable error) {
+    StackTraceElement[] frames = error == null ? new StackTraceElement[0] : error.getStackTrace();
+    return issueEvent(
+        configuration,
+        nextId("java"),
+        System.currentTimeMillis(),
+        "Native application crash",
+        "critical",
+        safeSymbol(error == null ? null : error.getClass().getName(), 256, "AndroidJavaCrash"),
+        "uncaught_exception",
+        0,
+        frames,
+        null);
+  }
+
+  private String hangEvent(StackTraceElement[] frames, long durationMs) {
+    return issueEvent(
+        configuration,
+        nextId("hang"),
+        System.currentTimeMillis(),
+        "Native application hang",
+        "error",
+        "AndroidAppHang",
+        "anr_watchdog",
+        durationMs,
+        frames,
+        null);
+  }
+
+  private String nativeCrashEvent(AndroidNativeSignalStore.Record record) {
+    return issueEvent(
+        new Configuration(
+            record.projectId,
+            record.release,
+            record.environment,
+            record.service,
+            configuration.operatingSystemVersion,
+            configuration.deviceModel,
+            record.architecture,
+            configuration.anrThresholdMs),
+        record.id,
+        record.timestampMs,
+        "Native application crash",
+        "critical",
+        "AndroidNativeCrash",
+        "signal",
+        0,
+        new StackTraceElement[0],
+        record);
+  }
+
+  private String issueEvent(
+      Configuration eventConfiguration,
+      String id,
+      long timestampMs,
+      String title,
+      String level,
+      String exceptionType,
+      String mechanism,
+      long durationMs,
+      StackTraceElement[] frames,
+      AndroidNativeSignalStore.Record nativeFrame) {
+    StringBuilder output = new StringBuilder(2048);
+    output.append("{\"type\":\"issue\",\"id\":\"").append(id)
+        .append("\",\"timestamp\":\"").append(timestamp(timestampMs))
+        .append("\",\"attributes\":{\"title\":\"").append(title)
+        .append("\",\"level\":\"").append(level).append('"');
+    appendJavaFrames(output, frames);
+    if (nativeFrame != null) {
+      output.append(",\"nativeStackFrames\":[{\"imageUuid\":\"")
+          .append(nativeFrame.imageUuid).append("\",\"architecture\":\"")
+          .append(nativeFrame.architecture).append("\",\"instructionOffset\":\"")
+          .append(nativeFrame.instructionOffset).append("\"}]");
+    }
+    output.append(",\"exception\":{\"type\":\"").append(exceptionType)
+        .append("\",\"mechanism\":{\"type\":\"").append(mechanism)
+        .append("\",\"handled\":false}},\"metadata\":{")
+        .append("\"crash.mechanism\":\"").append(mechanism)
+        .append("\",\"crash.replayed\":true,\"crash.handled\":false,")
+        .append("\"projectId\":\"").append(eventConfiguration.projectId)
+        .append("\",\"release\":\"").append(json(eventConfiguration.release))
+        .append("\",\"environment\":\"").append(json(eventConfiguration.environment))
+        .append("\",\"service\":\"").append(json(eventConfiguration.service)).append('"');
+    if (durationMs > 0) {
+      output.append(",\"durationMs\":").append(durationMs);
+    }
+    if (nativeFrame != null) {
+      output.append(",\"crash.signal\":").append(nativeFrame.signal);
+    }
+    output.append('}');
+    appendContext(output, eventConfiguration);
+    return output.append("}}").toString();
+  }
+
+  private static void appendJavaFrames(StringBuilder output, StackTraceElement[] frames) {
+    int start = output.length();
+    output.append(",\"stackFrames\":[");
+    int count = 0;
+    for (StackTraceElement frame : frames) {
+      if (frame == null || frame.getLineNumber() <= 0 || count == MAX_FRAMES) {
+        continue;
+      }
+      String filename = safeFilename(frame.getFileName());
+      if (filename == null) {
+        continue;
+      }
+      if (count > 0) {
+        output.append(',');
+      }
+      output.append("{\"filename\":\"").append(json(filename))
+          .append("\",\"line\":").append(frame.getLineNumber())
+          .append(",\"column\":1,\"function\":\"")
+          .append(json(safeSymbol(frame.getMethodName(), 256, "unknown")))
+          .append("\",\"module\":\"")
+          .append(json(safeSymbol(frame.getClassName(), 512, "unknown"))).append("\"}");
+      count += 1;
+    }
+    if (count == 0) {
+      output.setLength(start);
+    } else {
+      output.append(']');
+    }
+  }
+
+  private static void appendContext(StringBuilder output, Configuration value) {
+    output.append(",\"context\":{\"schemaVersion\":1,\"resource\":{\"service\":{\"name\":\"")
+        .append(json(value.service)).append("\"},\"deployment\":{\"environment\":\"")
+        .append(json(value.environment)).append("\",\"release\":\"")
+        .append(json(value.release)).append("\"},\"operatingSystem\":{\"name\":\"Android\",\"version\":\"")
+        .append(json(value.operatingSystemVersion)).append("\"},\"device\":{\"model\":\"")
+        .append(json(value.deviceModel)).append("\",\"architecture\":\"")
+        .append(value.architecture).append("\"}}}");
+  }
+
+  private String nextId(String kind) {
+    return "evt_android_" + kind + '_' + processNonce + '_' + Long.toString(SEQUENCE.incrementAndGet(), 36);
+  }
+
+  String nextNativeEventId() {
+    return nextId("native");
+  }
+
+  boolean configurationMatches(Configuration candidate) {
+    return configuration.matches(candidate);
+  }
+
+  private static String safeFilename(String value) {
+    String safe = safeSymbol(value, 256, null);
+    return safe == null || safe.contains("/") || safe.contains("\\") || safe.contains("?") || safe.contains("#") ? null : safe;
+  }
+
+  private static String safeSymbol(String value, int maximum, String fallback) {
+    return value == null
+            || value.trim().isEmpty()
+            || value.length() > maximum
+            || value.chars().anyMatch(character -> character <= 31 || character == 127)
+        ? fallback
+        : value.trim();
+  }
+
+  private static String json(String value) {
+    StringBuilder output = new StringBuilder(value.length());
+    for (int index = 0; index < value.length(); index += 1) {
+      char character = value.charAt(index);
+      if (character == '"' || character == '\\') {
+        output.append('\\');
+      }
+      output.append(character);
+    }
+    return output.toString();
+  }
+
+  private static String timestamp(long timestampMs) {
+    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US);
+    format.setTimeZone(TimeZone.getTimeZone("UTC"));
+    return format.format(new Date(timestampMs));
+  }
+
+  private static String randomHex(int bytes) {
+    byte[] value = new byte[bytes];
+    new SecureRandom().nextBytes(value);
+    StringBuilder output = new StringBuilder(bytes * 2);
+    for (byte item : value) {
+      output.append(String.format(Locale.ROOT, "%02x", item & 0xff));
+    }
+    return output.toString();
+  }
+}

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

@@ -0,0 +1,233 @@
+package co.logbrew.reactnative;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.regex.Pattern;
+import java.util.zip.CRC32;
+
+final class AndroidNativeSignalStore {
+  static final int MAGIC = 0x4c424e53;
+  static final int VERSION = 1;
+  static final int ID_BYTES = 96;
+  static final int UUID_BYTES = 36;
+  static final int ARCH_BYTES = 16;
+  static final int OFFSET_BYTES = 16;
+  static final int PROJECT_BYTES = 36 * 2;
+  static final int RELEASE_BYTES = 256 * 2;
+  static final int ENVIRONMENT_BYTES = 128 * 2;
+  static final int SERVICE_BYTES = 128 * 2;
+  static final int RECORD_BYTES =
+      4 + 4 + 4 + 8 + ID_BYTES + UUID_BYTES + ARCH_BYTES + OFFSET_BYTES
+          + PROJECT_BYTES + RELEASE_BYTES + ENVIRONMENT_BYTES + SERVICE_BYTES + 4;
+
+  private static final Pattern ID = Pattern.compile("^evt_android_native_[a-z0-9_]{1,76}$");
+  private static final Pattern UUID =
+      Pattern.compile("^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$");
+  private static final Pattern OFFSET = Pattern.compile("^[0-9a-f]{16}$");
+  private static final Pattern ARCHITECTURE = Pattern.compile("^(?:arm|arm64|x86|x86_64)$");
+
+  private final File file;
+
+  AndroidNativeSignalStore(File file) {
+    this.file = canonicalFile(file);
+  }
+
+  synchronized Record read() {
+    if (!safeRegularFile(file) || file.length() != RECORD_BYTES) {
+      discardInvalid();
+      return null;
+    }
+    byte[] bytes = new byte[RECORD_BYTES];
+    try (FileInputStream stream = new FileInputStream(file)) {
+      if (stream.read(bytes) != RECORD_BYTES || stream.read() != -1) {
+        discardInvalid();
+        return null;
+      }
+    } catch (Exception error) {
+      return null;
+    }
+    ByteBuffer input = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN);
+    if (input.getInt() != MAGIC || input.getInt() != VERSION) {
+      discardInvalid();
+      return null;
+    }
+    int signal = input.getInt();
+    long timestampMs = input.getLong();
+    String id = ascii(input, ID_BYTES);
+    String imageUuid = ascii(input, UUID_BYTES);
+    String architecture = ascii(input, ARCH_BYTES);
+    String instructionOffset = ascii(input, OFFSET_BYTES);
+    String projectId = utf16(input, PROJECT_BYTES);
+    String release = utf16(input, RELEASE_BYTES);
+    String environment = utf16(input, ENVIRONMENT_BYTES);
+    String service = utf16(input, SERVICE_BYTES);
+    long expectedChecksum = Integer.toUnsignedLong(input.getInt());
+    CRC32 checksum = new CRC32();
+    checksum.update(bytes, 0, RECORD_BYTES - 4);
+    if (expectedChecksum != checksum.getValue()
+        || signal <= 0
+        || timestampMs <= 0
+        || !ID.matcher(id).matches()
+        || !UUID.matcher(imageUuid).matches()
+        || !ARCHITECTURE.matcher(architecture).matches()
+        || !OFFSET.matcher(instructionOffset).matches()
+        || !UUID.matcher(projectId).matches()
+        || !bounded(release, 256)
+        || !bounded(environment, 128)
+        || !bounded(service, 128)) {
+      discardInvalid();
+      return null;
+    }
+    return new Record(
+        id,
+        signal,
+        timestampMs,
+        imageUuid,
+        architecture,
+        instructionOffset,
+        projectId,
+        release,
+        environment,
+        service);
+  }
+
+  synchronized boolean prepare(EventRecordStore.ParentDirectorySync parentSync) {
+    if (file.exists()) {
+      if (!safeRegularFile(file)) {
+        return false;
+      }
+      read();
+      if (file.exists()) {
+        return false;
+      }
+    }
+    try (FileOutputStream output = new FileOutputStream(file, false)) {
+      output.write(new byte[RECORD_BYTES]);
+      output.getFD().sync();
+      return parentSync.sync(file.getParentFile())
+          != EventRecordStore.ParentDirectorySyncResult.FAILED;
+    } catch (Exception error) {
+      return false;
+    }
+  }
+
+  synchronized boolean clear() {
+    return !file.exists() || (safeRegularFile(file) && file.delete());
+  }
+
+  String path() {
+    return file.getAbsolutePath();
+  }
+
+  private void discardInvalid() {
+    if (safeRegularFile(file)) {
+      file.delete();
+    }
+  }
+
+  private static File canonicalFile(File candidate) {
+    try {
+      File parent = candidate.getParentFile();
+      return parent == null
+          ? candidate.getCanonicalFile()
+          : new File(parent.getCanonicalFile(), candidate.getName());
+    } catch (Exception error) {
+      return candidate.getAbsoluteFile();
+    }
+  }
+
+  private static boolean safeRegularFile(File candidate) {
+    try {
+      return candidate.exists()
+          && candidate.isFile()
+          && !java.nio.file.Files.isSymbolicLink(candidate.toPath())
+          && candidate.getCanonicalFile().equals(candidate.getAbsoluteFile());
+    } catch (Exception error) {
+      return false;
+    }
+  }
+
+  private static String ascii(ByteBuffer input, int width) {
+    byte[] bytes = new byte[width];
+    input.get(bytes);
+    int end = 0;
+    while (end < bytes.length && bytes[end] != 0) {
+      if (bytes[end] < 0x20 || bytes[end] > 0x7e) {
+        return "";
+      }
+      end += 1;
+    }
+    for (int index = end; index < bytes.length; index += 1) {
+      if (bytes[index] != 0) {
+        return "";
+      }
+    }
+    return new String(Arrays.copyOf(bytes, end), StandardCharsets.US_ASCII);
+  }
+
+  private static String utf16(ByteBuffer input, int bytes) {
+    char[] value = new char[bytes / 2];
+    int end = 0;
+    boolean terminated = false;
+    for (int index = 0; index < value.length; index += 1) {
+      char character = input.getChar();
+      if (character == 0) {
+        terminated = true;
+      } else if (terminated) {
+        return "";
+      } else {
+        value[end++] = character;
+      }
+    }
+    return new String(value, 0, end);
+  }
+
+  private static boolean bounded(String value, int maximum) {
+    return !value.isEmpty()
+        && value.length() <= maximum
+        && value.equals(value.trim())
+        && value.chars().noneMatch(
+            character -> character <= 31 || character >= 127 && character <= 159);
+  }
+
+  static final class Record {
+    final String id;
+    final int signal;
+    final long timestampMs;
+    final String imageUuid;
+    final String architecture;
+    final String instructionOffset;
+    final String projectId;
+    final String release;
+    final String environment;
+    final String service;
+
+    Record(
+        String id,
+        int signal,
+        long timestampMs,
+        String imageUuid,
+        String architecture,
+        String instructionOffset,
+        String projectId,
+        String release,
+        String environment,
+        String service) {
+      this.id = id;
+      this.signal = signal;
+      this.timestampMs = timestampMs;
+      this.imageUuid = imageUuid;
+      this.architecture = architecture;
+      this.instructionOffset = instructionOffset;
+      this.projectId = projectId;
+      this.release = release;
+      this.environment = environment;
+      this.service = service;
+    }
+  }
+}

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

@@ -6,9 +6,9 @@ import android.system.OsConstants;
 import java.io.File;
 import java.io.FileDescriptor;
 
-final class AndroidParentDirectorySync implements FatalRecordStore.ParentDirectorySync {
+final class AndroidParentDirectorySync implements EventRecordStore.ParentDirectorySync {
   @Override
-  public FatalRecordStore.ParentDirectorySyncResult sync(File directory) {
+  public EventRecordStore.ParentDirectorySyncResult sync(File directory) {
     FileDescriptor descriptor;
     try {
       descriptor =
@@ -17,39 +17,39 @@ final class AndroidParentDirectorySync implements FatalRecordStore.ParentDirecto
               OsConstants.O_RDONLY | OsConstants.O_CLOEXEC | OsConstants.O_NOFOLLOW,
               0);
     } catch (ErrnoException | RuntimeException error) {
-      return FatalRecordStore.ParentDirectorySyncResult.FAILED;
+      return EventRecordStore.ParentDirectorySyncResult.FAILED;
     }
 
-    FatalRecordStore.ParentDirectorySyncResult result;
+    EventRecordStore.ParentDirectorySyncResult result;
     try {
       if (!OsConstants.S_ISDIR(Os.fstat(descriptor).st_mode)) {
-        result = FatalRecordStore.ParentDirectorySyncResult.FAILED;
+        result = EventRecordStore.ParentDirectorySyncResult.FAILED;
       } else {
         result = syncDescriptor(descriptor);
       }
     } catch (ErrnoException | RuntimeException error) {
-      result = FatalRecordStore.ParentDirectorySyncResult.FAILED;
+      result = EventRecordStore.ParentDirectorySyncResult.FAILED;
     }
 
     try {
       Os.close(descriptor);
     } catch (ErrnoException | RuntimeException error) {
-      return FatalRecordStore.ParentDirectorySyncResult.FAILED;
+      return EventRecordStore.ParentDirectorySyncResult.FAILED;
     }
     return result;
   }
 
-  private static FatalRecordStore.ParentDirectorySyncResult syncDescriptor(
+  private static EventRecordStore.ParentDirectorySyncResult syncDescriptor(
       FileDescriptor descriptor) {
     try {
       Os.fsync(descriptor);
-      return FatalRecordStore.ParentDirectorySyncResult.SYNCHRONIZED;
+      return EventRecordStore.ParentDirectorySyncResult.SYNCHRONIZED;
     } catch (ErrnoException error) {
       return unsupportedDirectorySync(error.errno)
-          ? FatalRecordStore.ParentDirectorySyncResult.UNSUPPORTED
-          : FatalRecordStore.ParentDirectorySyncResult.FAILED;
+          ? EventRecordStore.ParentDirectorySyncResult.UNSUPPORTED
+          : EventRecordStore.ParentDirectorySyncResult.FAILED;
     } catch (RuntimeException error) {
-      return FatalRecordStore.ParentDirectorySyncResult.FAILED;
+      return EventRecordStore.ParentDirectorySyncResult.FAILED;
     }
   }