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

package/dist/index.cjs

@@ -341,6 +341,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];
@@ -395,7 +400,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,
@@ -9872,6 +9877,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;
@@ -11742,15 +11783,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 } : {}
       });