@neat.is/core 0.3.5 → 0.3.7

package/dist/index.cjs

@@ -257,8 +257,7 @@ function parseOtlpRequest(body) {
   }
   return out;
 }
-function loadProtobufDecoder() {
-  if (exportTraceServiceRequestType) return exportTraceServiceRequestType;
+function loadProtoRoot() {
   const here = import_node_path35.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
   const protoRoot = import_node_path35.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
@@ -267,11 +266,32 @@ function loadProtobufDecoder() {
     "opentelemetry/proto/collector/trace/v1/trace_service.proto",
     { keepCase: true }
   );
+  return root;
+}
+function loadProtobufDecoder() {
+  if (exportTraceServiceRequestType) return exportTraceServiceRequestType;
+  const root = loadProtoRoot();
   exportTraceServiceRequestType = root.lookupType(
     "opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest"
   );
   return exportTraceServiceRequestType;
 }
+function loadProtobufResponseEncoder() {
+  if (exportTraceServiceResponseType) return exportTraceServiceResponseType;
+  const root = loadProtoRoot();
+  exportTraceServiceResponseType = root.lookupType(
+    "opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse"
+  );
+  return exportTraceServiceResponseType;
+}
+function encodeProtobufResponseBody() {
+  if (cachedProtobufResponseBody) return cachedProtobufResponseBody;
+  const Type = loadProtobufResponseEncoder();
+  const msg = Type.create({});
+  const encoded = Type.encode(msg).finish();
+  cachedProtobufResponseBody = Buffer.from(encoded);
+  return cachedProtobufResponseBody;
+}
 async function decodeProtobufBody(buf) {
   const Type = loadProtobufDecoder();
   const decoded = Type.decode(buf).toJSON();
@@ -318,7 +338,9 @@ async function buildOtelReceiver(opts) {
   app.post("/v1/traces", async (req, reply) => {
     const ct = (req.headers["content-type"] ?? "").toString().split(";")[0].trim().toLowerCase();
     let body;
+    let responseFlavor;
     if (ct === "application/x-protobuf") {
+      responseFlavor = "protobuf";
       try {
         body = await decodeProtobufBody(req.body);
       } catch (err) {
@@ -327,6 +349,7 @@ async function buildOtelReceiver(opts) {
         });
       }
     } else if (!ct || ct === "application/json") {
+      responseFlavor = "json";
       body = req.body ?? {};
     } else {
       return reply.code(415).send({ error: `unsupported content-type: ${ct}` });
@@ -344,7 +367,11 @@ async function buildOtelReceiver(opts) {
       }
     }
     enqueue(spans);
-    return reply.code(200).send({ partialSuccess: {} });
+    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: {} });
   });
   const decorated = app;
   decorated.flushPending = async () => {
@@ -362,7 +389,7 @@ function logSpanHandler(span) {
     `otel: ${span.service} ${span.name} parent=${parent} status=${status2}${db}`
   );
 }
-var import_node_path35, import_node_url2, import_fastify2, import_protobufjs, exportTraceServiceRequestType;
+var import_node_path35, import_node_url2, import_fastify2, import_protobufjs, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
@@ -372,6 +399,8 @@ var init_otel = __esm({
     import_fastify2 = __toESM(require("fastify"), 1);
     import_protobufjs = __toESM(require("protobufjs"), 1);
     exportTraceServiceRequestType = null;
+    exportTraceServiceResponseType = null;
+    cachedProtobufResponseBody = null;
   }
 });
 
@@ -1652,7 +1681,7 @@ function buildErrorEventForReceiver(span) {
     service: span.service,
     traceId: span.traceId,
     spanId: span.spanId,
-    errorMessage: span.exception?.message ?? span.name ?? "unknown error",
+    errorMessage: span.exception?.message ?? "unknown error",
     ...span.exception?.type ? { exceptionType: span.exception.type } : {},
     ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
     ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
@@ -1744,7 +1773,7 @@ async function handleSpan(ctx, span) {
         service: span.service,
         traceId: span.traceId,
         spanId: span.spanId,
-        errorMessage: span.exception?.message ?? span.name ?? "unknown error",
+        errorMessage: span.exception?.message ?? "unknown error",
         ...span.exception?.type ? { exceptionType: span.exception.type } : {},
         ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
         ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
@@ -5259,13 +5288,35 @@ function neatHomeFor(opts) {
 function routeSpanToProject(serviceName, projects) {
   if (!serviceName) return DEFAULT_PROJECT;
   for (const entry of projects) {
-    if (entry.status !== "active") continue;
-    if (entry.languages.length === 0) {
-    }
+    if (entry.status === "paused") continue;
     if (entry.name === serviceName) return entry.name;
   }
+  const candidates = [];
+  for (const entry of projects) {
+    if (entry.status === "paused") continue;
+    if (isTokenPrefix(entry.name, serviceName)) candidates.push(entry);
+  }
+  if (candidates.length > 0) {
+    candidates.sort((a, b) => b.name.length - a.name.length);
+    return candidates[0].name;
+  }
+  for (const entry of projects) {
+    if (entry.status === "paused") continue;
+    if (isTokenContained(entry.name, serviceName)) return entry.name;
+  }
   return DEFAULT_PROJECT;
 }
+function isTokenPrefix(prefix, full) {
+  if (prefix.length >= full.length) return false;
+  if (!full.startsWith(prefix)) return false;
+  const sep = full.charAt(prefix.length);
+  return sep === "-" || sep === "_";
+}
+function isTokenContained(needle, haystack) {
+  if (!haystack.includes(needle)) return false;
+  const tokens = haystack.split(/[-_]/);
+  return tokens.includes(needle);
+}
 async function bootstrapProject(entry) {
   const paths = pathsForProject(entry.name, import_node_path36.default.join(entry.path, "neat-out"));
   try {
@@ -5345,6 +5396,17 @@ async function startDaemon(opts = {}) {
 `);
   const slots = /* @__PURE__ */ new Map();
   const registry = new Projects();
+  const DROP_WARN_INTERVAL_MS = 6e4;
+  const lastDropWarnAt = /* @__PURE__ */ new Map();
+  function warnDroppedSpan(project, reason) {
+    const now = Date.now();
+    const prev = lastDropWarnAt.get(project) ?? 0;
+    if (now - prev < DROP_WARN_INTERVAL_MS) return;
+    lastDropWarnAt.set(project, now);
+    console.warn(
+      `[neatd] dropping span for project "${project}" \u2014 project status: broken (${reason}). Run \`neatd reload\` to retry bootstrap.`
+    );
+  }
   function upsertRegistryFromSlot(slot) {
     if (slot.status !== "active") return;
     registry.set(slot.entry.name, {
@@ -5353,12 +5415,38 @@ async function startDaemon(opts = {}) {
       graph: slot.graph
     });
   }
+  async function tryRecoverSlot(entry) {
+    try {
+      const fresh = await bootstrapProject(entry);
+      slots.set(entry.name, fresh);
+      upsertRegistryFromSlot(fresh);
+      if (fresh.status === "active") {
+        await setStatus(entry.name, "active").catch(() => {
+        });
+        console.log(
+          `neatd: project "${entry.name}" recovered from broken \u2014 active`
+        );
+      }
+      return fresh;
+    } catch (err) {
+      console.warn(
+        `neatd: project "${entry.name}" still broken after recovery attempt \u2014 ${err.message}`
+      );
+      return slots.get(entry.name);
+    }
+  }
   async function loadAll() {
     const projects = await listProjects();
     const seen = /* @__PURE__ */ new Set();
     for (const entry of projects) {
       seen.add(entry.name);
-      if (slots.has(entry.name)) continue;
+      const existing = slots.get(entry.name);
+      if (existing) {
+        if (existing.status === "broken") {
+          await tryRecoverSlot(entry);
+        }
+        continue;
+      }
       try {
         const slot = await bootstrapProject(entry);
         slots.set(entry.name, slot);
@@ -5415,13 +5503,28 @@ async function startDaemon(opts = {}) {
         `neatd: failed to bind REST on port ${restPort} \u2014 ${err.message}`
       );
     }
+    async function resolveTargetSlot(serviceName) {
+      const liveEntries = await listProjects().catch(() => []);
+      const target = routeSpanToProject(serviceName, liveEntries);
+      let slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
+      if (!slot) return null;
+      if (slot.status === "broken") {
+        const entry = liveEntries.find((e) => e.name === slot.entry.name);
+        if (entry) {
+          slot = await tryRecoverSlot(entry);
+        }
+        if (slot.status !== "active") {
+          warnDroppedSpan(slot.entry.name, slot.errorReason ?? "unknown");
+          return null;
+        }
+      }
+      return slot.status === "active" ? slot : null;
+    }
     try {
       otlpApp = await buildOtelReceiver({
         onSpan: async (span) => {
-          const liveEntries = await listProjects().catch(() => []);
-          const target = routeSpanToProject(span.service, liveEntries);
-          const slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
-          if (!slot || slot.status !== "active") return;
+          const slot = await resolveTargetSlot(span.service);
+          if (!slot) return;
           await handleSpan(
             {
               graph: slot.graph,
@@ -5434,10 +5537,8 @@ async function startDaemon(opts = {}) {
           );
         },
         onErrorSpanSync: async (span) => {
-          const liveEntries = await listProjects().catch(() => []);
-          const target = routeSpanToProject(span.service, liveEntries);
-          const slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
-          if (!slot || slot.status !== "active") return;
+          const slot = await resolveTargetSlot(span.service);
+          if (!slot) return;
           await makeErrorSpanWriter(slot.paths.errorsPath)(span);
         }
       });