@infinitedusky/indusk-mcp 1.18.2 → 1.19.0

package/dist/lib/eval/otel.d.ts

@@ -12,6 +12,7 @@
  * throws, same behavior. The evaluator never fails because of OTel.
  */
 import { type Attributes, type Span, type Tracer } from "@opentelemetry/api";
+import { type Logger } from "@opentelemetry/api-logs";
 export interface EvalOtelConfig {
     enabled: boolean;
     endpoint: string | null;
@@ -56,9 +57,30 @@ export declare function initEvalOtel(projectRoot: string): Tracer;
  */
 export declare function withSpan<T>(tracer: Tracer, name: string, attrs: Attributes | undefined, fn: (span: Span) => Promise<T> | T): Promise<T>;
 /**
- * Flush and shut down the active provider. Call this before `process.exit()`
- * in detached processes so batched spans are not lost. No-op if no provider
- * is active.
+ * Initialize the OTel logs pipeline alongside traces. Returns a Logger —
+ * real when enabled + endpoint set, no-op otherwise. Shares the same
+ * config gating + Dash0 dataset routing as `initEvalOtel`. Safe to call
+ * multiple times.
+ *
+ * Log records emitted via `getEvalLogger().emit(...)` automatically
+ * correlate with the active span via trace_id / span_id.
+ */
+export declare function initEvalOtelLogs(projectRoot: string): Logger;
+/**
+ * Accessor for the eval logger. Always safe to call — returns a no-op
+ * logger when logs aren't initialized.
+ */
+export declare function getEvalLogger(): Logger;
+/**
+ * Emit an info-severity log record with an arbitrary body. Shorthand for
+ * `getEvalLogger().emit(...)`. When called inside an active span, the
+ * SDK attaches trace_id + span_id automatically.
+ */
+export declare function logEvalContent(name: string, body: string | Record<string, unknown>, attributes?: Record<string, string | number | boolean>): void;
+/**
+ * Flush and shut down the active providers (traces + logs). Call this
+ * before `process.exit()` in detached processes so batched signals are
+ * not lost. No-op if neither provider is active.
  */
 export declare function shutdownEvalOtel(): Promise<void>;
 /**

package/dist/lib/eval/otel.js

@@ -14,8 +14,11 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
+import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
@@ -96,7 +99,9 @@ function rewriteDatasetInEnvHeaders(target) {
     const rewritten = current.replace(/Dash0-Dataset=[^,]*/g, `Dash0-Dataset=${target}`);
     process.env.OTEL_EXPORTER_OTLP_HEADERS = rewritten;
 }
+const LOGGER_NAME = "@infinitedusky/indusk-mcp/eval";
 let activeProvider = null;
+let activeLoggerProvider = null;
 /**
  * Initialize OTel tracing for the evaluator if enabled + endpoint set.
  * Returns a Tracer — real when enabled, no-op when not.
@@ -187,22 +192,105 @@ export async function withSpan(tracer, name, attrs, fn) {
     });
 }
 /**
- * Flush and shut down the active provider. Call this before `process.exit()`
- * in detached processes so batched spans are not lost. No-op if no provider
- * is active.
+ * Initialize the OTel logs pipeline alongside traces. Returns a Logger —
+ * real when enabled + endpoint set, no-op otherwise. Shares the same
+ * config gating + Dash0 dataset routing as `initEvalOtel`. Safe to call
+ * multiple times.
+ *
+ * Log records emitted via `getEvalLogger().emit(...)` automatically
+ * correlate with the active span via trace_id / span_id.
+ */
+export function initEvalOtelLogs(projectRoot) {
+    const { enabled, endpoint, dataset } = isEvalOtelEnabled(projectRoot);
+    if (!enabled)
+        return logs.getLogger(LOGGER_NAME);
+    if (!endpoint) {
+        syslog(projectRoot, "eval.otel.logs — endpoint unset; falling back to no-op logger");
+        return logs.getLogger(LOGGER_NAME);
+    }
+    if (activeLoggerProvider)
+        return logs.getLogger(LOGGER_NAME);
+    rewriteDatasetInEnvHeaders(dataset);
+    const headers = { "Dash0-Dataset": dataset };
+    if (process.env.DASH0_API_TOKEN) {
+        headers.Authorization = `Bearer ${process.env.DASH0_API_TOKEN}`;
+    }
+    try {
+        const exporter = new OTLPLogExporter({
+            url: endpoint.endsWith("/v1/logs") ? endpoint : `${endpoint.replace(/\/$/, "")}/v1/logs`,
+            headers,
+        });
+        const provider = new LoggerProvider({
+            resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: SERVICE_NAME }),
+            processors: [new BatchLogRecordProcessor(exporter)],
+        });
+        // setGlobalLoggerProvider returns false if one is already registered
+        // (e.g., a test's InMemoryLogRecordExporter provider). Respect that —
+        // only retain ownership (and tear down at shutdown) if we actually
+        // registered ours.
+        const accepted = logs.setGlobalLoggerProvider(provider);
+        if (accepted) {
+            activeLoggerProvider = provider;
+            syslog(projectRoot, `eval.otel.logs initialized — endpoint: ${endpoint}, dataset: ${dataset}`);
+        }
+        else {
+            syslog(projectRoot, "eval.otel.logs — global provider already set; using existing");
+            // Fire-and-forget shutdown of the unused provider
+            void provider.shutdown().catch(() => { });
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        syslog(projectRoot, `eval.otel.logs init failed — falling back to no-op: ${message}`);
+    }
+    return logs.getLogger(LOGGER_NAME);
+}
+/**
+ * Accessor for the eval logger. Always safe to call — returns a no-op
+ * logger when logs aren't initialized.
+ */
+export function getEvalLogger() {
+    return logs.getLogger(LOGGER_NAME);
+}
+/**
+ * Emit an info-severity log record with an arbitrary body. Shorthand for
+ * `getEvalLogger().emit(...)`. When called inside an active span, the
+ * SDK attaches trace_id + span_id automatically.
+ */
+export function logEvalContent(name, body, attributes) {
+    // AnyValue requires plain primitives/arrays/records — stringify objects so
+    // Dash0 ingests the content as a single searchable log body rather than a
+    // nested structure.
+    const bodyText = typeof body === "string" ? body : JSON.stringify(body);
+    getEvalLogger().emit({
+        severityNumber: SeverityNumber.INFO,
+        severityText: "INFO",
+        body: bodyText,
+        attributes: { "eval.event": name, ...(attributes ?? {}) },
+    });
+}
+/**
+ * Flush and shut down the active providers (traces + logs). Call this
+ * before `process.exit()` in detached processes so batched signals are
+ * not lost. No-op if neither provider is active.
  */
 export async function shutdownEvalOtel() {
-    if (!activeProvider)
-        return;
+    const tasks = [];
+    if (activeProvider) {
+        tasks.push(activeProvider.forceFlush().then(() => activeProvider?.shutdown()));
+    }
+    if (activeLoggerProvider) {
+        tasks.push(activeLoggerProvider.forceFlush().then(() => activeLoggerProvider?.shutdown()));
+    }
     try {
-        await activeProvider.forceFlush();
-        await activeProvider.shutdown();
+        await Promise.all(tasks);
     }
     catch {
         // shutdown is best-effort
     }
     finally {
         activeProvider = null;
+        activeLoggerProvider = null;
     }
 }
 /**
@@ -210,12 +298,17 @@ export async function shutdownEvalOtel() {
  * starts fresh. Not part of the public API.
  */
 export function __resetEvalOtelForTests() {
-    // Tear down any provider left over from a previous test. This un-registers
-    // from the global OTel API, so `trace.getTracer()` falls back to the no-op
-    // tracer until a new provider is registered.
+    // Tear down any providers left over from a previous test. This
+    // un-registers from the global OTel API so `trace.getTracer()` /
+    // `logs.getLogger()` fall back to no-op until re-registered.
     if (activeProvider) {
         void activeProvider.shutdown().catch(() => { });
     }
+    if (activeLoggerProvider) {
+        void activeLoggerProvider.shutdown().catch(() => { });
+    }
     activeProvider = null;
+    activeLoggerProvider = null;
     trace.disable();
+    logs.disable();
 }

package/dist/lib/eval/persistent-evaluator.js

@@ -13,7 +13,7 @@ import { getProjectGroupId } from "../config.js";
 import { readUnprocessedHighlights } from "../highlights/highlights.js";
 import { ingestScorecard } from "./findings.js";
 import { EvalLogWriter } from "./log-writer.js";
-import { initEvalOtel, shutdownEvalOtel, withSpan } from "./otel.js";
+import { initEvalOtel, initEvalOtelLogs, logEvalContent, shutdownEvalOtel, withSpan, } from "./otel.js";
 import { buildEvaluatorPrompt } from "./prompt-builder.js";
 import { V1_RUBRIC } from "./rubric.js";
 function getSessionPath(projectRoot) {
@@ -112,6 +112,7 @@ async function spawnClaude(args, prompt, cwd) {
  */
 export async function runPersistentEval(opts) {
     const tracer = initEvalOtel(opts.projectRoot);
+    initEvalOtelLogs(opts.projectRoot);
     const source = process.env.INDUSK_EVAL_SOURCE ?? "commit";
     const projectGroup = getProjectGroupId(opts.projectRoot);
     // Peek at the highlights queue before spawning — gives us observability
@@ -135,7 +136,17 @@ export async function runPersistentEval(opts) {
         const session = await withSpan(tracer, "eval.read_session", undefined, () => readSession(opts.projectRoot));
         rootSpan.setAttribute("resumed", session !== null);
         try {
-            const { args, prompt } = await withSpan(tracer, "eval.build_prompt", { resumed: session !== null }, () => {
+            const { args, prompt } = await withSpan(tracer, "eval.build_prompt", { resumed: session !== null }, (span) => {
+                const built = buildArgsAndPrompt();
+                span.setAttribute("prompt.length", built.prompt.length);
+                span.setAttribute("prompt.kind", session ? "resume" : "full");
+                logEvalContent("prompt", built.prompt, {
+                    "prompt.length": built.prompt.length,
+                    "prompt.kind": session ? "resume" : "full",
+                });
+                return built;
+            });
+            function buildArgsAndPrompt() {
                 if (session) {
                     const resumePrompt = `Evaluate a new commit. Change ID: ${opts.changeId}
 
@@ -175,16 +186,24 @@ Output ONLY the JSON scorecard as before — no commentary.`;
                         projectGroup,
                     }),
                 };
-            });
+            }
             const claudeResult = await withSpan(tracer, "eval.spawn_claude", {
                 "args.resumed": session !== null,
                 "args.model": session ? "(resumed)" : "opus",
             }, async (span) => {
                 const spawned = await spawnClaude(args, prompt, opts.projectRoot);
                 span.setAttribute("exit.code", spawned.code ?? -1);
+                span.setAttribute("stdout.length", spawned.stdout.length);
                 if (spawned.code !== 0) {
                     span.setAttribute("exit.stderr_tail", spawned.stderr.slice(-500));
+                    logEvalContent("claude.error", spawned.stderr, {
+                        "exit.code": spawned.code ?? -1,
+                    });
                 }
+                logEvalContent("claude.stdout", spawned.stdout, {
+                    "stdout.length": spawned.stdout.length,
+                    "exit.code": spawned.code ?? -1,
+                });
                 return spawned;
             });
             if (claudeResult.code !== 0) {
@@ -210,6 +229,26 @@ Output ONLY the JSON scorecard as before — no commentary.`;
             if (parsed.usage)
                 scorecard.usage = parsed.usage;
             scorecard.telemetryPosted = false;
+            // Carry scorecard-level content onto the root span for at-a-glance debugging in Dash0
+            rootSpan.setAttribute("scorecard.status", "ok");
+            rootSpan.setAttribute("scorecard.question_count", scorecard.questions?.length ?? 0);
+            if (scorecard.summary) {
+                rootSpan.setAttribute("scorecard.summary", scorecard.summary.slice(0, 500));
+            }
+            if (scorecard.usage) {
+                rootSpan.setAttribute("scorecard.cost_usd", scorecard.usage.costUsd);
+                rootSpan.setAttribute("scorecard.duration_ms", scorecard.usage.durationMs);
+                rootSpan.setAttribute("scorecard.input_tokens", scorecard.usage.inputTokens);
+                rootSpan.setAttribute("scorecard.output_tokens", scorecard.usage.outputTokens);
+            }
+            const answerCounts = { yes: 0, no: 0, partial: 0 };
+            for (const q of scorecard.questions ?? []) {
+                if (q.answer in answerCounts)
+                    answerCounts[q.answer]++;
+            }
+            rootSpan.setAttribute("scorecard.answers.yes", answerCounts.yes);
+            rootSpan.setAttribute("scorecard.answers.no", answerCounts.no);
+            rootSpan.setAttribute("scorecard.answers.partial", answerCounts.partial);
             await withSpan(tracer, "eval.update_session", undefined, () => {
                 const newSession = {
                     sessionId: parsed.sessionId ?? session?.sessionId ?? "unknown",
@@ -222,17 +261,28 @@ Output ONLY the JSON scorecard as before — no commentary.`;
             await withSpan(tracer, "eval.write_scorecard", undefined, async () => {
                 await logWriter.append(scorecard);
                 ingestScorecard(opts.projectRoot, scorecard);
+                logEvalContent("scorecard", JSON.stringify(scorecard), {
+                    "scorecard.question_count": scorecard.questions?.length ?? 0,
+                    "scorecard.summary_length": scorecard.summary?.length ?? 0,
+                });
             });
             return scorecard;
         }
         catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error ? (err.stack ?? "") : "";
+            rootSpan.setAttribute("scorecard.status", "error");
+            rootSpan.setAttribute("error.message", msg.slice(0, 500));
+            logEvalContent("error", stack || msg, {
+                "error.message": msg.slice(0, 500),
+            });
             const errorEntry = {
                 version: 1,
                 timestamp: new Date().toISOString(),
                 mode: opts.mode,
                 changeId: opts.changeId,
                 error: true,
-                message: err instanceof Error ? err.message : String(err),
+                message: msg,
             };
             await logWriter.append(errorEntry);
             return errorEntry;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@infinitedusky/indusk-mcp",
-	"version": "1.18.2",
+	"version": "1.19.0",
 	"description": "InDusk development system — skills, MCP tools, and CLI for structured AI-assisted development",
 	"type": "module",
 	"files": [
@@ -29,8 +29,11 @@
 	"dependencies": {
 		"@modelcontextprotocol/sdk": "^1.12.1",
 		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/api-logs": "^0.214.0",
+		"@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
 		"@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
 		"@opentelemetry/resources": "^2.6.0",
+		"@opentelemetry/sdk-logs": "^0.214.0",
 		"@opentelemetry/sdk-trace-base": "^2.6.0",
 		"@opentelemetry/sdk-trace-node": "^2.6.0",
 		"@opentelemetry/semantic-conventions": "^1.40.0",