@reproapp/node-sdk 0.0.3 → 0.0.5

package/src/ingest/client.ts

@@ -0,0 +1,194 @@
+import { mapLegacyEntriesToCanonicalEvents } from './mapper';
+import type { IngestClientConfig, LegacyEntry } from './types';
+
+const DEFAULT_INGEST_BASE = 'http://localhost:8080';
+const DEFAULT_INGEST_PATH = '/v1/ingest/events';
+const DEFAULT_QUEUE_MAX_ITEMS = 1000;
+const DEFAULT_QUEUE_MAX_ATTEMPTS = 5;
+const DEFAULT_QUEUE_BACKOFF_MAX_MS = 4000;
+const DEFAULT_DEFER_DRAIN_MS = 25;
+
+type QueuedIngestBatch = {
+    config: IngestClientConfig;
+    sessionId: string;
+    entries: LegacyEntry[];
+    attempts: number;
+};
+
+const ingestQueue: QueuedIngestBatch[] = [];
+let drainTimer: ReturnType<typeof setTimeout> | null = null;
+let draining = false;
+let backoffMs = 0;
+let shouldDeferDrain: (() => boolean) | null = null;
+let deferDrainMs = DEFAULT_DEFER_DRAIN_MS;
+
+export const configureIngestQueueDrain = (options: {
+    shouldDefer?: (() => boolean) | null;
+    deferMs?: number;
+}): void => {
+    shouldDeferDrain = options.shouldDefer ?? null;
+    if (Number.isFinite(options.deferMs) && Number(options.deferMs) >= 0) {
+        deferDrainMs = Number(options.deferMs);
+    }
+};
+
+export const kickIngestQueueDrain = (): void => {
+    if (ingestQueue.length > 0 && !drainTimer) {
+        scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+    }
+};
+
+const resolveIngestUrl = (config: IngestClientConfig): string => {
+    const envBase = typeof process !== 'undefined' ? (process as any)?.env?.REPRO_INGEST_BASE : undefined;
+    const ingestBase = String(envBase || config.ingestBase || DEFAULT_INGEST_BASE).replace(/\/+$/, '');
+    const ingestPath = config.ingestPath || DEFAULT_INGEST_PATH;
+    const normalizedPath = ingestPath.startsWith('/') ? ingestPath : `/${ingestPath}`;
+    return `${ingestBase}${normalizedPath}`;
+};
+
+const toHeaders = (config: IngestClientConfig): Record<string, string> => {
+    const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        'X-App-Id': config.appId,
+    };
+
+    if (config.appSecret) {
+        headers['X-App-Secret'] = config.appSecret;
+    }
+
+    if (config.appName) {
+        headers['X-App-Name'] = config.appName;
+    }
+
+    return headers;
+};
+
+export const postIngestEntries = async (
+    config: IngestClientConfig,
+    sessionId: string,
+    entries: LegacyEntry[],
+): Promise<void> => {
+    await sendIngestEntries(config, sessionId, entries);
+};
+
+const sendIngestEntries = async (
+    config: IngestClientConfig,
+    sessionId: string,
+    entries: LegacyEntry[],
+): Promise<boolean> => {
+    if (!sessionId || !Array.isArray(entries) || entries.length === 0) {
+        return true;
+    }
+
+    const events = mapLegacyEntriesToCanonicalEvents(config, sessionId, entries);
+    if (!events.length) {
+        return true;
+    }
+
+    try {
+        const response = await fetch(resolveIngestUrl(config), {
+            method: 'POST',
+            headers: toHeaders(config),
+            body: JSON.stringify({ events }),
+        });
+        return response.ok;
+    } catch {
+        // swallow in SDK
+        return false;
+    }
+};
+
+const scheduleDrain = (delayMs = 0): void => {
+    if (drainTimer) {
+        return;
+    }
+    const nextDelay = shouldDeferDrain?.()
+        ? Math.max(delayMs, deferDrainMs)
+        : delayMs;
+    drainTimer = setTimeout(() => {
+        drainTimer = null;
+        if (shouldDeferDrain?.()) {
+            scheduleDrain(deferDrainMs);
+            return;
+        }
+        void drainIngestQueue();
+    }, nextDelay);
+    try {
+        (drainTimer as any).unref?.();
+    } catch {}
+};
+
+const drainIngestQueue = async (): Promise<void> => {
+    if (draining) {
+        return;
+    }
+    if (shouldDeferDrain?.()) {
+        scheduleDrain(deferDrainMs);
+        return;
+    }
+    draining = true;
+    try {
+        while (ingestQueue.length > 0) {
+            if (shouldDeferDrain?.()) {
+                scheduleDrain(deferDrainMs);
+                return;
+            }
+            const batch = ingestQueue[0];
+            const ok = await sendIngestEntries(batch.config, batch.sessionId, batch.entries);
+            if (ok) {
+                ingestQueue.shift();
+                backoffMs = 0;
+                continue;
+            }
+
+            batch.attempts += 1;
+            if (batch.attempts >= DEFAULT_QUEUE_MAX_ATTEMPTS) {
+                ingestQueue.shift();
+                backoffMs = 0;
+                continue;
+            }
+
+            backoffMs = Math.min(
+                DEFAULT_QUEUE_BACKOFF_MAX_MS,
+                backoffMs ? backoffMs * 2 : 250,
+            );
+            scheduleDrain(backoffMs);
+            return;
+        }
+    } finally {
+        draining = false;
+        if (ingestQueue.length > 0 && !drainTimer) {
+            scheduleDrain(backoffMs || deferDrainMs);
+        }
+    }
+};
+
+export const enqueueIngestEntries = (
+    config: IngestClientConfig,
+    sessionId: string,
+    entries: LegacyEntry[],
+): void => {
+    if (!sessionId || !Array.isArray(entries) || entries.length === 0) {
+        return;
+    }
+    ingestQueue.push({
+        config: { ...config },
+        sessionId,
+        entries: entries.slice(),
+        attempts: 0,
+    });
+    if (ingestQueue.length > DEFAULT_QUEUE_MAX_ITEMS) {
+        ingestQueue.splice(0, ingestQueue.length - DEFAULT_QUEUE_MAX_ITEMS);
+    }
+    scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+};
+
+export const flushIngestQueue = async (): Promise<void> => {
+    if (drainTimer) {
+        clearTimeout(drainTimer);
+        drainTimer = null;
+    }
+    await drainIngestQueue();
+};
+
+export type { IngestClientConfig, LegacyEntry } from './types';

package/src/ingest/mapper.ts

@@ -0,0 +1,104 @@
+import type { CanonicalEvent, IngestClientConfig, LegacyEntry } from './types';
+
+const toIso = (timestamp: unknown): string => {
+  const numeric =
+    typeof timestamp === 'number' && Number.isFinite(timestamp) ? timestamp : Date.now();
+  return new Date(numeric).toISOString();
+};
+
+const inferEventType = (entry: LegacyEntry): string => {
+  if (entry.request !== undefined) return 'backend_request';
+  if (entry.db !== undefined) return 'db_change';
+  if (entry.trace !== undefined) return 'trace_batch';
+  if (entry.email !== undefined) return 'email_event';
+  return 'backend_event';
+};
+
+const toActorLabels = (config: IngestClientConfig): Record<string, string> | undefined => {
+  if (!config.actorLabels) return undefined;
+  const labels = Object.entries(config.actorLabels).reduce<Record<string, string>>(
+    (acc, [key, value]) => {
+      if (!key) return acc;
+      if (typeof value !== 'string') return acc;
+      acc[key] = value;
+      return acc;
+    },
+    {},
+  );
+  return Object.keys(labels).length ? labels : undefined;
+};
+
+const resolveServiceName = (config: IngestClientConfig): string | undefined => {
+  const candidate = config.serviceName ?? config.appName;
+  if (typeof candidate !== 'string') {
+    return undefined;
+  }
+  const normalized = candidate.trim();
+  return normalized.length ? normalized : undefined;
+};
+
+const toPayload = (entry: LegacyEntry): Record<string, unknown> => {
+  const payload: Record<string, unknown> = {
+    action_id: entry.actionId ?? null,
+  };
+
+  const normalizeFieldValue = (key: string, value: unknown): unknown => {
+    if (key !== 'trace' || typeof value !== 'string') {
+      return value;
+    }
+
+    try {
+      const parsed = JSON.parse(value) as unknown;
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  };
+
+  for (const [key, value] of Object.entries(entry)) {
+    if (key === 't' || key === 'actionId') continue;
+    payload[key] = normalizeFieldValue(key, value);
+  }
+
+  return payload;
+};
+
+export const mapLegacyEntriesToCanonicalEvents = (
+  config: IngestClientConfig,
+  sessionId: string,
+  entries: LegacyEntry[],
+): CanonicalEvent[] => {
+  const actorLabels = toActorLabels(config);
+  const actorId = config.actorId ?? config.appId;
+  const actorType = config.actorType ?? 'service';
+  const schemaVersion = config.schemaVersion ?? 1;
+  const serviceName = resolveServiceName(config);
+
+  return entries.map((entry) => {
+    const payload = toPayload(entry);
+    if (
+      serviceName &&
+      (typeof payload.serviceName !== 'string' || !String(payload.serviceName).trim().length)
+    ) {
+      payload.serviceName = serviceName;
+    }
+
+    const canonical: CanonicalEvent = {
+      schema_version: schemaVersion,
+      tenant_id: config.tenantId,
+      app_id: config.appId,
+      session_id: sessionId,
+      event_type: inferEventType(entry),
+      event_ts: toIso(entry.t),
+      actor_id: actorId,
+      actor_type: actorType,
+      payload,
+    };
+
+    if (actorLabels) {
+      canonical.actor_labels = actorLabels;
+    }
+
+    return canonical;
+  });
+};

package/src/ingest/types.ts

@@ -0,0 +1,42 @@
+export interface IngestClientConfig {
+    appId: string;
+    tenantId: string;
+    appSecret?: string;
+    appName?: string;
+    serviceName?: string;
+    ingestBase?: string;
+    ingestPath?: string;
+    actorId?: string;
+    actorType?: string;
+    actorLabels?: Record<string, string>;
+    source?: string;
+    schemaVersion?: number;
+}
+
+export interface LegacyEntry {
+    actionId?: string | null;
+    requestRid?: string | null;
+    request?: unknown;
+    requestValues?: unknown[];
+    db?: unknown;
+    dbValues?: unknown[];
+    trace?: unknown[];
+    traceBatch?: unknown;
+    traceValues?: unknown[];
+    email?: unknown;
+    t?: number;
+    [key: string]: unknown;
+}
+
+export interface CanonicalEvent {
+    schema_version: number;
+    tenant_id: string;
+    app_id: string;
+    session_id: string;
+    event_type: string;
+    event_ts: string;
+    actor_id: string;
+    actor_type: string;
+    actor_labels?: Record<string, string>;
+    payload: Record<string, unknown>;
+}

package/src/integrations/sendgrid.ts

@@ -1,5 +1,6 @@
 // repro-node/src/integrations/sendgrid.ts
 import { AsyncLocalStorage } from 'async_hooks';
+import { enqueueIngestEntries, type IngestClientConfig, type LegacyEntry } from '../ingest/client';
 
 type Ctx = { sid?: string; aid?: string };
 const als = new AsyncLocalStorage<Ctx>();
@@ -7,32 +8,18 @@ export const getCtx = () => als.getStore() || {};
 
 // If you already export als/getCtx from repro-node, reuse that instead of re-declaring.
 
-async function post(
-    cfg: { appId: string; appSecret: string; appName?: string; apiBase?: string },
+function post(
+    cfg: IngestClientConfig,
     sessionId: string,
     body: any,
 ) {
     try {
-        const envBase = typeof process !== 'undefined' ? (process as any)?.env?.REPRO_API_BASE : undefined;
-        const legacyBase = (cfg as any)?.apiBase;
-        const apiBase = String(envBase || legacyBase || 'https://repro-api-d7288.ondigitalocean.app/api').replace(/\/+$/, '');
-        await fetch(`${apiBase}/v1/sessions/${sessionId}/backend`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'X-App-Id': cfg.appId,
-                'X-App-Secret': cfg.appSecret,
-                ...(cfg.appName ? { 'X-App-Name': cfg.appName } : {}),
-            },
-            body: JSON.stringify(body),
-        });
+        const entries = Array.isArray(body?.entries) ? (body.entries as LegacyEntry[]) : [];
+        enqueueIngestEntries(cfg, sessionId, entries);
     } catch { /* swallow */ }
 }
 
-export type SendgridPatchConfig = {
-    appId: string;
-    appSecret: string;
-    appName?: string;
+export type SendgridPatchConfig = IngestClientConfig & {
     // Optional: provide a function to resolve sid/aid if AsyncLocalStorage is not set
     resolveContext?: () => { sid?: string; aid?: string } | undefined;
 };

package/src/privacy-fallback.ts

@@ -0,0 +1,25 @@
+const SANITIZED_TEXT_CACHE = new Map<string, string>();
+const SANITIZED_TEXT_CACHE_MAX = 500;
+
+export async function sanitizeUnknownBoundaryTextWithDetectors(value: string): Promise<string> {
+    if (!value) {
+        return value;
+    }
+    const cached = SANITIZED_TEXT_CACHE.get(value);
+    if (cached !== undefined) {
+        return cached;
+    }
+    rememberSanitizedText(value, value);
+    return value;
+}
+
+function rememberSanitizedText(input: string, output: string): void {
+    SANITIZED_TEXT_CACHE.set(input, output);
+    if (SANITIZED_TEXT_CACHE.size <= SANITIZED_TEXT_CACHE_MAX) {
+        return;
+    }
+    const oldestKey = SANITIZED_TEXT_CACHE.keys().next().value;
+    if (typeof oldestKey === 'string') {
+        SANITIZED_TEXT_CACHE.delete(oldestKey);
+    }
+}

package/src/privacy-redaction.ts

@@ -0,0 +1,37 @@
+import { createHash } from 'crypto';
+
+const EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+const EMAIL_TOKEN_PREFIX = 'email_tok_';
+const EMAIL_TOKEN_LENGTH = 12;
+
+export function redactEmailDeterministic(value: string): string {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    if (!normalized) {
+        return `${EMAIL_TOKEN_PREFIX}unknown`;
+    }
+    const token = createHash('sha256').update(normalized).digest('hex').slice(0, EMAIL_TOKEN_LENGTH);
+    return `${EMAIL_TOKEN_PREFIX}${token}`;
+}
+
+export function redactEmailsInText(value: string): string {
+    if (!value) {
+        return value;
+    }
+    return value.replace(EMAIL_PATTERN, (match) => isAlreadyMaskedEmail(match) ? match : redactEmailDeterministic(match));
+}
+
+export function collectEmailsInText(value: string): string[] {
+    if (!value) {
+        return [];
+    }
+    const matches = value.match(EMAIL_PATTERN);
+    return Array.isArray(matches) ? matches : [];
+}
+
+function isAlreadyMaskedEmail(value: string): boolean {
+    if (/^email_tok_[a-z0-9]+$/i.test(value)) {
+        return true;
+    }
+    const [local = '', domain = ''] = String(value).split('@');
+    return local.includes('...') || domain.includes('...');
+}