@geraldmaron/construct 1.0.0 → 1.0.2

package/lib/opencode-telemetry.mjs

@@ -1,11 +1,11 @@
 /**
- * lib/opencode-telemetry.mjs — OpenCode → Langfuse full-fidelity tracing.
+ * lib/opencode-telemetry.mjs — OpenCode telemetry full-fidelity tracing.
  *
- * Maintains per-session state, maps OpenCode events/hooks onto Langfuse
+ * Maintains per-session state, maps OpenCode events/hooks onto telemetry
  * trace/generation/span/event observations, and flushes on session.idle.
  */
 import { randomUUID } from "node:crypto";
-import { createIngestClient } from "./telemetry/langfuse-ingest.mjs";
+import { createIngestClient } from "./telemetry/ingest.mjs";
 
 const SECRET_PATH_PATTERNS = [
   /(^|\/)\.env(\.|$)/i,
@@ -25,9 +25,9 @@ let cachedIngest = null;
 export function getIngestClient(env = process.env) {
   if (cachedIngest) return cachedIngest;
   cachedIngest = createIngestClient({
-    baseUrl: env.LANGFUSE_BASEURL,
-    publicKey: env.LANGFUSE_PUBLIC_KEY,
-    secretKey: env.LANGFUSE_SECRET_KEY,
+    baseUrl: env.CONSTRUCT_TELEMETRY_URL,
+    publicKey: env.CONSTRUCT_TELEMETRY_PUBLIC_KEY,
+    secretKey: env.CONSTRUCT_TELEMETRY_SECRET_KEY,
     onError: (err) => {
       if (env.CONSTRUCT_TRACE_DEBUG === "1") {
         // eslint-disable-next-line no-console
@@ -106,6 +106,15 @@ function sanitizeUsage(tokens, cost) {
   const total = input + output + reasoning;
   if (!input && !output && !total) return undefined;
   const usage = { input, output, total, unit: "TOKENS" };
+  if (reasoning) usage.reasoning = reasoning;
+  const cacheRead = Number(tokens.cache?.read) || 0;
+  const cacheWrite = Number(tokens.cache?.write) || 0;
+  const cacheWrite5m = Number(tokens.cache?.write_5m ?? tokens.cache?.create_5m) || 0;
+  const cacheWrite1h = Number(tokens.cache?.write_1h ?? tokens.cache?.create_1h) || 0;
+  if (cacheRead) usage.cacheRead = cacheRead;
+  if (cacheWrite5m) usage.cacheWrite5m = cacheWrite5m;
+  if (cacheWrite1h) usage.cacheWrite1h = cacheWrite1h;
+  if (cacheWrite) usage.cacheWrite = cacheWrite;
   if (Number(cost) > 0) usage.totalCost = Number(cost);
   return usage;
 }
@@ -125,6 +134,10 @@ export function ensureSessionTrace(sessionId, { env = process.env, agent, userId
       toolSpanByCallId: new Map(),
       pendingGenerationId: null,
       agent: agent || null,
+      lastOutput: null,
+      lastUsedModel: null,
+      lastUsage: null,
+      lastGenerationCompletedAt: null,
     };
     sessionTraces.set(sessionId, entry);
     ingest.trace({
@@ -318,10 +331,38 @@ export async function onBusEvent(event, { env = process.env, buildUsage } = {})
           provider: info.providerID,
           ...(info.tokens?.cache ? { cacheTokens: info.tokens.cache } : {}),
           ...(info.cost ? { costUsd: info.cost } : {}),
+          ...(usage?.reasoning ? { reasoningTokens: usage.reasoning } : {}),
+          ...(usage?.cacheRead ? { cacheReadInputTokens: usage.cacheRead } : {}),
+          ...(usage?.cacheWrite5m ? { cacheCreation5mInputTokens: usage.cacheWrite5m } : {}),
+          ...(usage?.cacheWrite1h ? { cacheCreation1hInputTokens: usage.cacheWrite1h } : {}),
         },
       };
       if (existingGenId) ingest.generationUpdate(body);
       else ingest.generation(body);
+
+      // Also update the parent trace with the final output so the trace
+      // detail page in the telemetry backend shows what was produced, not just metadata.
+      if (outputText) {
+        // Only update trace with the first/last substantial output to conserve
+        // batch payload; telemetry backend merges metadata fields with existing values.
+        entry.lastOutput = outputText;
+        entry.lastUsedModel = body.model;
+        entry.lastUsage = usage;
+        entry.lastGenerationCompletedAt = body.endTime;
+        ingest.traceUpdate({
+          id: entry.traceId,
+          output: outputText.slice(0, 10_000), // cap trace-level output
+          metadata: {
+            hasOutput: true,
+            lastModel: body.model,
+            lastAgent: agent,
+            lastGenerationCompletedAt: body.endTime,
+            lastGenerationId: genId,
+            totalOutputTokens: usage?.output,
+          },
+        });
+      }
+
       return;
     }
 
@@ -362,6 +403,23 @@ export async function onBusEvent(event, { env = process.env, buildUsage } = {})
         name: event.type,
         startTime: new Date().toISOString(),
       });
+
+      // If generation output was captured but trace-level output is stale,
+      // re-update trace with latest output before flush.
+      if (entry.lastOutput) {
+        ingest.traceUpdate({
+          id: entry.traceId,
+          output: entry.lastOutput.slice(0, 10_000),
+          metadata: {
+            hasOutput: true,
+            idleAt: new Date().toISOString(),
+            finalModel: entry.lastUsedModel,
+            finalAgent: entry.agent,
+            finalGenerationCompletedAt: entry.lastGenerationCompletedAt,
+          },
+        });
+      }
+
       await ingest.flush();
       return;
     }