@neat.is/core 0.5.4-dev.20260721 → 0.6.0

package/dist/{chunk-4RU3AAOI.js → chunk-MVINCLQM.js}

@@ -1,6 +1,6 @@
 import {
   parseOtlpRequest
-} from "./chunk-I4NZ7PSN.js";
+} from "./chunk-BZ3AJVAC.js";
 
 // src/otel-grpc.ts
 import { fileURLToPath } from "url";
@@ -138,4 +138,4 @@ export {
   reshapeGrpcRequest,
   startOtelGrpcReceiver
 };
-//# sourceMappingURL=chunk-4RU3AAOI.js.map
+//# sourceMappingURL=chunk-MVINCLQM.js.map

package/dist/cli.cjs

@@ -342,6 +342,11 @@ function pickEnv(spanAttrs, resourceAttrs) {
   }
   return ENV_FALLBACK;
 }
+function normalizeDbSystem(attrs) {
+  const raw = attrs["db.system"];
+  if (typeof raw !== "string") return void 0;
+  return raw === "mongoose" ? "mongodb" : raw;
+}
 function messagingDestinationOf(attrs) {
   for (const key of ["messaging.destination.name", "messaging.destination"]) {
     const v = attrs[key];
@@ -396,7 +401,7 @@ function parseOtlpRequest(body) {
           durationNanos: durationNanos(span.startTimeUnixNano, span.endTimeUnixNano),
           env: pickEnv(attrs, resourceAttrs),
           attributes: attrs,
-          dbSystem: typeof attrs["db.system"] === "string" ? attrs["db.system"] : void 0,
+          dbSystem: normalizeDbSystem(attrs),
           dbName: typeof attrs["db.name"] === "string" ? attrs["db.name"] : void 0,
           dbCollection: typeof attrs["db.collection.name"] === "string" ? attrs["db.collection.name"] : typeof attrs["db.mongodb.collection"] === "string" ? attrs["db.mongodb.collection"] : void 0,
           messagingSystem: typeof attrs["messaging.system"] === "string" ? attrs["messaging.system"] : void 0,
@@ -10242,6 +10247,42 @@ function registerRoutes(scope, ctx) {
       return reply.code(500).send({ error: err.message });
     }
   });
+  scope.get("/instrumentation", async (req, reply) => {
+    const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
+    if (!proj) return;
+    if (!proj.scanPath) {
+      return { engaged: null };
+    }
+    try {
+      const state = await describeProjectInstrumentation({ project: proj.name, scanPath: proj.scanPath });
+      const uninstrumented = await listUninstrumented({ project: proj.name, scanPath: proj.scanPath });
+      if (state.hookFiles.length === 0) {
+        return {
+          engaged: false,
+          diagnosis: {
+            reason: "No instrumented entry point found \u2014 NEAT hasn't written an OTel init hook for this project.",
+            fixCommand: "neat init",
+            detail: "Run `neat init` so NEAT writes the instrumentation hook next to your entry point, then run your app."
+          }
+        };
+      }
+      if (uninstrumented.length > 0) {
+        const names = uninstrumented.map((u) => u.library);
+        const more = names.length > 1 ? ` (and ${names.length - 1} more)` : "";
+        return {
+          engaged: false,
+          diagnosis: {
+            reason: `\`${names[0]}\`${more} isn't in the auto-instrumentation set, so spans from it won't reach the graph.`,
+            fixCommand: "neat extend",
+            detail: `Uninstrumented on your hot path: ${names.join(", ")}. Run \`neat extend\` to wire the missing instrumentation.`
+          }
+        };
+      }
+      return { engaged: true };
+    } catch {
+      return { engaged: null };
+    }
+  });
   scope.post("/extend/apply", async (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
@@ -11997,15 +12038,21 @@ var PROVIDER_DISPATCH = {
         resolveTarget: createCloudflareResolveTarget(config, graph)
       };
     },
-    // GET /user/tokens/verify — Cloudflare's own purpose-built "is this API
-    // token live" endpoint. 200 on a valid token, 401 on an invalid one.
+    // GET /accounts/{accountId}/tokens/verify — the *account-scoped* token-verify
+    // endpoint. A Workers connector token is scoped to the account, and the
+    // user-level `GET /user/tokens/verify` returns 401 "Invalid API Token" for
+    // such a token even though it authenticates fine against the account's own
+    // resources (confirmed live). Probing the account-scoped verify endpoint —
+    // `accountId` is already required for this provider — returns 200
+    // `{status:"active"}` for a working token and 401 for a bad one, so a valid
+    // Workers token is no longer falsely rejected at `neat connector add`.
     validate({ credentials, options, fetchImpl }) {
       const cfg = options;
       const baseUrl = cfg.baseUrl ?? CLOUDFLARE_API_BASE_URL;
       return authProbe({
         provider: "cloudflare",
         accountKey: cfg.accountId ?? "validate",
-        url: `${baseUrl}/user/tokens/verify`,
+        url: `${baseUrl}/accounts/${cfg.accountId ?? ""}/tokens/verify`,
         token: String(credentials.apiToken ?? ""),
         ...fetchImpl ? { fetchImpl } : {}
       });
@@ -13537,9 +13584,12 @@ ${OTEL_ENDPOINT_RESOLVER_ESM}
 ${OTEL_OTLP_PROTOCOL_JS}
 ${OTEL_OTLP_HEADERS_JS}
 
-import { NodeSDK } from '@opentelemetry/sdk-node'
-import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
-import { trace, context } from '@opentelemetry/api'
+// Keep dependency loading inside the guard. Static ESM imports are evaluated
+// before any try/catch and would crash the host app when an install failed.
+try {
+const { NodeSDK } = await import('@opentelemetry/sdk-node')
+const { getNodeAutoInstrumentations } = await import('@opentelemetry/auto-instrumentations-node')
+const { trace, context } = await import('@opentelemetry/api')
 
 ${CALLSITE_PROCESSOR_JS}
 
@@ -13548,6 +13598,14 @@ __INSTRUMENTATION_BLOCK__
 const sdk = new NodeSDK({ instrumentations })
 sdk.start()
 ${neatWireCaptureSource(false)}
+} catch (__neatOtelErr) {
+  const __neatMsg = String((__neatOtelErr && __neatOtelErr.message) || __neatOtelErr)
+  if (/Cannot find (?:module|package)|MODULE_NOT_FOUND|ERR_MODULE_NOT_FOUND/.test(__neatMsg)) {
+    console.warn('[neat] OpenTelemetry is not active: its packages are not installed, so this app is running without OBSERVED tracing. Run your package manager install and restart to enable it.')
+  } else {
+    console.warn('[neat] OpenTelemetry failed to start; the app is running without OBSERVED tracing: ' + __neatMsg)
+  }
+}
 `;
 var OTEL_INIT_TS = `${OTEL_INIT_HEADER}
 ${OTEL_INIT_STAMP}
@@ -13562,9 +13620,12 @@ ${OTEL_ENDPOINT_RESOLVER_ESM}
 ${OTEL_OTLP_PROTOCOL_JS}
 ${OTEL_OTLP_HEADERS_JS}
 
-import { NodeSDK } from '@opentelemetry/sdk-node'
-import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
-import { trace, context } from '@opentelemetry/api'
+// Top-level await preserves the static import's ordering: the host entry does
+// not run until instrumentation has started (or safely degraded).
+try {
+const { NodeSDK } = await import('@opentelemetry/sdk-node')
+const { getNodeAutoInstrumentations } = await import('@opentelemetry/auto-instrumentations-node')
+const { trace, context } = await import('@opentelemetry/api')
 
 ${CALLSITE_PROCESSOR_TS}
 
@@ -13573,6 +13634,14 @@ __INSTRUMENTATION_BLOCK__
 const sdk = new NodeSDK({ instrumentations })
 sdk.start()
 ${neatWireCaptureSource(true)}
+} catch (__neatOtelErr) {
+  const __neatMsg = String((__neatOtelErr && __neatOtelErr.message) || __neatOtelErr)
+  if (/Cannot find (?:module|package)|MODULE_NOT_FOUND|ERR_MODULE_NOT_FOUND/.test(__neatMsg)) {
+    console.warn('[neat] OpenTelemetry is not active: its packages are not installed, so this app is running without OBSERVED tracing. Run your package manager install and restart to enable it.')
+  } else {
+    console.warn('[neat] OpenTelemetry failed to start; the app is running without OBSERVED tracing: ' + __neatMsg)
+  }
+}
 `;
 function renderNodeOtelInit(template, serviceName, projectName, registrations = []) {
   const block = registrations.length === 0 ? "" : `
@@ -15871,9 +15940,26 @@ function printSummary(result, graph, dashboardUrl, daemonLog) {
   } else {
     console.log("running locally \u2014 open the dashboard, no token needed");
   }
+  const failedInstalls = (result.steps.apply.packageManagerInstalls ?? []).filter(
+    (i) => i.exitCode !== 0
+  );
   if (daemonLog !== null) {
     console.log("");
     console.log(`daemon running in the background (logs: ${daemonLog})`);
+  }
+  if (failedInstalls.length > 0) {
+    if (daemonLog === null) console.log("");
+    console.log(
+      "instrumentation is wired into your manifests, but it is NOT yet active:"
+    );
+    console.log(
+      "the dependency install did not complete, so the OTel SDK never landed and"
+    );
+    console.log("OBSERVED edges will stay empty until you finish the install. Fix it:");
+    for (const i of failedInstalls) {
+      console.log(`      run \`${i.pm} install\` in ${i.cwd}`);
+    }
+  } else if (daemonLog !== null) {
     console.log(
       "next: run your app or your test suite \u2014 OBSERVED edges fill in as it executes,"
     );