@glasstrace/sdk 1.5.0 → 1.6.0

package/dist/edge-entry.js

@@ -2,9 +2,9 @@ import {
   GlasstraceSpanProcessor,
   SdkError,
   captureCorrelationId
-} from "./chunk-Q42BY5BA.js";
+} from "./chunk-H57MQGNU.js";
 import "./chunk-DQ25VOKK.js";
-import "./chunk-4WI7B5FQ.js";
+import "./chunk-P45NZR4J.js";
 import "./chunk-NSBPE2FW.js";
 export {
   GlasstraceSpanProcessor,

package/dist/index.cjs

@@ -14639,6 +14639,26 @@ var init_dist = __esm({
       ERROR_CODE: "glasstrace.error.code",
       ERROR_CATEGORY: "glasstrace.error.category",
       ERROR_FIELD: "glasstrace.error.field",
+      // Error evidence v1 (SDK-041 / DISC-1535).
+      // Additive to the existing `glasstrace.error.*` family. Bounded
+      // stacktrace input for the product-side StackSummary parser
+      // (SCHEMA-033); plus framework-fallback markers so the original
+      // request path is preserved when Next.js (or another framework)
+      // rewrites the route to a fallback like `/_error` or `/_not-found`;
+      // plus a source-provenance enum so product can tell which surface
+      // emitted each error fact (`exception.message` event vs span attr
+      // vs response body vs framework runtime).
+      //
+      // Wire keys remain in `glasstrace.error.*` for namespace consistency
+      // with the Tier-1 `error.message` / `error.code` / `error.category`
+      // attributes already in this registry.
+      ERROR_STACK: "glasstrace.error.stack",
+      ERROR_STACK_TRUNCATED: "glasstrace.error.stack.truncated",
+      ERROR_STACK_REDACTED: "glasstrace.error.stack.redacted",
+      ERROR_SOURCE: "glasstrace.error.source",
+      ERROR_FRAMEWORK_KIND: "glasstrace.error.framework.kind",
+      ERROR_ORIGINAL_PATH: "glasstrace.error.original_path",
+      ERROR_FALLBACK_ROUTE: "glasstrace.error.fallback_route",
       ORM_PROVIDER: "glasstrace.orm.provider",
       ORM_MODEL: "glasstrace.orm.model",
       ORM_OPERATION: "glasstrace.orm.operation",
@@ -18520,6 +18540,119 @@ function prepareErrorResponseBody(body) {
   return truncateErrorResponseBody(sanitized);
 }
 
+// src/error-stack.ts
+var ERROR_STACK_MAX_BYTES = 8192;
+var ERROR_STACK_TRUNCATION_MARKER = "...[stack truncated]";
+var PATH_REDACTED = "<path>";
+var PATH_KEEP_MARKERS = [
+  "node_modules",
+  ".next",
+  ".glasstrace",
+  "src",
+  "dist",
+  "build",
+  "lib",
+  "app",
+  "pages"
+];
+var PATH_TOKEN_RE = /(?<=^|[\s(])(\/[^\s()<>]+|[A-Za-z]:\\[^\s()<>]+|file:\/\/\/[^\s()<>]+|webpack-internal:\/\/[^\s()<>]+|node:[^\s()<>]+)/g;
+var URL_QUERY_FRAGMENT_RE = /(\bhttps?:\/\/[^\s?#()<>]+)([?#][^\s()<>]*)/g;
+function normalizePathToken(token) {
+  let work = token;
+  if (work.startsWith("file:///")) {
+    work = work.slice("file://".length);
+  }
+  if (work.startsWith("webpack-internal:") || work.startsWith("node:")) {
+    return { token, changed: false };
+  }
+  const isPosixAbs = work.startsWith("/");
+  const isWinAbs = /^[A-Za-z]:\\/.test(work);
+  if (!isPosixAbs && !isWinAbs) {
+    return { token, changed: false };
+  }
+  const sep = isWinAbs ? "\\" : "/";
+  let bestIdx = -1;
+  for (const marker of PATH_KEEP_MARKERS) {
+    const needle = `${sep}${marker}${sep}`;
+    const idx = work.lastIndexOf(needle);
+    if (idx >= 0) {
+      bestIdx = idx;
+      break;
+    }
+  }
+  if (bestIdx >= 0) {
+    const kept = work.slice(bestIdx + sep.length);
+    const rebuilt2 = `${PATH_REDACTED}/${kept.replace(/\\/g, "/")}`;
+    return { token: rebuilt2, changed: true };
+  }
+  const colonLineRe = /:\d+(?::\d+)?$/;
+  const lineMatch = colonLineRe.exec(work);
+  const pathBody = lineMatch ? work.slice(0, lineMatch.index) : work;
+  const lineSuffix = lineMatch ? work.slice(lineMatch.index) : "";
+  const lastSep = Math.max(pathBody.lastIndexOf("/"), pathBody.lastIndexOf("\\"));
+  const basename = lastSep >= 0 ? pathBody.slice(lastSep + 1) : pathBody;
+  const rebuilt = `${PATH_REDACTED}/${basename}${lineSuffix}`;
+  return { token: rebuilt, changed: true };
+}
+function sanitizeStack(stack) {
+  let changed = false;
+  const pathNormalized = stack.replace(PATH_TOKEN_RE, (token) => {
+    const out = normalizePathToken(token);
+    if (out.changed) changed = true;
+    return out.token;
+  });
+  const urlStripped = pathNormalized.replace(URL_QUERY_FRAGMENT_RE, (match, prefix) => {
+    if (match !== prefix) changed = true;
+    return prefix;
+  });
+  const credentialRedacted = sanitizeErrorResponseBody(urlStripped);
+  if (credentialRedacted !== urlStripped) changed = true;
+  return { stack: credentialRedacted, redacted: changed };
+}
+function truncateStack(stack) {
+  const encoder = new TextEncoder();
+  const encoded = encoder.encode(stack);
+  if (encoded.byteLength <= ERROR_STACK_MAX_BYTES) {
+    return { stack, truncated: false };
+  }
+  let cut = ERROR_STACK_MAX_BYTES;
+  let scan = cut - 1;
+  while (scan >= 0 && (encoded[scan] & 192) === 128) {
+    scan -= 1;
+  }
+  if (scan >= 0) {
+    const leading = encoded[scan];
+    let expected = 1;
+    if ((leading & 128) === 0) {
+      expected = 1;
+    } else if ((leading & 224) === 192) {
+      expected = 2;
+    } else if ((leading & 240) === 224) {
+      expected = 3;
+    } else if ((leading & 248) === 240) {
+      expected = 4;
+    }
+    if (scan + expected > cut) {
+      cut = scan;
+    }
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  const sliced = encoded.subarray(0, cut);
+  const decoded = decoder.decode(sliced);
+  return { stack: decoded + ERROR_STACK_TRUNCATION_MARKER, truncated: true };
+}
+function prepareStack(stack) {
+  if (stack.length === 0) return null;
+  if (stack.trim().length === 0) return null;
+  const sanitized = sanitizeStack(stack);
+  const truncated = truncateStack(sanitized.stack);
+  return {
+    stack: truncated.stack,
+    truncated: truncated.truncated,
+    redacted: sanitized.redacted
+  };
+}
+
 // src/build-info.ts
 init_console_capture();
 var UNSET = "";
@@ -18678,10 +18811,10 @@ var GlasstraceExporter = class {
       if (route) {
         extra[ATTR.ROUTE] = route;
       }
-      const rawUrl = attrs["http.url"] ?? attrs["url.full"] ?? attrs["http.target"];
-      const trpcUrl = typeof rawUrl === "string" ? rawUrl : void 0;
-      if (trpcUrl) {
-        const trpcMatch = trpcUrl.match(/\/api\/trpc\/([^/?#]+)/);
+      const rawUrlAttr = attrs["http.url"] ?? attrs["url.full"] ?? attrs["http.target"];
+      const rawHttpUrl = typeof rawUrlAttr === "string" ? rawUrlAttr : void 0;
+      if (rawHttpUrl) {
+        const trpcMatch = rawHttpUrl.match(/\/api\/trpc\/([^/?#]+)/);
         if (trpcMatch) {
           let procedure;
           try {
@@ -18752,24 +18885,56 @@ var GlasstraceExporter = class {
           extra[ATTR.HTTP_DURATION_MS] = durationMs;
         }
       }
-      const eventDetails = statusNotExplicitlyOK ? getExceptionEventDetails(span) : { type: void 0, message: void 0 };
-      const errorMessage = attrs["exception.message"];
-      if (typeof errorMessage === "string") {
-        extra[ATTR.ERROR_MESSAGE] = errorMessage;
-      } else if (eventDetails.message) {
+      const eventDetails = statusNotExplicitlyOK ? getExceptionEventDetails(span) : { type: void 0, message: void 0, stacktrace: void 0 };
+      let errorSource;
+      const attrMessage = attrs["exception.message"];
+      if (eventDetails.message) {
         extra[ATTR.ERROR_MESSAGE] = eventDetails.message;
+        errorSource = "otel_exception";
+      } else if (typeof attrMessage === "string") {
+        extra[ATTR.ERROR_MESSAGE] = attrMessage;
+        errorSource = "otel_event";
       }
-      const errorType = attrs["exception.type"];
-      if (typeof errorType === "string") {
-        extra[ATTR.ERROR_CODE] = errorType;
-        extra[ATTR.ERROR_CATEGORY] = deriveErrorCategory(errorType);
-      } else if (eventDetails.type) {
+      const attrType = attrs["exception.type"];
+      if (eventDetails.type) {
         extra[ATTR.ERROR_CODE] = eventDetails.type;
         extra[ATTR.ERROR_CATEGORY] = deriveErrorCategory(eventDetails.type);
+        errorSource = errorSource ?? "otel_exception";
+      } else if (typeof attrType === "string") {
+        extra[ATTR.ERROR_CODE] = attrType;
+        extra[ATTR.ERROR_CATEGORY] = deriveErrorCategory(attrType);
+        errorSource = errorSource ?? "otel_event";
+      }
+      if (statusNotExplicitlyOK) {
+        const rawStack = eventDetails.stacktrace ?? (typeof attrs["exception.stacktrace"] === "string" ? attrs["exception.stacktrace"] : void 0);
+        if (rawStack) {
+          const prepared = prepareStack(rawStack);
+          if (prepared !== null) {
+            extra[ATTR.ERROR_STACK] = prepared.stack;
+            extra[ATTR.ERROR_STACK_TRUNCATED] = prepared.truncated;
+            extra[ATTR.ERROR_STACK_REDACTED] = prepared.redacted;
+            errorSource = errorSource ?? (eventDetails.stacktrace ? "otel_exception" : "otel_event");
+          }
+        }
+      }
+      const routeIsFallback = route === "/_error" || route === "/_not-found" || route === "/_404" || route === "/_500";
+      if (routeIsFallback && rawHttpUrl) {
+        const originalPath = extractPathOnly(rawHttpUrl);
+        const normOriginal = stripTrailingSlash(originalPath);
+        const normRoute = stripTrailingSlash(route);
+        if (normOriginal && normOriginal !== normRoute) {
+          extra[ATTR.ERROR_ORIGINAL_PATH] = normOriginal;
+          extra[ATTR.ERROR_FALLBACK_ROUTE] = route;
+          extra[ATTR.ERROR_FRAMEWORK_KIND] = "fallback";
+          errorSource = errorSource ?? "framework_fallback";
+        }
+      }
+      if (errorSource !== void 0) {
+        extra[ATTR.ERROR_SOURCE] = errorSource;
       }
       if (this.verbose && (extra[ATTR.ERROR_MESSAGE] || extra[ATTR.ERROR_CODE])) {
-        const msgSource = typeof errorMessage === "string" ? "attrs" : eventDetails.message ? "event" : "none";
-        const typeSource = typeof errorType === "string" ? "attrs" : eventDetails.type ? "event" : "none";
+        const msgSource = eventDetails.message ? "event" : typeof attrMessage === "string" ? "attrs" : "none";
+        const typeSource = eventDetails.type ? "event" : typeof attrType === "string" ? "attrs" : "none";
         sdkLog(
           "info",
           `[glasstrace] enrichSpan "${name}": error.message source=${msgSource}, error.code source=${typeSource}`
@@ -18915,13 +19080,15 @@ function hasExceptionEvent(span) {
 function getExceptionEventDetails(span) {
   const event = span.events?.find((e) => e.name === "exception");
   if (!event?.attributes) {
-    return { type: void 0, message: void 0 };
+    return { type: void 0, message: void 0, stacktrace: void 0 };
   }
   const type = event.attributes["exception.type"];
   const message = event.attributes["exception.message"];
+  const stacktrace = event.attributes["exception.stacktrace"];
   return {
     type: typeof type === "string" ? type : void 0,
-    message: typeof message === "string" ? message : void 0
+    message: typeof message === "string" ? message : void 0,
+    stacktrace: typeof stacktrace === "string" ? stacktrace : void 0
   };
 }
 function extractLeadingPath(raw) {
@@ -18939,6 +19106,36 @@ function extractLeadingPath(raw) {
   }
   return void 0;
 }
+function stripTrailingSlash(path4) {
+  if (!path4) return path4;
+  if (path4 === "/") return path4;
+  return path4.endsWith("/") ? path4.slice(0, -1) : path4;
+}
+function extractPathOnly(raw) {
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return void 0;
+  const isAbsoluteUrl = /^https?:\/\//i.test(trimmed);
+  const isProtocolRelative = trimmed.startsWith("//");
+  if (isAbsoluteUrl || isProtocolRelative) {
+    try {
+      const parsed = new URL(trimmed, "http://_/");
+      if (parsed.pathname && parsed.pathname.startsWith("/")) {
+        return parsed.pathname;
+      }
+    } catch {
+    }
+  }
+  if (trimmed.startsWith("/")) {
+    const queryIdx = trimmed.indexOf("?");
+    const fragIdx = trimmed.indexOf("#");
+    let cut = trimmed.length;
+    if (queryIdx >= 0) cut = Math.min(cut, queryIdx);
+    if (fragIdx >= 0) cut = Math.min(cut, fragIdx);
+    return trimmed.slice(0, cut);
+  }
+  return void 0;
+}
 function deriveOrmProvider(instrumentationName) {
   const lower = instrumentationName.toLowerCase();
   if (lower.includes("prisma")) {
@@ -22924,11 +23121,11 @@ function registerGlasstrace(options) {
     setCoreState(CoreState.REGISTERING);
     maybeWarnStaleAgentInstructions({
       projectRoot: process.cwd(),
-      sdkVersion: "1.5.0"
+      sdkVersion: "1.6.0"
     });
     startRuntimeStateWriter({
       projectRoot: process.cwd(),
-      sdkVersion: "1.5.0"
+      sdkVersion: "1.6.0"
     });
     const config2 = resolveConfig(options);
     if (config2.verbose) {
@@ -23095,8 +23292,8 @@ async function backgroundInit(config2, anonKeyForInit, generation) {
   if (config2.verbose) {
     console.info("[glasstrace] Background init firing.");
   }
-  const healthReport = collectHealthReport("1.5.0");
-  const initResult = await performInit(config2, anonKeyForInit, "1.5.0", healthReport);
+  const healthReport = collectHealthReport("1.6.0");
+  const initResult = await performInit(config2, anonKeyForInit, "1.6.0", healthReport);
   if (generation !== registrationGeneration) return;
   const currentState = getCoreState();
   if (currentState === CoreState.SHUTTING_DOWN || currentState === CoreState.SHUTDOWN) {
@@ -23119,7 +23316,7 @@ async function backgroundInit(config2, anonKeyForInit, generation) {
   }
   maybeInstallConsoleCapture();
   if (didLastInitSucceed()) {
-    startHeartbeat(config2, anonKeyForInit, "1.5.0", generation, (newApiKey, accountId) => {
+    startHeartbeat(config2, anonKeyForInit, "1.6.0", generation, (newApiKey, accountId) => {
       setAuthState(AuthState.CLAIMING);
       emitLifecycleEvent("auth:claim_started", { accountId });
       setResolvedApiKey(newApiKey);