@debugbundle/sdk-react-native 0.1.0

package/src/redaction.ts

@@ -0,0 +1,165 @@
+const DEFAULT_REDACT_FIELDS = [
+  "password",
+  "secret",
+  "token",
+  "api_key",
+  "apikey",
+  "access_token",
+  "refresh_token",
+  "private_key",
+  "passwd",
+  "card_number",
+  "cvv",
+  "cvc",
+  "pin",
+  "expiry",
+  "phone",
+  "bearer",
+  "session_id",
+  "otp",
+  "verification_code",
+  "authorization",
+  "cookie",
+  "ssn"
+];
+
+export const DEFAULT_HEADER_ALLOWLIST = [
+  "user-agent",
+  "content-type",
+  "accept",
+  "x-request-id",
+  "x-correlation-id",
+  "x-debugbundle-trace-id",
+  "traceparent"
+];
+
+export interface SanitizeOptions {
+  redactFields?: string[];
+  maxDepth?: number;
+  maxStringLength?: number;
+  maxArrayLength?: number;
+  maxObjectKeys?: number;
+}
+
+export function defaultRedactFields(): string[] {
+  return [...DEFAULT_REDACT_FIELDS];
+}
+
+export function sanitizeValue(value: unknown, options: SanitizeOptions = {}): unknown {
+  const visited = new WeakSet<object>();
+  return sanitize(value, normalizeOptions(options), 0, visited, undefined);
+}
+
+export function sanitizeHeaders(
+  headers: Record<string, string> | undefined,
+  allowlist: string[] = DEFAULT_HEADER_ALLOWLIST,
+  options: SanitizeOptions = {}
+): Record<string, string> {
+  if (!headers) {
+    return {};
+  }
+  const allowed = new Set(allowlist.map((header) => header.toLowerCase()));
+  const sanitized: Record<string, string> = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const normalizedKey = key.toLowerCase();
+    if (allowed.has(normalizedKey)) {
+      sanitized[normalizedKey] = String(sanitizeValue(value, options));
+    }
+  }
+  return sanitized;
+}
+
+function normalizeOptions(options: SanitizeOptions): Required<SanitizeOptions> {
+  return {
+    redactFields: options.redactFields ?? DEFAULT_REDACT_FIELDS,
+    maxDepth: options.maxDepth ?? 8,
+    maxStringLength: options.maxStringLength ?? 2048,
+    maxArrayLength: options.maxArrayLength ?? 50,
+    maxObjectKeys: options.maxObjectKeys ?? 50
+  };
+}
+
+function sanitize(
+  value: unknown,
+  options: Required<SanitizeOptions>,
+  depth: number,
+  visited: WeakSet<object>,
+  key: string | undefined
+): unknown {
+  if (key && isSensitiveKey(key, options.redactFields)) {
+    return "[Redacted]";
+  }
+  if (value === null || value === undefined) {
+    return value ?? null;
+  }
+  if (typeof value === "string") {
+    return truncate(value, options.maxStringLength);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "function" || typeof value === "symbol") {
+    return `[${typeof value}]`;
+  }
+  if (value instanceof Error) {
+    return sanitizeError(value, options, depth, visited);
+  }
+  if (depth >= options.maxDepth) {
+    return "[Truncated: depth]";
+  }
+  if (typeof value === "object") {
+    if (visited.has(value)) {
+      return "[Circular]";
+    }
+    visited.add(value);
+    if (Array.isArray(value)) {
+      return value
+        .slice(0, options.maxArrayLength)
+        .map((entry) => sanitize(entry, options, depth + 1, visited, undefined));
+    }
+    const output: Record<string, unknown> = {};
+    for (const [entryKey, entryValue] of Object.entries(value).slice(0, options.maxObjectKeys)) {
+      output[entryKey] = sanitize(entryValue, options, depth + 1, visited, entryKey);
+    }
+    return output;
+  }
+  return String(value);
+}
+
+function sanitizeError(
+  error: Error,
+  options: Required<SanitizeOptions>,
+  depth: number,
+  visited: WeakSet<object>
+): Record<string, unknown> {
+  return {
+    name: truncate(error.name || "Error", options.maxStringLength),
+    message: truncate(error.message || "", options.maxStringLength),
+    stack: typeof error.stack === "string" ? truncate(error.stack, options.maxStringLength * 4) : null,
+    cause: "cause" in error ? sanitize(error.cause, options, depth + 1, visited, "cause") : null
+  };
+}
+
+function truncate(value: string, maxLength: number): string {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength)}...[Truncated]`;
+}
+
+function isSensitiveKey(key: string, sensitiveFields: string[]): boolean {
+  const segments = splitKey(key);
+  const sensitive = new Set(sensitiveFields.flatMap(splitKey));
+  return segments.some((segment) => sensitive.has(segment));
+}
+
+function splitKey(key: string): string[] {
+  return key
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .split(/[^a-zA-Z0-9]+/)
+    .map((segment) => segment.toLowerCase())
+    .filter(Boolean);
+}

package/src/testing.ts

@@ -0,0 +1,45 @@
+import { resetNativeModuleCacheForTesting, setNativeModuleForTesting } from "./native.js";
+import type { DebugBundleEventEnvelope, NativeDebugBundleModule, NativeDebugBundleState, ResolvedDebugBundleConfig } from "./types.js";
+
+export interface RecordingNativeModule extends NativeDebugBundleModule {
+  events: DebugBundleEventEnvelope[];
+  config: ResolvedDebugBundleConfig | null;
+}
+
+export function createRecordingNativeModule(initialState: NativeDebugBundleState = { status: "healthy", lastEventAt: null }): RecordingNativeModule {
+  const state = { ...initialState };
+  return {
+    events: [],
+    config: null,
+    initialize(config) {
+      this.config = config;
+      return state;
+    },
+    enqueueEvent(event) {
+      this.events.push(event);
+      state.lastEventAt = Date.now();
+    },
+    flush() {
+      state.status = "healthy";
+    },
+    getStatus() {
+      return state;
+    },
+    setContext() {
+      return undefined;
+    },
+    activateProbeTriggerToken() {
+      return true;
+    }
+  };
+}
+
+export function installRecordingNativeModule(module: RecordingNativeModule = createRecordingNativeModule()): RecordingNativeModule {
+  setNativeModuleForTesting(module);
+  return module;
+}
+
+export function resetDebugBundleNativeModule(): void {
+  setNativeModuleForTesting(undefined);
+  resetNativeModuleCacheForTesting();
+}

package/src/types.ts

@@ -0,0 +1,173 @@
+export type DebugBundleStatus = "healthy" | "degraded" | "disconnected";
+
+export type DebugBundleLogLevel = "debug" | "info" | "warning" | "error" | "critical";
+
+export interface DebugBundleConfig {
+  projectToken?: string;
+  enabled?: boolean;
+  environment?: string;
+  service?: string;
+  endpoint?: string;
+  releaseChannel?: string;
+  appVersion?: string;
+  buildNumber?: string;
+  batchSize?: number;
+  flushInterval?: number;
+  sampleRate?: number;
+  sessionSampleRate?: number;
+  maxEventsPerSession?: number;
+  maxBreadcrumbs?: number;
+  captureErrors?: boolean;
+  captureUnhandledRejections?: boolean;
+  captureScreens?: boolean;
+  captureActions?: boolean;
+  captureNetwork?: boolean;
+  captureConsole?: boolean;
+  captureLogs?: boolean;
+  logLevel?: DebugBundleLogLevel;
+  tracePropagationTargets?: string[];
+  networkFilter?: DebugBundleNetworkFilter;
+  offlineQueueMaxEvents?: number;
+  offlineQueueMaxBytes?: number;
+  offlineQueueTtl?: number;
+  requestTimeout?: number;
+  maxProbeLabels?: number;
+  maxProbeEntriesPerLabel?: number;
+  probeFlushOnError?: boolean;
+  redactFields?: string[];
+  headerAllowlist?: string[];
+  sdkVersion?: string;
+}
+
+export interface ResolvedDebugBundleConfig {
+  projectToken: string;
+  enabled: boolean;
+  environment: string;
+  service: string;
+  endpoint: string;
+  releaseChannel: string;
+  appVersion: string | null;
+  buildNumber: string | null;
+  batchSize: number;
+  flushInterval: number;
+  sampleRate: number;
+  sessionSampleRate: number;
+  maxEventsPerSession: number;
+  maxBreadcrumbs: number;
+  captureErrors: boolean;
+  captureUnhandledRejections: boolean;
+  captureScreens: boolean;
+  captureActions: boolean;
+  captureNetwork: boolean;
+  captureConsole: boolean;
+  captureLogs: boolean;
+  logLevel: DebugBundleLogLevel;
+  tracePropagationTargets: string[];
+  networkFilter: DebugBundleNetworkFilter;
+  offlineQueueMaxEvents: number;
+  offlineQueueMaxBytes: number;
+  offlineQueueTtl: number;
+  requestTimeout: number;
+  maxProbeLabels: number;
+  maxProbeEntriesPerLabel: number;
+  probeFlushOnError: boolean;
+  redactFields: string[];
+  headerAllowlist: string[];
+  sdkVersion: string;
+}
+
+export interface DebugBundleNetworkFilter {
+  urlAllowlist?: string[];
+  urlDenylist?: string[];
+  statusCodes?: number[];
+  minResponseTime?: number;
+}
+
+export interface DebugBundleRequestInfo {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  routeTemplate?: string;
+  traceId?: string;
+}
+
+export interface DebugBundleResponseInfo {
+  statusCode: number;
+  durationMillis?: number;
+  headers?: Record<string, string>;
+}
+
+export interface DebugBundleCaptureContext {
+  [key: string]: unknown;
+}
+
+export interface DebugBundleProbeOptions {
+  heavy?: boolean;
+}
+
+export interface DebugBundleEventEnvelope {
+  schema_version: "1";
+  event_id: string;
+  event_type:
+    | "frontend_exception"
+    | "frontend_breadcrumb"
+    | "log_event"
+    | "request_event"
+    | "error_suppressed"
+    | "probe_event";
+  sdk_name: "@debugbundle/sdk-react-native";
+  sdk_version: string;
+  service: {
+    name: string;
+    environment: string;
+    runtime: "react-native";
+    framework: "react-native";
+  };
+  occurred_at: string;
+  correlation: {
+    trace_id: string | null;
+    request_id?: string | null;
+    session_id?: string | null;
+    user_id_hash?: string | null;
+  } | null;
+  payload: Record<string, unknown>;
+  device: Record<string, unknown> | null;
+}
+
+export interface DebugBundleClient {
+  readonly status: DebugBundleStatus;
+  readonly lastEventAt: number | null;
+  init(config: DebugBundleConfig): void;
+  captureException(error: unknown, context?: DebugBundleCaptureContext): void;
+  captureError(error: unknown, context?: DebugBundleCaptureContext): void;
+  captureLog(message: string, level?: DebugBundleLogLevel, context?: DebugBundleCaptureContext): void;
+  captureRequest(
+    request: DebugBundleRequestInfo,
+    response: DebugBundleResponseInfo,
+    context?: DebugBundleCaptureContext
+  ): void;
+  captureMessage(message: string, level?: DebugBundleLogLevel, context?: DebugBundleCaptureContext): void;
+  setContext(key: string, value: unknown): void;
+  probe(label: string, data: unknown | (() => unknown), options?: DebugBundleProbeOptions): void;
+  flush(): Promise<void>;
+  activateProbeTriggerToken(token: string): Promise<boolean>;
+  recordBreadcrumb(type: string, data?: Record<string, unknown>): void;
+  recordScreen(screenName: string, previousScreen?: string | null, source?: string): void;
+}
+
+export interface NativeDebugBundleModule {
+  initialize(config: ResolvedDebugBundleConfig): Promise<NativeDebugBundleState> | NativeDebugBundleState;
+  enqueueEvent(event: DebugBundleEventEnvelope): Promise<void> | void;
+  flush(): Promise<void> | void;
+  getStatus(): Promise<NativeDebugBundleState> | NativeDebugBundleState;
+  setContext?(key: string, value: unknown): Promise<void> | void;
+  activateProbeTriggerToken?(token: string): Promise<boolean> | boolean;
+}
+
+export interface NativeDebugBundleState {
+  status: DebugBundleStatus;
+  lastEventAt?: number | null;
+  device?: Record<string, unknown> | null;
+  nativeModuleAvailable?: boolean;
+  degradedReason?: string | null;
+}