@neat.is/core 0.9.3 → 0.9.5-dev.20260824

package/dist/{chunk-EDE4XP2M.js → chunk-IVVF37OU.js}

@@ -3691,6 +3691,63 @@ function latencyPercentiles(hist) {
   return { p50: round(quantile(hist, 0.5)), p95: round(quantile(hist, 0.95)) };
 }
 
+// src/stacktrace.ts
+var FRAME_SHAPES = [
+  // `File "<path>", line <N>, in <func>` — the "most recent call last" shape.
+  { re: /File "([^"]+)", line (\d+)(?:, in (\S+))?/, file: 1, line: 2, fn: 3, deepest: "last" },
+  // `at <func> (<path>:<line>:<col>)` — named call frame, most recent first.
+  { re: /\bat\s+(.+?)\s+\((.+?):(\d+):\d+\)/, file: 2, line: 3, fn: 1, deepest: "first" },
+  // `at <path>:<line>:<col>` — anonymous call frame, most recent first.
+  { re: /\bat\s+(.+?):(\d+):\d+/, file: 1, line: 2, deepest: "first" },
+  // `at <qualified.method>(<File.ext>:<line>)` — JVM-style, most recent first.
+  { re: /\bat\s+(.+?)\((\S+\.\w+):(\d+)\)/, file: 2, line: 3, fn: 1, deepest: "first" }
+];
+var VENDOR_MARKERS = [
+  "node_modules",
+  // dependency root
+  "site-packages",
+  // installed-package root
+  "dist-packages",
+  // distro-packaged root
+  "node:"
+  // runtime-internal module scheme (a stdlib/runtime-root frame)
+];
+function matchFrame(line) {
+  for (const shape of FRAME_SHAPES) {
+    const m = shape.re.exec(line);
+    if (!m) continue;
+    const file = m[shape.file];
+    const lineNo = Number(m[shape.line]);
+    if (!file || !Number.isFinite(lineNo)) continue;
+    const fn = shape.fn !== void 0 ? m[shape.fn] : void 0;
+    return { frame: { file, line: lineNo, ...fn ? { fn } : {} }, deepest: shape.deepest };
+  }
+  return null;
+}
+function isApplicationFrame(file) {
+  if (file.startsWith("<")) return false;
+  const norm = file.split("\\").join("/");
+  for (const marker of VENDOR_MARKERS) {
+    if (norm.includes(marker)) return false;
+  }
+  return true;
+}
+function deepestApplicationFrame(stacktrace) {
+  if (!stacktrace) return null;
+  const appFrames = [];
+  for (const raw of stacktrace.split("\n")) {
+    const matched = matchFrame(raw);
+    if (!matched) continue;
+    if (!isApplicationFrame(matched.frame.file)) continue;
+    appFrames.push(matched);
+  }
+  if (appFrames.length === 0) return null;
+  const orientation = appFrames.some((f) => f.deepest === "last") ? "last" : "first";
+  const oriented = appFrames.filter((f) => f.deepest === orientation);
+  const chosen = orientation === "last" ? oriented[oriented.length - 1] : oriented[0];
+  return chosen ? chosen.frame : null;
+}
+
 // src/ingest.ts
 var HOUR_MS = 60 * 60 * 1e3;
 var DAY_MS = 24 * HOUR_MS;
@@ -4542,29 +4599,71 @@ async function appendConnectorIncident(errorsPath, input) {
   await fs7.mkdir(path8.dirname(errorsPath), { recursive: true });
   await fs7.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
-function incidentAffectedNode(span, graph, scanPath) {
+function landIncidentCallSite(span, callSite, trusted, graph) {
+  const relPath = graph ? reconcileObservedRelPath(graph, span.service, callSite.relPath) : callSite.relPath;
+  const canonicalService = serviceNodeName(graph, span) ?? span.service;
+  const recovered = !trusted;
+  if (graph) {
+    const fusedFileId = fileId3(canonicalService, relPath);
+    if (graph.hasNode(fusedFileId)) {
+      const node = landObservedSymbol(
+        graph,
+        fusedFileId,
+        canonicalService,
+        relPath,
+        { ...callSite, relPath },
+        false
+      );
+      return {
+        affectedNode: node,
+        ...recovered ? {
+          codeFilepath: relPath,
+          ...callSite.line !== void 0 ? { codeLineno: callSite.line } : {}
+        } : {}
+      };
+    }
+    if (recovered) return null;
+  }
+  return { affectedNode: fileId3(span.service, relPath) };
+}
+function serviceNodeName(graph, span) {
+  if (!graph) return void 0;
+  const sid = resolveFusedServiceId(graph, span.service, span.env);
+  if (!graph.hasNode(sid)) return void 0;
+  const node = graph.getNodeAttributes(sid);
+  return typeof node.name === "string" ? node.name : void 0;
+}
+function stacktraceCallSite(span, serviceNode, scanPath) {
+  const frame = deepestApplicationFrame(span.exception?.stacktrace);
+  if (!frame) return null;
+  const relPath = relPathForRuntimeFile(frame.file, serviceNode, scanPath);
+  if (!relPath) return null;
+  return { relPath, line: frame.line, ...frame.fn ? { fn: frame.fn } : {} };
+}
+function incidentLocus(span, graph, scanPath) {
   const sid = graph ? resolveFusedServiceId(graph, span.service, span.env) : serviceId(span.service, span.env);
   const serviceNode = graph && graph.hasNode(sid) ? graph.getNodeAttributes(sid) : void 0;
   const callSite = callSiteFromSpan(span, serviceNode, scanPath);
   if (callSite) {
-    const relPath = graph ? reconcileObservedRelPath(graph, span.service, callSite.relPath) : callSite.relPath;
-    const canonicalService = serviceNode && typeof serviceNode.name === "string" ? serviceNode.name : span.service;
-    if (graph) {
-      const fusedFileId = fileId3(canonicalService, relPath);
-      if (graph.hasNode(fusedFileId)) {
-        return landObservedSymbol(
-          graph,
-          fusedFileId,
-          canonicalService,
-          relPath,
-          { ...callSite, relPath },
-          false
-        );
-      }
+    const landed = landIncidentCallSite(span, callSite, true, graph);
+    if (landed) return landed;
+  } else {
+    const recovered = stacktraceCallSite(span, serviceNode, scanPath);
+    if (recovered) {
+      const landed = landIncidentCallSite(span, recovered, false, graph);
+      if (landed) return landed;
     }
-    return fileId3(span.service, relPath);
   }
-  return sid;
+  return { affectedNode: sid };
+}
+function incidentAffectedNode(span, graph, scanPath) {
+  return incidentLocus(span, graph, scanPath).affectedNode;
+}
+function withRecoveredCodeAttrs(attrs, locus) {
+  if (locus.codeFilepath === void 0) return attrs;
+  attrs[CODE_FILEPATH_ATTR] = locus.codeFilepath;
+  if (locus.codeLineno !== void 0) attrs[CODE_LINENO_ATTR] = locus.codeLineno;
+  return attrs;
 }
 function sanitizeAttributes(attrs) {
   const out = {};
@@ -4577,7 +4676,8 @@ function sanitizeAttributes(attrs) {
 function buildErrorEventForReceiver(span, graph, scanPath) {
   if (span.statusCode !== 2) return null;
   const ts = span.startTimeIso ?? (/* @__PURE__ */ new Date()).toISOString();
-  const attrs = sanitizeAttributes(span.attributes);
+  const locus = incidentLocus(span, graph, scanPath);
+  const attrs = withRecoveredCodeAttrs(sanitizeAttributes(span.attributes), locus);
   return {
     id: `${span.traceId}:${span.spanId}`,
     timestamp: ts,
@@ -4588,7 +4688,7 @@ function buildErrorEventForReceiver(span, graph, scanPath) {
     ...span.exception?.type ? { exceptionType: span.exception.type } : {},
     ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
     ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
-    affectedNode: incidentAffectedNode(span, graph, scanPath)
+    affectedNode: locus.affectedNode
   };
 }
 function makeErrorSpanWriter(errorsPath, graph, scanPath) {
@@ -4622,7 +4722,8 @@ async function recordFailingResponseIncident(ctx, span, affectedNode, timestamp,
   await appendErrorEvent(ctx, ev);
 }
 async function recordExceptionIncident(ctx, span, ts) {
-  const attrs = sanitizeAttributes(span.attributes);
+  const locus = incidentLocus(span, ctx.graph, ctx.scanPath);
+  const attrs = withRecoveredCodeAttrs(sanitizeAttributes(span.attributes), locus);
   const ev = {
     id: `${span.traceId}:${span.spanId}`,
     timestamp: ts,
@@ -4633,7 +4734,7 @@ async function recordExceptionIncident(ctx, span, ts) {
     ...span.exception?.type ? { exceptionType: span.exception.type } : {},
     ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
     ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
-    affectedNode: incidentAffectedNode(span, ctx.graph, ctx.scanPath)
+    affectedNode: locus.affectedNode
   };
   await appendErrorEvent(ctx, ev);
 }
@@ -4936,7 +5037,8 @@ async function handleSpan(ctx, span) {
   if (span.statusCode === 2) {
     stitchTrace(ctx.graph, sourceId, ts);
     if (ctx.writeErrorEventInline !== false) {
-      const attrs = sanitizeAttributes(span.attributes);
+      const locus = incidentLocus(span, ctx.graph, ctx.scanPath);
+      const attrs = withRecoveredCodeAttrs(sanitizeAttributes(span.attributes), locus);
       const ev = {
         id: `${span.traceId}:${span.spanId}`,
         timestamp: ts,
@@ -4948,10 +5050,11 @@ async function handleSpan(ctx, span) {
         ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
         ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
         // Attribute to where the failure originated — the symbol / file / service
-        // the throwing span named (incidentAffectedNode, ADR-191) — the same
-        // source-based attribution the durable receiver write uses, not the
-        // outbound edge target this span happened to mint.
-        affectedNode: incidentAffectedNode(span, ctx.graph, ctx.scanPath)
+        // the throwing span named (incidentAffectedNode / ADR-191, extended to
+        // recover the locus from the stacktrace when the span stamped no code.*
+        // attrs, ADR-216) — the same source-based attribution the durable
+        // receiver write uses, not the outbound edge target this span minted.
+        affectedNode: locus.affectedNode
       };
       await appendErrorEvent(ctx, ev);
     }
@@ -21695,4 +21798,4 @@ export {
   deprovisionConnector,
   buildApi
 };
-//# sourceMappingURL=chunk-EDE4XP2M.js.map
+//# sourceMappingURL=chunk-IVVF37OU.js.map