@neutrome/open-ai-router 0.5.2 → 0.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutrome/open-ai-router",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

package/src/otlp.ts

@@ -14,6 +14,12 @@ type OtlpAttribute = {
   key: string;
   value: { stringValue?: string; intValue?: string; boolValue?: boolean };
 };
+type OtlpLogRecord = {
+  timeUnixNano: string;
+  severityText: "ERROR";
+  body: { stringValue: string };
+  attributes: OtlpAttribute[];
+};
 
 export async function exportOtlp(
   env: Environment,
@@ -30,34 +36,63 @@ export async function exportOtlp(
         "content-type": "application/json",
         ...headersFor(env, signal),
       },
-      body: JSON.stringify({
-        resourceSpans: [
-          {
-            resource: {
-              attributes: attributes({
-                "service.name":
-                  stringEnv(env, "OTEL_SERVICE_NAME") ?? "neutrome-router",
-              }),
-            },
-            scopeSpans: [
-              { scope: { name: "@neutrome/open-ai-router" }, spans },
-            ],
-          },
-        ],
-      }),
+      body: JSON.stringify(otlpPayload(env, signal, spans)),
     });
     if (!response.ok) {
-      console.error("[telemetry] OTLP export rejected", {
-        signal,
-        status: response.status,
-        statusText: response.statusText,
-      });
+      const responseBody = (await response.text()).slice(0, 2_000);
+      console.error(
+        `[telemetry] OTLP ${signal} export rejected: ${response.status} ${response.statusText}${responseBody ? `: ${responseBody}` : ""}`,
+      );
     }
   } catch (error) {
     console.error("[telemetry] OTLP export failed", error);
   }
 }
 
+function otlpPayload(
+  env: Environment,
+  signal: "traces" | "errors",
+  spans: OtlpSpan[],
+): Record<string, unknown> {
+  const resource = {
+    attributes: attributes({
+      "service.name": stringEnv(env, "OTEL_SERVICE_NAME") ?? "neutrome-router",
+    }),
+  };
+  if (signal === "traces") {
+    return {
+      resourceSpans: [
+        {
+          resource,
+          scopeSpans: [{ scope: { name: "@neutrome/open-ai-router" }, spans }],
+        },
+      ],
+    };
+  }
+  return {
+    resourceLogs: [
+      {
+        resource,
+        scopeLogs: [
+          {
+            scope: { name: "@neutrome/open-ai-router" },
+            logRecords: spans.map(errorLogRecord),
+          },
+        ],
+      },
+    ],
+  };
+}
+
+function errorLogRecord(span: OtlpSpan): OtlpLogRecord {
+  return {
+    timeUnixNano: span.endTimeUnixNano,
+    severityText: "ERROR",
+    body: { stringValue: span.status?.message ?? span.name },
+    attributes: span.attributes,
+  };
+}
+
 export function rootOtlpSpan(input: {
   traceId: string;
   spanId: string;

package/src/telemetry.test.ts

@@ -45,15 +45,34 @@ describe("createRouterTelemetry", () => {
     expect(fetchMock.mock.calls[1]?.[1]?.headers).toMatchObject({
       authorization: "Bearer error-token",
     });
+    expect(
+      JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body)),
+    ).toMatchObject({
+      resourceLogs: [
+        {
+          scopeLogs: [
+            {
+              logRecords: [
+                {
+                  severityText: "ERROR",
+                  body: { stringValue: "upstream unavailable" },
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    });
     fetchMock.mockRestore();
   });
 
   it("logs a rejected exporter response without exposing credentials", async () => {
-    const fetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(
-        new Response(null, { status: 401, statusText: "Unauthorized" }),
-      );
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response("invalid authentication", {
+        status: 401,
+        statusText: "Unauthorized",
+      }),
+    );
     const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
     const telemetry = createRouterTelemetry({
       OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: "https://traces.example/v1/traces",
@@ -67,11 +86,9 @@ describe("createRouterTelemetry", () => {
 
     await telemetry.flush();
 
-    expect(errorSpy).toHaveBeenCalledWith("[telemetry] OTLP export rejected", {
-      signal: "traces",
-      status: 401,
-      statusText: "Unauthorized",
-    });
+    expect(errorSpy).toHaveBeenCalledWith(
+      "[telemetry] OTLP traces export rejected: 401 Unauthorized: invalid authentication",
+    );
     fetchMock.mockRestore();
     errorSpy.mockRestore();
   });