@neat.is/core 0.9.9 → 0.9.10

package/dist/cli.js

@@ -6,7 +6,7 @@ import {
   resolveHost,
   resolveNeatVersion,
   writeDaemonRecord
-} from "./chunk-QETJIA2Q.js";
+} from "./chunk-UHNE7LGF.js";
 import {
   buildSearchIndex
 } from "./chunk-BC53SCT7.js";
@@ -75,7 +75,7 @@ import {
   startStalenessLoop,
   upsertConnectorEntry,
   validateConnectorEntry
-} from "./chunk-B6KJG5KN.js";
+} from "./chunk-C3LHXC55.js";
 import {
   startOtelGrpcReceiver
 } from "./chunk-ERE47MCR.js";

package/dist/index.cjs

@@ -1865,6 +1865,24 @@ function incidentCountForNode(nodeId, incidents) {
   if (!incidents || incidents.length === 0) return 0;
   return incidents.filter((ev) => incidentMatchesNode(ev, nodeId)).length;
 }
+var DEP_EDGE_TYPES = /* @__PURE__ */ new Set([
+  import_types.EdgeType.CALLS,
+  import_types.EdgeType.CONNECTS_TO,
+  import_types.EdgeType.PUBLISHES_TO,
+  import_types.EdgeType.CONSUMES_FROM
+]);
+var TIMEOUT_ERROR_PATTERNS = [
+  /\bDEADLINE_EXCEEDED\b/i,
+  /\bdeadline exceeded\b/i,
+  /\bETIMEDOUT\b/i,
+  /\btimed[\s-]?out\b/i,
+  /\btimeout\b/i
+];
+function isBoundaryTimeoutError(ev) {
+  if (ev.httpStatusCode === 504) return true;
+  const haystack = [ev.errorType, ev.exceptionType, ev.errorMessage].filter((s) => typeof s === "string").join(" \n ");
+  return TIMEOUT_ERROR_PATTERNS.some((re) => re.test(haystack));
+}
 function nodeContext(graph, nodeId, incidents, now = Date.now()) {
   const scope = nodeScope(graph, nodeId);
   let errorsFromCallers = 0;
@@ -1874,6 +1892,8 @@ function nodeContext(graph, nodeId, incidents, now = Date.now()) {
   let latestInboundMs;
   let latencyP95Ms;
   let stale = false;
+  let observedErroringDownstream = false;
+  let hasOutboundDeps = false;
   for (const n of scope) {
     if (!graph.hasNode(n)) continue;
     for (const edgeId of graph.inboundEdges(n)) {
@@ -1895,10 +1915,17 @@ function nodeContext(graph, nodeId, incidents, now = Date.now()) {
       outboundVolume += e.callCount ?? e.signal?.spanCount ?? 0;
       if (e.type === import_types.EdgeType.CALLS) outboundErrors += e.signal?.errorCount ?? 0;
       if (e.provenance === import_types.Provenance.STALE) stale = true;
+      if (DEP_EDGE_TYPES.has(e.type)) {
+        hasOutboundDeps = true;
+        if ((e.signal?.errorCount ?? 0) > 0) observedErroringDownstream = true;
+      }
     }
   }
   const errorsEmittedHere = incidentCountForNode(nodeId, incidents) + outboundErrors;
   const lastObservedAgeMs = latestInboundMs !== void 0 ? Math.max(0, now - latestInboundMs) : void 0;
+  const boundaryTimeout = (incidents ?? []).some(
+    (ev) => incidentMatchesNode(ev, nodeId) && isBoundaryTimeoutError(ev)
+  );
   return {
     errorsEmittedHere,
     errorsFromCallers,
@@ -1906,17 +1933,24 @@ function nodeContext(graph, nodeId, incidents, now = Date.now()) {
     outboundVolume,
     ...lastObservedAgeMs !== void 0 ? { lastObservedAgeMs } : {},
     ...latencyP95Ms !== void 0 ? { latencyP95Ms } : {},
-    stale
+    stale,
+    boundaryTimeout,
+    observedErroringDownstream,
+    hasOutboundDeps
   };
 }
 function isSaturated(ctx) {
   return ctx.latencyP95Ms !== void 0 && ctx.latencyP95Ms >= SATURATION_P95_MS;
 }
+function isBoundaryTimeoutSymptom(ctx) {
+  return ctx.errorsEmittedHere > 0 && ctx.boundaryTimeout === true && ctx.errorsFromCallers === 0 && ctx.hasOutboundDeps === true && ctx.observedErroringDownstream !== true;
+}
 function classifyNode(ctx) {
   if (ctx.errorsEmittedHere > 0) {
     if ((ctx.stale || isSaturated(ctx)) && ctx.errorsFromCallers >= ctx.errorsEmittedHere) {
       return "symptom-only";
     }
+    if (isBoundaryTimeoutSymptom(ctx)) return "symptom-only";
     return "primary-failure";
   }
   if (ctx.errorsFromCallers > 0) return "symptom-only";
@@ -2121,6 +2155,57 @@ function getRootCause(graph, errorNodeId, errorEvent, incidents, opts) {
   if (!navigation) return tagged.result;
   return enrichWithNavigation(graph, errorNodeId, tagged, incidents, opts?.now ?? Date.now());
 }
+function boundaryIncidentRoute(nodeId, incidents) {
+  for (const ev of incidents ?? []) {
+    if (!incidentMatchesNode(ev, nodeId)) continue;
+    const r = ev.attributes?.["http.route"] ?? ev.attributes?.["http.target"] ?? ev.attributes?.["url.path"];
+    if (typeof r === "string" && r.length > 0) return r;
+  }
+  return void 0;
+}
+function declaredOutboundCallees(graph, nodeId) {
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const n of nodeScope(graph, nodeId)) {
+    if (!graph.hasNode(n)) continue;
+    for (const edgeId of graph.outboundEdges(n)) {
+      const e = graph.getEdgeAttributes(edgeId);
+      if (!DEP_EDGE_TYPES.has(e.type)) continue;
+      if (e.provenance !== import_types.Provenance.EXTRACTED) continue;
+      if (e.target === nodeId || byTarget.has(e.target)) continue;
+      const route = e.evidence?.pathTemplate;
+      byTarget.set(
+        e.target,
+        route !== void 0 ? { target: e.target, route } : { target: e.target }
+      );
+    }
+  }
+  return [...byTarget.values()];
+}
+function normalizeRoute(s) {
+  return s.replace(/\/+$/, "").toLowerCase();
+}
+function routeMatches(declared, incident) {
+  const a = normalizeRoute(declared);
+  const b = normalizeRoute(incident);
+  return a === b || a.startsWith(b) || b.startsWith(a);
+}
+function structuralUpstreamPointer(graph, boundaryNode, incidents) {
+  const route = boundaryIncidentRoute(boundaryNode, incidents);
+  const callees = declaredOutboundCallees(graph, boundaryNode);
+  if (callees.length === 0) return null;
+  const narrowed = route !== void 0 ? callees.filter((c) => c.route !== void 0 && routeMatches(c.route, route)) : callees;
+  const chosen = narrowed.length === 1 ? narrowed[0] : callees.length === 1 ? callees[0] : null;
+  if (!chosen) return null;
+  let node = chosen.target;
+  const seen = /* @__PURE__ */ new Set([boundaryNode, node]);
+  for (let depth = 0; depth < ROOT_CAUSE_MAX_DEPTH; depth++) {
+    const next = declaredOutboundCallees(graph, node);
+    if (next.length !== 1 || seen.has(next[0].target)) break;
+    node = next[0].target;
+    seen.add(node);
+  }
+  return route !== void 0 ? { node, route } : { node };
+}
 function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
   const legacy = tagged.result;
   const seedNode = legacy.rootCauseNode;
@@ -2154,6 +2239,29 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
       confidence: Math.min(legacy.confidence, 0.4),
       ...lastProv ? { provenance: lastProv } : {}
     });
+  } else if (seedCtx && isBoundaryTimeoutSymptom(seedCtx)) {
+    const pointer = structuralUpstreamPointer(graph, seedNode, incidents);
+    const seedName = displayNameOf(seedNode);
+    const routeNote = pointer?.route ? ` serving ${pointer.route}` : "";
+    if (pointer) {
+      const causeName = displayNameOf(pointer.node);
+      candidates.push({
+        node: pointer.node,
+        classification: "primary-failure",
+        reason: `${causeName} is the likely root cause (structural, INFERRED \u2014 not observed): the boundary ${seedName} only timed out waiting, and the actual culprit hung without exporting a span, so this is walked from the declared call graph${routeNote}, not from runtime signal. Restore instrumentation / inspect ${causeName} to confirm.`,
+        context: nodeContext(graph, pointer.node, incidents, now),
+        confidence: Math.min(legacy.confidence, PROVENANCE_CEILING.EXTRACTED),
+        provenance: import_types.Provenance.INFERRED
+      });
+    }
+    candidates.push({
+      node: seedNode,
+      classification: "symptom-only",
+      reason: pointer ? `${seedName} timed out waiting on a downstream that hung and exported nothing \u2014 a boundary reporting an upstream fault, not the fault itself.` : `${seedName} timed out but nothing it can see downstream is erroring \u2014 the cause is downstream and unobserved (the culprit hung and exported no span). No single declared callee${routeNote} resolves, so no confident cause is named; inspect ${seedName}'s declared downstream.`,
+      context: seedCtx,
+      confidence: Math.min(legacy.confidence, 0.3),
+      ...lastProv ? { provenance: lastProv } : {}
+    });
   } else if (staleChain) {
     const culprit = staleChain.culprit;
     const culpritName = displayNameOf(culprit);