@neat.is/core 0.4.3 → 0.4.5

package/dist/index.d.cts

@@ -130,6 +130,7 @@ declare function buildApi(opts: BuildApiOptions): Promise<FastifyInstance>;
 
 interface ParsedSpan {
     service: string;
+    resourceServiceNamePresent?: boolean;
     traceId: string;
     spanId: string;
     parentSpanId?: string;
@@ -153,9 +154,12 @@ interface ParsedSpan {
 }
 type AttributeValue = string | number | boolean | bigint | string[] | number[] | boolean[] | null;
 type SpanHandler = (span: ParsedSpan) => void | Promise<void>;
+type ProjectSpanHandler = (project: string, span: ParsedSpan) => void | Promise<void>;
 interface BuildOtelReceiverOptions {
     onSpan: SpanHandler;
     onErrorSpanSync?: (span: ParsedSpan) => Promise<void>;
+    onProjectSpan?: ProjectSpanHandler;
+    onProjectErrorSpanSync?: (project: string, span: ParsedSpan) => Promise<void>;
     bodyLimit?: number;
     authToken?: string;
     trustProxy?: boolean;

package/dist/index.d.ts

@@ -130,6 +130,7 @@ declare function buildApi(opts: BuildApiOptions): Promise<FastifyInstance>;
 
 interface ParsedSpan {
     service: string;
+    resourceServiceNamePresent?: boolean;
     traceId: string;
     spanId: string;
     parentSpanId?: string;
@@ -153,9 +154,12 @@ interface ParsedSpan {
 }
 type AttributeValue = string | number | boolean | bigint | string[] | number[] | boolean[] | null;
 type SpanHandler = (span: ParsedSpan) => void | Promise<void>;
+type ProjectSpanHandler = (project: string, span: ParsedSpan) => void | Promise<void>;
 interface BuildOtelReceiverOptions {
     onSpan: SpanHandler;
     onErrorSpanSync?: (span: ParsedSpan) => Promise<void>;
+    onProjectSpan?: ProjectSpanHandler;
+    onProjectErrorSpanSync?: (project: string, span: ParsedSpan) => Promise<void>;
     bodyLimit?: number;
     authToken?: string;
     trustProxy?: boolean;

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   routeSpanToProject,
   startDaemon
-} from "./chunk-CB2UK4EH.js";
+} from "./chunk-6GXBAR3M.js";
 import {
   ProjectNameCollisionError,
   addProject,
@@ -37,15 +37,15 @@ import {
   thresholdForEdgeType,
   touchLastSeen,
   writeAtomically
-} from "./chunk-NTQHMXWE.js";
+} from "./chunk-RBWL4HRB.js";
 import {
   startOtelGrpcReceiver
-} from "./chunk-D5PIJFBE.js";
+} from "./chunk-3QCRUEQD.js";
 import {
   buildOtelReceiver,
   logSpanHandler,
   parseOtlpRequest
-} from "./chunk-KYRIQIPG.js";
+} from "./chunk-HVF4S7J3.js";
 export {
   ProjectNameCollisionError,
   addProject,

package/dist/neatd.cjs

@@ -337,12 +337,15 @@ function parseOtlpRequest(body) {
   const out = [];
   for (const rs of body.resourceSpans ?? []) {
     const resourceAttrs = attrsToRecord(rs.resource?.attributes);
-    const service = typeof resourceAttrs["service.name"] === "string" ? resourceAttrs["service.name"] : "unknown";
+    const rawServiceName = resourceAttrs["service.name"];
+    const resourceServiceNamePresent = typeof rawServiceName === "string" && rawServiceName.length > 0;
+    const service = resourceServiceNamePresent ? rawServiceName : "unidentified";
     for (const ss of rs.scopeSpans ?? []) {
       for (const span of ss.spans ?? []) {
         const attrs = attrsToRecord(span.attributes);
         const parsed = {
           service,
+          resourceServiceNamePresent,
           traceId: span.traceId ?? "",
           spanId: span.spanId ?? "",
           parentSpanId: span.parentSpanId || void 0,
@@ -437,6 +440,64 @@ async function buildOtelReceiver(opts) {
     for (const s of spans) queue.push(s);
     drainPromise = drainPromise.then(() => drain());
   };
+  const projectQueue = [];
+  let projectDraining = false;
+  let projectDrainPromise = Promise.resolve();
+  const drainProject = async () => {
+    if (projectDraining) return;
+    projectDraining = true;
+    try {
+      while (projectQueue.length > 0) {
+        const { project, span } = projectQueue.shift();
+        try {
+          if (opts.onProjectSpan) {
+            await opts.onProjectSpan(project, span);
+          } else {
+            await opts.onSpan(span);
+          }
+        } catch (err) {
+          console.warn(`[neat] otel handler error: ${err.message}`);
+        }
+      }
+    } finally {
+      projectDraining = false;
+    }
+  };
+  const enqueueProject = (project, spans) => {
+    if (spans.length === 0) return;
+    for (const s of spans) projectQueue.push({ project, span: s });
+    projectDrainPromise = projectDrainPromise.then(() => drainProject());
+  };
+  const legacyEndpointWarned = /* @__PURE__ */ new Set();
+  function warnLegacyEndpoint(serviceName) {
+    if (legacyEndpointWarned.has(serviceName)) return;
+    legacyEndpointWarned.add(serviceName);
+    console.warn(
+      `[neatd] received span on the global endpoint; migrate OTEL_EXPORTER_OTLP_TRACES_ENDPOINT to /projects/<name>/v1/traces (service.name="${serviceName}").`
+    );
+  }
+  async function readOtlpBody(req2) {
+    const ct = (req2.headers["content-type"] ?? "").toString().split(";")[0].trim().toLowerCase();
+    if (ct === "application/x-protobuf") {
+      try {
+        const body = await decodeProtobufBody(req2.body);
+        return { ok: true, body, flavor: "protobuf" };
+      } catch (err) {
+        return { ok: false, code: 400, error: `protobuf decode failed: ${err.message}` };
+      }
+    }
+    if (!ct || ct === "application/json") {
+      return { ok: true, body: req2.body ?? {}, flavor: "json" };
+    }
+    return { ok: false, code: 415, error: `unsupported content-type: ${ct}` };
+  }
+  function sendOtlpSuccess(reply, flavor) {
+    if (flavor === "protobuf") {
+      const buf = encodeProtobufResponseBody();
+      return reply.code(200).header("content-type", "application/x-protobuf").send(buf);
+    }
+    return reply.code(200).header("content-type", "application/json").send({ partialSuccess: {} });
+  }
   app.addContentTypeParser(
     "application/x-protobuf",
     { parseAs: "buffer", bodyLimit: opts.bodyLimit ?? 16 * 1024 * 1024 },
@@ -446,26 +507,44 @@ async function buildOtelReceiver(opts) {
   );
   app.get("/health", async () => ({ ok: true }));
   app.post("/v1/traces", async (req2, reply) => {
-    const ct = (req2.headers["content-type"] ?? "").toString().split(";")[0].trim().toLowerCase();
-    let body;
-    let responseFlavor;
-    if (ct === "application/x-protobuf") {
-      responseFlavor = "protobuf";
+    const result = await readOtlpBody(req2);
+    if (!result.ok) {
+      return reply.code(result.code).send({ error: result.error });
+    }
+    const spans = parseOtlpRequest(result.body);
+    for (const s of spans) warnLegacyEndpoint(s.service);
+    if (opts.onErrorSpanSync) {
       try {
-        body = await decodeProtobufBody(req2.body);
+        for (const span of spans) {
+          if (span.statusCode === 2) await opts.onErrorSpanSync(span);
+        }
       } catch (err) {
-        return reply.code(400).send({
-          error: `protobuf decode failed: ${err.message}`
+        return reply.code(500).send({
+          error: `error-event write failed: ${err.message}`
         });
       }
-    } else if (!ct || ct === "application/json") {
-      responseFlavor = "json";
-      body = req2.body ?? {};
-    } else {
-      return reply.code(415).send({ error: `unsupported content-type: ${ct}` });
     }
-    const spans = parseOtlpRequest(body);
-    if (opts.onErrorSpanSync) {
+    enqueue(spans);
+    return sendOtlpSuccess(reply, result.flavor);
+  });
+  app.post("/projects/:project/v1/traces", async (req2, reply) => {
+    const project = req2.params.project;
+    const result = await readOtlpBody(req2);
+    if (!result.ok) {
+      return reply.code(result.code).send({ error: result.error });
+    }
+    const spans = parseOtlpRequest(result.body);
+    if (opts.onProjectErrorSpanSync) {
+      try {
+        for (const span of spans) {
+          if (span.statusCode === 2) await opts.onProjectErrorSpanSync(project, span);
+        }
+      } catch (err) {
+        return reply.code(500).send({
+          error: `error-event write failed: ${err.message}`
+        });
+      }
+    } else if (opts.onErrorSpanSync) {
       try {
         for (const span of spans) {
           if (span.statusCode === 2) await opts.onErrorSpanSync(span);
@@ -476,17 +555,13 @@ async function buildOtelReceiver(opts) {
         });
       }
     }
-    enqueue(spans);
-    if (responseFlavor === "protobuf") {
-      const buf = encodeProtobufResponseBody();
-      return reply.code(200).header("content-type", "application/x-protobuf").send(buf);
-    }
-    return reply.code(200).header("content-type", "application/json").send({ partialSuccess: {} });
+    enqueueProject(project, spans);
+    return sendOtlpSuccess(reply, result.flavor);
   });
   const decorated = app;
   decorated.flushPending = async () => {
-    while (queue.length > 0 || draining) {
-      await drainPromise;
+    while (queue.length > 0 || draining || projectQueue.length > 0 || projectDraining) {
+      await Promise.all([drainPromise, projectDrainPromise]);
     }
   };
   return decorated;
@@ -1506,6 +1581,14 @@ var DEFAULT_STALE_THRESHOLDS = {
 function nowIso(ctx) {
   return new Date(ctx.now ? ctx.now() : Date.now()).toISOString();
 }
+var unidentifiedWarnedProjects = /* @__PURE__ */ new Set();
+function warnUnidentifiedSpan(project) {
+  if (unidentifiedWarnedProjects.has(project)) return;
+  unidentifiedWarnedProjects.add(project);
+  console.warn(
+    `[neatd] span lacked service.name; routed to 'unidentified' in project ${project}; check your OTel SDK config.`
+  );
+}
 function pickAttr(span, ...keys) {
   for (const k of keys) {
     const v = span.attributes[k];
@@ -1760,6 +1843,9 @@ async function handleSpan(ctx, span) {
   const ts = span.startTimeIso ?? nowIso(ctx);
   const nowMs = ctx.now ? ctx.now() : Date.now();
   const env = span.env ?? "unknown";
+  if (span.resourceServiceNamePresent === false) {
+    warnUnidentifiedSpan(ctx.project ?? DEFAULT_PROJECT);
+  }
   const sourceId = ensureServiceNode(ctx.graph, span.service, env);
   const isError = span.statusCode === 2;
   cacheSpanService(span, nowMs);
@@ -5680,6 +5766,25 @@ async function startDaemon(opts = {}) {
       }
       return slot.status === "active" ? slot : null;
     }
+    async function resolveSlotByName(project, serviceName, traceId) {
+      const liveEntries = await listProjects().catch(() => []);
+      let slot = slots.get(project);
+      if (!slot) {
+        await recordUnroutedSpan(serviceName, traceId);
+        return null;
+      }
+      if (slot.status === "broken") {
+        const entry2 = liveEntries.find((e) => e.name === slot.entry.name);
+        if (entry2) {
+          slot = await tryRecoverSlot(entry2);
+        }
+        if (slot.status !== "active") {
+          warnDroppedSpan(slot.entry.name, slot.errorReason ?? "unknown");
+          return null;
+        }
+      }
+      return slot.status === "active" ? slot : null;
+    }
     try {
       otlpApp = await buildOtelReceiver({
         authToken: auth.otelToken,
@@ -5702,6 +5807,28 @@ async function startDaemon(opts = {}) {
           const slot = await resolveTargetSlot(span.service, span.traceId);
           if (!slot) return;
           await makeErrorSpanWriter(slot.paths.errorsPath)(span);
+        },
+        // Project-scoped route (issue #367) — the URL already named the
+        // project. Resolution is a direct slot lookup; service.name resolves
+        // the ServiceNode inside the slot's graph instead of which project
+        // owns the span.
+        onProjectSpan: async (project, span) => {
+          const slot = await resolveSlotByName(project, span.service, span.traceId);
+          if (!slot) return;
+          await handleSpan(
+            {
+              graph: slot.graph,
+              errorsPath: slot.paths.errorsPath,
+              project: slot.entry.name,
+              writeErrorEventInline: false
+            },
+            span
+          );
+        },
+        onProjectErrorSpanSync: async (project, span) => {
+          const slot = await resolveSlotByName(project, span.service, span.traceId);
+          if (!slot) return;
+          await makeErrorSpanWriter(slot.paths.errorsPath)(span);
         }
       });
       otlpAddress = await otlpApp.listen({ port: otlpPort, host });