@hanzo/event 0.3.1 → 0.3.3

package/dist/react.mjs

@@ -70,6 +70,284 @@ function hasAttribution(a) {
 // src/events.ts
 var PAGEVIEW = "$pageview";
 
+// src/scrub.ts
+var REDACTED = "[redacted]";
+var EMAIL_MARK = "[email]";
+var IP_MARK = "[ip]";
+var SECRET_PATTERNS = [
+  /-----BEGIN[ A-Z]*PRIVATE KEY-----[\s\S]*?-----END[ A-Z]*PRIVATE KEY-----/g,
+  /eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}/g,
+  // JWT
+  /\bbearer\s+[A-Za-z0-9._~+/-]{12,}=*/gi,
+  // bearer token
+  /\b(?:sk|pk|rk)-[A-Za-z0-9]{2,}-?[A-Za-z0-9]{12,}/g,
+  // openai-style
+  /\b(?:sk|pk)_(?:live|test)_[A-Za-z0-9]{16,}/g,
+  // stripe
+  /\bhk-[A-Za-z0-9]{16,}/g,
+  // hanzo key
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  // aws access key id
+  /\bASIA[0-9A-Z]{16}\b/g,
+  // aws sts key id
+  /\bAIza[0-9A-Za-z_-]{20,}/g,
+  // google api key
+  /\bgh[posru]_[A-Za-z0-9]{20,}/g,
+  // github token
+  /\bxox[baprs]-[A-Za-z0-9-]{10,}/g,
+  // slack token
+  // Creds in a URL/DSN. The repetition is BOUNDED on purpose: the unbounded form
+  // ([^\s:@/]+:[^\s@/]+@) backtracks quadratically on colon-rich text with no
+  // terminating '@' — an HTML error page pasted into an error message took 4.9s
+  // at 32KB and >60s at 128KB, freezing the main thread from inside captureError.
+  // Real userinfo is far below these caps, so bounding costs nothing.
+  /[a-zA-Z][a-zA-Z0-9+.-]{0,32}:\/\/[^\s:@/]{1,256}:[^\s@/]{1,256}@/g
+];
+var RE_PAN = /\b(?:\d[ -]?){13,19}\b/g;
+function luhn(digits) {
+  let sum = 0;
+  let alt = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = digits.charCodeAt(i) - 48;
+    if (alt) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    alt = !alt;
+  }
+  return sum % 10 === 0;
+}
+function redactPAN(s) {
+  return s.replace(RE_PAN, (m) => {
+    const digits = m.replace(/[ -]/g, "");
+    if (digits.length < 13 || digits.length > 19) return m;
+    return luhn(digits) ? REDACTED : m;
+  });
+}
+var RE_EMAIL = /[A-Za-z0-9._%+-]{1,64}@[A-Za-z0-9.-]{1,255}\.[A-Za-z]{2,24}/g;
+var RE_IPV4 = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
+var RE_IPV6 = /\b(?:[0-9A-Fa-f]{1,4}:){2,7}[0-9A-Fa-f]{1,4}\b/g;
+function redactSecrets(s) {
+  for (const re of SECRET_PATTERNS) s = s.replace(re, REDACTED);
+  return redactPAN(s);
+}
+function scrubPII(s) {
+  s = s.replace(RE_EMAIL, EMAIL_MARK);
+  s = s.replace(RE_IPV6, IP_MARK);
+  s = s.replace(RE_IPV4, IP_MARK);
+  return s;
+}
+var MAX_SCRUB_LEN = 8192;
+function truncate(s, max = MAX_SCRUB_LEN) {
+  return s.length > max ? s.slice(0, max) + "\u2026 [truncated]" : s;
+}
+function scrubText(s, capturePII = false) {
+  if (!s) return s ?? "";
+  s = truncate(s);
+  s = redactSecrets(s);
+  if (!capturePII) s = scrubPII(s);
+  return s;
+}
+
+// src/version.ts
+var VERSION = "0.3.3";
+
+// src/sentry.ts
+var MAX_FRAMES = 50;
+var MAX_LINES = 500;
+var MAX_LINE_LEN = 2048;
+var MAX_TAG_LEN = 1024;
+var MAX_TAGS = 50;
+function eventId() {
+  const c = typeof crypto !== "undefined" ? crypto : void 0;
+  if (c && "randomUUID" in c) return c.randomUUID().replace(/-/g, "");
+  let s = "";
+  for (let i = 0; i < 32; i++) s += Math.floor(Math.random() * 16).toString(16);
+  return s;
+}
+function byteLen(s) {
+  if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(s).length;
+  if (typeof Buffer !== "undefined") return Buffer.byteLength(s, "utf8");
+  return s.length;
+}
+function parseDsn(dsn) {
+  if (!dsn) return null;
+  const m = /^(https?):\/\/([^@]+)@([^/]+)(\/.*)?$/.exec(dsn.trim());
+  if (!m) return null;
+  const scheme = m[1];
+  const publicKey = m[2];
+  const host = m[3];
+  const path = m[4] ?? "";
+  if (!publicKey || !host) return null;
+  const segs = path.split("/").filter(Boolean);
+  const projectId = segs.length > 0 ? segs[segs.length - 1] : "";
+  if (!projectId) return null;
+  const origin = `${scheme}://${host}`;
+  const ingestUrl = `${origin}/v1/sentry/${encodeURIComponent(projectId)}/envelope/?sentry_key=${encodeURIComponent(publicKey)}`;
+  return { publicKey, origin, projectId, ingestUrl };
+}
+var V8_FRAME = /^\s*at\s+(?:(.+?)\s+\()?(?:(.+?):(\d+):(\d+)|([^)]+))\)?\s*$/;
+var MOZ_FRAME = /^\s*(?:(.*?)@)?(.+?):(\d+):(\d+)\s*$/;
+function inApp(file) {
+  if (!file) return false;
+  return !(file.includes("node_modules") || file.startsWith("webpack-internal") || file.startsWith("webpack://") || file.startsWith("chrome-extension://") || file.startsWith("moz-extension://"));
+}
+function framesFromStack(stack) {
+  if (!stack) return [];
+  const lines = stack.split("\n", MAX_LINES);
+  const frames = [];
+  for (const raw of lines) {
+    if (raw.length > MAX_LINE_LEN) continue;
+    const line = raw.trimEnd();
+    if (!line) continue;
+    let fn;
+    let file = "";
+    let lineno = 0;
+    let colno = 0;
+    const v = V8_FRAME.exec(line);
+    if (v) {
+      fn = v[1];
+      if (v[2]) {
+        file = v[2];
+        lineno = Number(v[3]) || 0;
+        colno = Number(v[4]) || 0;
+      } else {
+        file = (v[5] || "").trim();
+      }
+    } else {
+      const f = MOZ_FRAME.exec(line);
+      if (!f) continue;
+      fn = f[1];
+      file = f[2];
+      lineno = Number(f[3]) || 0;
+      colno = Number(f[4]) || 0;
+    }
+    if (!file && !fn) continue;
+    frames.push({
+      function: fn || "<anonymous>",
+      filename: file,
+      abs_path: file,
+      lineno,
+      colno,
+      in_app: inApp(file)
+    });
+  }
+  frames.reverse();
+  if (frames.length > MAX_FRAMES) return frames.slice(frames.length - MAX_FRAMES);
+  return frames;
+}
+function normalizeError(err) {
+  if (err instanceof Error) {
+    const name = read(err, "name");
+    const message = read(err, "message");
+    const stack = read(err, "stack");
+    return {
+      name: typeof name === "string" && name ? name : "Error",
+      message: typeof message === "string" && message ? message : str(err),
+      stack: typeof stack === "string" ? stack : void 0
+    };
+  }
+  if (typeof err === "string") return { name: "Error", message: err };
+  try {
+    return { name: "Error", message: JSON.stringify(err) ?? str(err) };
+  } catch {
+    return { name: "Error", message: str(err) };
+  }
+}
+function read(o, k) {
+  try {
+    return o[k];
+  } catch {
+    return void 0;
+  }
+}
+function str(v) {
+  try {
+    return String(v);
+  } catch {
+    return "[unstringifiable]";
+  }
+}
+function coerceTag(v) {
+  const s = typeof v === "string" ? v : (() => {
+    try {
+      return JSON.stringify(v) ?? String(v);
+    } catch {
+      try {
+        return String(v);
+      } catch {
+        return "[unstringifiable]";
+      }
+    }
+  })();
+  return s.length > MAX_TAG_LEN ? s.slice(0, MAX_TAG_LEN) : s;
+}
+function buildSentryEvent(input) {
+  const { error, options = {}, identity, capturePII = false } = input;
+  const norm = normalizeError(error);
+  const handled = options.handled !== false;
+  const level = options.level ?? (handled ? "error" : "fatal");
+  const tags = { handled: String(handled) };
+  if (identity.product) tags.product = identity.product;
+  if (identity.sessionId) tags.session = identity.sessionId;
+  try {
+    const props = options.properties ?? {};
+    let n = 0;
+    for (const k of Object.keys(props)) {
+      if (n >= MAX_TAGS) break;
+      try {
+        const val = props[k];
+        if (val === void 0 || val === null) continue;
+        tags[k] = scrubText(coerceTag(val), capturePII);
+        n++;
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  const event = {
+    event_id: input.id ?? eventId(),
+    timestamp: (input.now ?? Date.now()) / 1e3,
+    platform: "javascript",
+    level,
+    logger: identity.product,
+    environment: identity.environment,
+    release: identity.release,
+    exception: {
+      values: [
+        {
+          type: norm.name,
+          value: scrubText(norm.message, capturePII),
+          stacktrace: { frames: framesFromStack(norm.stack) }
+        }
+      ]
+    },
+    tags,
+    sdk: { name: "@hanzo/event", version: VERSION }
+  };
+  if (identity.userId) event.user = { id: identity.userId };
+  return event;
+}
+function buildEnvelope(event, dsn, sentAt) {
+  const payload = JSON.stringify(event);
+  const header = JSON.stringify({
+    event_id: event.event_id,
+    dsn: `${dsn.origin}/v1/sentry/${dsn.projectId}`,
+    sent_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const itemHeader = JSON.stringify({
+    type: "event",
+    content_type: "application/json",
+    length: byteLen(payload)
+  });
+  return `${header}
+${itemHeader}
+${payload}
+`;
+}
+
 // src/storage.ts
 var KEY = {
   anon: "hz_anon_id",
@@ -158,9 +436,25 @@ function mergeCohort(patch) {
 }
 
 // src/core.ts
-var VERSION = "0.3.0";
 var EVENT_PATH = "/v1/event";
 var DEFAULT_HOST = "https://api.hanzo.ai";
+var ENVELOPE_CONTENT_TYPE = "application/x-sentry-envelope";
+function readEnvDsn() {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      return process.env.NEXT_PUBLIC_HANZO_EVENT_DSN || process.env.HANZO_EVENT_DSN || void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function readEnv(name) {
+  try {
+    if (typeof process !== "undefined" && process.env) return process.env[name] || void 0;
+  } catch {
+  }
+  return void 0;
+}
 function appendQuery(url, key, value) {
   return url + (url.includes("?") ? "&" : "?") + key + "=" + encodeURIComponent(value);
 }
@@ -169,30 +463,42 @@ function uid2() {
   if (c && "randomUUID" in c) return c.randomUUID();
   return "m-" + Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
 }
-function normalizeError(err) {
-  if (err instanceof Error) {
-    return { type: err.name, message: err.message, stack: err.stack };
-  }
-  if (typeof err === "string") return { message: err };
+function normalizeError2(err) {
+  const n = normalizeError(err);
+  return { type: n.name, message: n.message, stack: n.stack };
+}
+var isBrowser = () => typeof window !== "undefined";
+function serializeBatch(batch) {
   try {
-    return { message: JSON.stringify(err) };
+    return JSON.stringify({ batch });
   } catch {
-    return { message: String(err) };
   }
+  const parts = [];
+  for (const e of batch) {
+    try {
+      parts.push(JSON.stringify(e));
+    } catch {
+      try {
+        parts.push(JSON.stringify({ ...e, properties: { $unserializable: true } }));
+      } catch {
+      }
+    }
+  }
+  return parts.length > 0 ? '{"batch":[' + parts.join(",") + "]}" : null;
 }
-var isBrowser = () => typeof window !== "undefined";
 var DefaultTransport = class {
   send(url, body, opts) {
+    const contentType = opts.contentType ?? "application/json";
     if (opts.beacon && isBrowser() && typeof navigator.sendBeacon === "function") {
       const beaconUrl = opts.ingestKey ? appendQuery(url, "ingest_key", opts.ingestKey) : url;
       try {
-        navigator.sendBeacon(beaconUrl, new Blob([body], { type: "application/json" }));
+        navigator.sendBeacon(beaconUrl, new Blob([body], { type: contentType }));
         return;
       } catch {
       }
     }
     if (typeof fetch !== "function") return;
-    const headers = { "Content-Type": "application/json" };
+    const headers = { "Content-Type": contentType };
     const bearer = opts.ingestKey ?? opts.token;
     if (bearer) headers.Authorization = `Bearer ${bearer}`;
     void fetch(url, {
@@ -201,7 +507,12 @@ var DefaultTransport = class {
       body,
       keepalive: true,
       credentials: "include"
-    }).catch(() => {
+    }).then((res) => {
+      if (!res.ok && opts.debug) {
+        console.warn("[event] ingest rejected", res.status, url.split("?")[0]);
+      }
+    }).catch((e) => {
+      if (opts.debug) console.warn("[event] ingest failed", url.split("?")[0], e);
     });
   }
 };
@@ -212,6 +523,8 @@ var Analytics = class {
     this.attribution = { utm: {} };
     this.cohort = {};
     this.started = false;
+    /** Guards against an error thrown *inside* the error path re-entering it. */
+    this.reentrant = false;
     /** track is an alias of capture (Segment familiarity). */
     this.track = this.capture.bind(this);
     /** captureException — @sentry-familiar alias of captureError. */
@@ -225,6 +538,19 @@ var Analytics = class {
       ...config
     };
     this.transport = config.transport ?? new DefaultTransport();
+    this.dsn = parseDsn(config.dsn ?? readEnvDsn());
+  }
+  /** errorPlaneEnabled reports whether captured exceptions can actually reach the
+   *  error host. False means a DSN was never configured — the documented
+   *  fail-safe. Exposed so an app (or a test) can assert its wiring instead of
+   *  discovering months later that nothing was ever reported. */
+  get errorPlaneEnabled() {
+    return this.dsn !== null;
+  }
+  /** errorIngestUrl is the fully-derived envelope endpoint, or undefined when the
+   *  plane is inert. Diagnostics only. */
+  get errorIngestUrl() {
+    return this.dsn?.ingestUrl;
   }
   /** init is idempotent and browser-only for its side effects: capture first-touch
    *  attribution, hydrate cohort, register the unload flush, and (unless opted out)
@@ -275,18 +601,38 @@ var Analytics = class {
   capture(event, properties, commerce) {
     this.enqueue("event", event, { properties, ...commerce });
   }
-  /** captureError records an exception as a first-class error event — the ONE
-   *  error path (subsumes @sentry). A caught error, an unhandled rejection, a
-   *  React render error, or a manual report all become a type:'error' event on the
-   *  same stream; Cloud folds the exception into properties.$exception and stamps
-   *  event_type='error', so it surfaces in the error-tracking lens. Never throws
-   *  back into the app; errors are higher-signal than pageviews, so it flushes
-   *  promptly (a crash may unload the page moments later). */
+  /** captureError reports a caught error, an unhandled rejection, a React render
+   *  error, or a manual report to BOTH planes, from one call:
+   *
+   *    - the ERROR PLANE — a real Sentry envelope to the DSN host. This is the one
+   *      that produces an issue in sentry.hanzo.ai (grouping, stack frames, AST).
+   *      Inert when no DSN is configured.
+   *    - the EVENT STREAM — a `type:'error'` row in the cloud event warehouse, so
+   *      an error stays correlated with the session's pageviews for product
+   *      analysis (readable via GET /v1/errors).
+   *
+   *  Both carry the SAME session and subject id, so an error and the pageview
+   *  before it join up. Never throws back into the app; errors are higher-signal
+   *  than pageviews, so both planes flush promptly (a crash may unload the page
+   *  moments later). */
   captureError(err, context) {
-    const ex = normalizeError(err);
-    ex.handled = context?.handled ?? true;
-    this.enqueue("error", ex.message, { error: ex, properties: context?.properties });
-    this.flush();
+    if (this.reentrant) return;
+    this.reentrant = true;
+    try {
+      try {
+        this.sendError(err, context);
+      } catch {
+      }
+      try {
+        const ex = normalizeError2(err);
+        ex.handled = context?.handled ?? true;
+        this.enqueue("error", ex.message, { error: ex, properties: context?.properties });
+        this.flush();
+      } catch {
+      }
+    } finally {
+      this.reentrant = false;
+    }
   }
   /** setCohort persists cohort dimensions (e.g. signupWeek at signup) so they ride
    *  every subsequent event. */
@@ -312,11 +658,53 @@ var Analytics = class {
     const key = this.cfg.ingestKey?.trim() || void 0;
     const token = key ? void 0 : this.cfg.getToken?.() ?? void 0;
     const useBeacon = beacon && !token;
-    const body = JSON.stringify({ batch });
+    const body = serializeBatch(batch);
+    if (body === null) {
+      if (this.cfg.debug) console.debug("[event] flush \u2192 dropped, batch unserializable");
+      return;
+    }
     if (this.cfg.debug) console.debug("[event] flush \u2192", EVENT_PATH, batch.length);
-    this.transport.send(this.cfg.host + EVENT_PATH, body, { beacon: useBeacon, token, ingestKey: key });
+    this.transport.send(this.cfg.host + EVENT_PATH, body, {
+      beacon: useBeacon,
+      token,
+      ingestKey: key,
+      debug: this.cfg.debug
+    });
   }
   // ── internals ────────────────────────────────────────────────────────────
+  /** sendError frames one exception as a Sentry envelope and posts it to the DSN's
+   *  ingest URL. The DSN's own key rides ?sentry_key= (the credential channel the
+   *  server trusts, and the only one a headerless beacon can carry), so NO bearer
+   *  or publishable key is attached here — the two planes authenticate
+   *  independently. Errors are sent one envelope per event, immediately: batching
+   *  a crash report is how you lose it. */
+  sendError(err, options) {
+    if (!this.cfg.enabled || !this.dsn) return;
+    const event = buildSentryEvent({
+      error: err,
+      options,
+      identity: this.errorIdentity(),
+      capturePII: this.cfg.capturePII ?? false
+    });
+    const body = buildEnvelope(event, this.dsn);
+    if (this.cfg.debug) console.debug("[event] error \u2192", this.dsn.ingestUrl, event.event_id);
+    this.transport.send(this.dsn.ingestUrl, body, {
+      beacon: false,
+      contentType: ENVELOPE_CONTENT_TYPE,
+      debug: this.cfg.debug
+    });
+  }
+  /** errorIdentity is the SAME identity the event stream stamps — the OIDC subject
+   *  once identify() has run, else the anon id. Never email/PII. */
+  errorIdentity() {
+    return {
+      userId: this.personId ?? anonId(),
+      sessionId: sessionId(),
+      product: this.cfg.product,
+      release: this.cfg.release ?? readEnv("NEXT_PUBLIC_HANZO_RELEASE"),
+      environment: this.cfg.environment ?? readEnv("NODE_ENV")
+    };
+  }
   enqueue(kind, event, extra) {
     if (!this.cfg.enabled) return;
     if (!this.started) this.init();