@hanzo/event 0.3.19 → 0.3.21

package/dist/react.mjs

@@ -76,19 +76,16 @@ var PRODUCT_PROJECT = Object.freeze({
   site: "019f9b1e-5785-7359-ad0b-f75db8e58c99"
   // hanzo.ai (marketing; product `site`)
 });
-function dsnForProduct(product) {
-  if (!product) return void 0;
+function dsnForProduct(product, key) {
+  if (!product || !key) return void 0;
   const projectId = PRODUCT_PROJECT[product];
   if (!projectId) return void 0;
-  return `https://${HANZO_PUBLISHABLE_KEY}@api.hanzo.ai/v1/sentry/${projectId}`;
-}
-var HANZO_PUBLISHABLE_KEY = "pk-live-c88649f1085fb6ad441d8a0072933a9b";
-function defaultPublishableKey(host) {
-  return host === void 0 || host === "https://api.hanzo.ai" ? HANZO_PUBLISHABLE_KEY : void 0;
+  return `https://${key}@api.hanzo.ai/v1/sentry/${projectId}`;
 }
 
 // src/events.ts
 var PAGEVIEW = "$pageview";
+var EXCEPTION = "$exception";
 
 // src/scrub.ts
 var REDACTED = "[redacted]";
@@ -313,7 +310,7 @@ function hzAnonId() {
 }
 
 // src/version.ts
-var VERSION = "0.3.19";
+var VERSION = "0.3.21";
 
 // src/sentry.ts
 var MAX_FRAMES = 50;
@@ -505,6 +502,94 @@ ${itemHeader}
 ${payload}
 `;
 }
+var MAX_VALUE = 4096;
+function digest(s) {
+  let out = "";
+  for (const seed of [2166136261, 16777619, 2654435769, 2246822507]) {
+    let h = seed >>> 0;
+    for (let i = 0; i < s.length; i++) {
+      h ^= s.charCodeAt(i);
+      h = h + (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24) >>> 0;
+    }
+    out += h.toString(16).padStart(8, "0");
+  }
+  return out;
+}
+function frameOf(f) {
+  const source = f.filename ?? "";
+  const name = f.function ?? "<anonymous>";
+  const line = f.lineno ?? 0;
+  const column = f.colno ?? 0;
+  return {
+    // Stable per code location, so the same frame groups and re-renders under one
+    // key. The '/part' suffix is the product's format for one raw frame expanding
+    // into several resolved ones; a browser frame is always part 0.
+    raw_id: `${digest(`${source}|${name}|${line}|${column}`)}/0`,
+    mangled_name: name,
+    source,
+    line,
+    column,
+    in_app: f.in_app ?? false,
+    lang: "javascript",
+    resolved: false,
+    resolve_failure: "no symbol set uploaded for this release",
+    resolved_name: null,
+    module: null
+  };
+}
+function truncate2(s, max) {
+  if (s.length <= max) return s;
+  let end = max;
+  const c = s.charCodeAt(end - 1);
+  if (c >= 55296 && c <= 56319) end--;
+  return s.slice(0, end);
+}
+function exceptionEntry(err, opts) {
+  const n = normalizeError(err);
+  const frames = framesFromStack(n.stack).slice(-50);
+  const entry = {
+    id: opts.id,
+    type: n.name,
+    value: truncate2(n.message, MAX_VALUE),
+    mechanism: {
+      type: "generic",
+      handled: opts.handled,
+      // An exception the app reported by hand was constructed, not thrown by the
+      // runtime at a real call site.
+      synthetic: !(err instanceof Error)
+    }
+  };
+  if (frames.length > 0) {
+    entry.stacktrace = { type: "resolved", frames: frames.map(frameOf) };
+  }
+  return entry;
+}
+function fingerprint(entry) {
+  const frames = entry.stacktrace?.frames ?? [];
+  const pieces = frames.filter((f) => f.in_app).map((f) => `${f.mangled_name}@${f.source}`);
+  return digest([entry.type, ...pieces].join("\n"));
+}
+function exceptionProperties(err, opts) {
+  const entry = exceptionEntry(err, opts);
+  const frames = entry.stacktrace?.frames ?? [];
+  const fp = fingerprint(entry);
+  return {
+    $exception_list: [entry],
+    $exception_fingerprint: fp,
+    // Records WHY this fingerprint holds. 'manual' is the honest value: the client
+    // supplied the key rather than a server grouper deriving one.
+    $exception_fingerprint_record: [{ type: "manual" }],
+    $exception_type: entry.type,
+    $exception_message: entry.value,
+    $exception_level: opts.level ?? "error",
+    $exception_handled: opts.handled,
+    $exception_synthetic: entry.mechanism?.synthetic ?? false,
+    $exception_types: [entry.type],
+    $exception_values: [entry.value],
+    $exception_sources: frames.map((f) => f.source).filter((s) => !!s),
+    $exception_functions: frames.map((f) => f.resolved_name ?? f.mangled_name).filter((s) => !!s)
+  };
+}
 
 // src/storage.ts
 var KEY = {
@@ -676,27 +761,24 @@ var Analytics = class {
       enabled: true,
       captureErrors: true,
       ...config,
-      // The publishable key resolves the SAME way the DSN below does, and now
-      // ends the SAME way too — in a baked default, so declaring nothing is
-      // enough. Most specific first:
+      // The publishable key resolves from ONE live source, never a literal baked
+      // beside the code. Most specific first:
       //   1. an explicit `ingestKey` in config;
       //   2. NEXT_PUBLIC_PUBLISHABLE_KEY, the inlined build-time env the fleet
-      //      carries end to end (KMS `deploy/PUBLISHABLE_KEY` -> the PUBLISHABLE_KEY
-      //      build-arg -> the NEXT_PUBLIC_ prefix Next inlines);
-      //   3. the hanzo org key baked in `dsn.ts`, on the hanzo cloud only.
+      //      carries end to end — KMS `deploy/PUBLISHABLE_KEY` -> the PUBLISHABLE_KEY
+      //      build-arg -> the NEXT_PUBLIC_ prefix Next inlines.
       //
-      // (3) is why this is `publishable_key for all`: a hanzo surface that passes
-      // no key in code and inlines no env still emits attributed, exactly as
-      // declaring `product` is enough for the DSN. Without it that surface sent
-      // its beacons to `$public` — which drops every track/identify/group and
-      // still answers 200 — silent in the page and invisible until you read the
-      // warehouse and find the host missing entirely. A white-label surface on
-      // its own cloud (a non-default host) gets no default, so the org this
-      // attributes to is never the wrong one.
-      ingestKey: config.ingestKey ?? readEnv("NEXT_PUBLIC_PUBLISHABLE_KEY") ?? defaultPublishableKey(config.host ?? DEFAULT_HOST)
+      // A surface that provides neither has no key, and its anonymous traffic
+      // files under `$public` (which drops track/identify/group and answers 200);
+      // the fix is to give it the KMS-sourced env, not to hardcode the org key
+      // here. The key is a credential-class value: its home is KMS, and the ONE
+      // build reads it from there.
+      ingestKey: config.ingestKey ?? readEnv("NEXT_PUBLIC_PUBLISHABLE_KEY")
     };
     this.transport = config.transport ?? new DefaultTransport();
-    this.dsn = parseDsn(config.dsn ?? readEnvDsn() ?? dsnForProduct(this.cfg.product));
+    this.dsn = parseDsn(
+      config.dsn ?? readEnvDsn() ?? dsnForProduct(this.cfg.product, this.cfg.ingestKey)
+    );
   }
   /** errorPlaneEnabled reports whether captured exceptions can actually reach the
    *  error host. False means a DSN was never configured — the documented
@@ -781,9 +863,20 @@ var Analytics = class {
       } catch {
       }
       try {
+        const handled = context?.handled ?? true;
         const ex = normalizeError2(err);
-        ex.handled = context?.handled ?? true;
-        this.enqueue("error", ex.message, { error: ex, properties: context?.properties });
+        ex.handled = handled;
+        this.enqueue("event", EXCEPTION, {
+          error: ex,
+          properties: {
+            ...context?.properties,
+            ...exceptionProperties(err, {
+              handled,
+              id: hzUuidv7(),
+              level: context?.level
+            })
+          }
+        });
         this.flush();
       } catch {
       }