copilot-tracer 1.0.5 → 1.0.6

package/README.md

@@ -1,6 +1,6 @@
 # copilot-tracer
 
-Real-time tracing and prompt-refinement companion for **GitHub Copilot CLI** and **VS Code Copilot extension**.
+Real-time tracing and prompt-refinement companion for **GitHub Copilot CLI**, **Claude Code**, and **VS Code Copilot extension**.
 
 Captures every prompt, response, token usage, AI credits, tool calls, and duration — all in one place. Runs as a background daemon that collects data from all your projects automatically. Includes a web dashboard with project overview and per-project live tracing.
 
@@ -11,7 +11,7 @@ Captures every prompt, response, token usage, AI credits, tool calls, and durati
 - **Daemon mode** — install once, run forever. Collects traces from all projects automatically
 - **Auto project detection** — detects project from `github.copilot.git.repository` in OTLP spans
 - **Zero-intrusion capture** — uses Copilot's built-in OTel support. Set env vars, done.
-- **Works everywhere** — captures both Copilot CLI and VS Code Copilot Chat
+- **Works everywhere** — captures GitHub Copilot CLI, Claude Code, and VS Code Copilot Chat
 - **Dashboard** — overview of all projects with token usage, credits, and session counts
 - **Live tracer** — real-time trace table per project with detail panel
 - **Prompt refinement** — rewrites prompts with stronger instructions and less noise
@@ -31,7 +31,8 @@ This will:
 1. Detect your Copilot CLI and VS Code installation
 2. Patch `~/.zshrc` with OTEL env vars
 3. Patch VS Code `settings.json` with terminal env vars
-4. Start the daemon on port 4747
+4. Enable Claude Code OTLP logs/events and enhanced beta traces
+5. Start the daemon on port 4747
 
 Then apply env vars in your current shell:
 
@@ -39,7 +40,9 @@ Then apply env vars in your current shell:
 source ~/.zshrc
 ```
 
-Restart VS Code once. After that, the daemon collects traces from all your Copilot sessions automatically.
+Restart VS Code once. After that, the daemon collects traces from all your Copilot
+and Claude Code sessions automatically. Claude Code content flags are enabled by
+setup so prompts and responses can be displayed in the local dashboard.
 
 Open **http://localhost:4747** to see the dashboard.
 
@@ -51,20 +54,20 @@ Open **http://localhost:4747** to see the dashboard.
 ┌─────────────────────────────────────────────────────────┐
 │  copilot-tracer --daemon (runs once, stays running)      │
 │                                                          │
-│  OTLP Receiver ← Copilot CLI + VS Code                   │
+│  OTLP Receiver ← Copilot CLI + Claude Code + VS Code                   │
 │  (auto-detects project from github.copilot.git.repository)│
 │                                                          │
 │  SQLite DB → Dashboard + Live Tracer (Socket.io)         │
 └─────────────────────────────────────────────────────────┘
 
-Copilot CLI / VS Code Copilot Chat
+Copilot CLI / Claude Code / VS Code Copilot Chat
          │
          │  OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4747
          ↓
-   POST /v1/traces (OpenTelemetry OTLP JSON)
+   POST /v1/traces and /v1/logs (OpenTelemetry OTLP JSON)
          │
          ↓
-   copilot-tracer parses spans → tokens, credits, tool calls
+   copilot-tracer parses spans and events → tokens, credits, tool calls
          │
          ↓
    SQLite DB (~/.copilot-tracer/traces.db)
@@ -121,6 +124,7 @@ Open http://localhost:4747 after starting the daemon.
 - **Summary cards** — total projects, sessions, tokens, credits
 - **Project cards** — each project shows path, session count, tokens, credits, last active
 - **Click a project** → opens live tracer filtered to that project
+<img width="737" height="410" alt="image" src="https://github.com/user-attachments/assets/dc20653b-8774-46b3-9a42-6e7bb934aded" />
 
 ---
 
@@ -138,6 +142,10 @@ Real-time trace table for a specific project.
 - Click Skills / Agents / MCPs → filtered call list
 - Real-time updates via Socket.io
 
+<img width="1504" height="742" alt="image" src="https://github.com/user-attachments/assets/f334108f-c587-4228-8120-7dac2f85f90b" />
+
+<img width="1061" height="696" alt="image" src="https://github.com/user-attachments/assets/1555d5a2-dbca-4f1d-b102-3d2865dcee68" />
+
 ---
 
 ## Prompt Refinement
@@ -173,8 +181,21 @@ Add to `~/.zshrc`:
 export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4747
 export OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true
 export COPILOT_OTEL_ENABLED=true
+
+# Claude Code telemetry
+export CLAUDE_CODE_ENABLE_TELEMETRY=1
+export CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1
+export OTEL_LOGS_EXPORTER=otlp
+export OTEL_TRACES_EXPORTER=otlp
+export OTEL_EXPORTER_OTLP_PROTOCOL=http/json
+export OTEL_LOG_USER_PROMPTS=1
+export OTEL_LOG_ASSISTANT_RESPONSES=1
 ```
 
+Claude Code exports standard OTLP logs/events and optional beta traces. See
+[Anthropic's monitoring documentation](https://code.claude.com/docs/en/monitoring-usage)
+for protocol and content controls.
+
 For VS Code, add to `~/Library/Application Support/Code/User/settings.json`:
 
 ```json

package/dist/otlpReceiver.js

@@ -14,6 +14,7 @@
  *   chat <model> span attrs: same as above
  *   User message event: github.copilot.user.message
  */
+import { randomUUID } from 'crypto';
 import { upsertTrace, createSession, deleteTrace, ensureProject, ensureProjectByRepo } from './db.js';
 import { traceEvents } from './proxy.js';
 // ── Helpers ───────────────────────────────────────────────────────────────────
@@ -36,6 +37,27 @@ function nanoToMs(nano) {
 function nanoToIso(nano) {
     return new Date(nanoToMs(nano)).toISOString();
 }
+function getStringAttr(attrs, ...keys) {
+    for (const key of keys) {
+        const value = getAttr(attrs, key);
+        if (value !== undefined && String(value).trim())
+            return String(value);
+    }
+    return undefined;
+}
+function getBodyText(body) {
+    if (!body)
+        return undefined;
+    if (body.stringValue !== undefined)
+        return body.stringValue;
+    if (body.intValue !== undefined)
+        return String(body.intValue);
+    if (body.doubleValue !== undefined)
+        return String(body.doubleValue);
+    if (body.boolValue !== undefined)
+        return String(body.boolValue);
+    return undefined;
+}
 const inFlight = new Map(); // traceId → InFlight
 // Sessions are created lazily. Always upsert so project_id gets backfilled
 // when the session was created earlier without a project.
@@ -53,7 +75,7 @@ function resolveProjectId(repoUrl, workingDir, defaultProjectId) {
     return defaultProjectId;
 }
 function detectWorkingDir(attrs) {
-    for (const key of ['process.working_directory', 'github.copilot.working_dir']) {
+    for (const key of ['process.working_directory', 'github.copilot.working_dir', 'claude_code.working_dir']) {
         const v = getAttr(attrs, key);
         if (v && String(v).trim())
             return String(v).trim();
@@ -65,6 +87,116 @@ function detectWorkingDir(attrs) {
 const pendingChatIds = new Map(); // `chat:${traceId}` → list of entryIds
 // Buffer tool calls that arrive before invoke_agent
 const pendingToolCalls = new Map(); // traceId → tool calls
+const claudePromptEntries = new Map(); // prompt.id → trace entry
+const claudeInteractionEntries = new Map(); // traceId → interaction entry
+const CLAUDE_STATE_LIMIT = 1000;
+function rememberClaudeEntry(map, key, entry) {
+    map.set(key, entry);
+    if (map.size > CLAUDE_STATE_LIMIT) {
+        const oldest = map.keys().next().value;
+        if (oldest)
+            map.delete(oldest);
+    }
+}
+function claudeEventId(record, attrs, eventName) {
+    const messageId = getStringAttr(attrs, 'message.uuid', 'tool_use_id');
+    const promptId = getStringAttr(attrs, 'prompt.id');
+    return `claude:${messageId ?? promptId ?? record.traceId ?? randomUUID()}:${eventName}`;
+}
+function processClaudeLogRecord(record, resourceAttrs, sessionId, projectId, workingDir) {
+    const attrs = record.attributes ?? [];
+    const eventName = getStringAttr(attrs, 'event.name') ?? getBodyText(record.body);
+    if (!eventName || !eventName.startsWith('claude_code.'))
+        return;
+    const eventTime = getStringAttr(attrs, 'event.timestamp');
+    const dateTime = eventTime ?? (record.timeUnixNano ? nanoToIso(record.timeUnixNano) : new Date().toISOString());
+    const promptId = getStringAttr(attrs, 'prompt.id');
+    const resolvedProjectId = resolveProjectId(getStringAttr(resourceAttrs, 'github.copilot.git.repository', 'vcs.repository.url'), getStringAttr(attrs, 'process.working_directory', 'github.copilot.working_dir', 'claude_code.working_dir') ?? workingDir, projectId);
+    const eventSessionId = getStringAttr(attrs, 'session.id') ?? sessionId;
+    if (eventName === 'claude_code.user_prompt') {
+        const entry = {
+            id: claudeEventId(record, attrs, 'prompt'),
+            sessionId: eventSessionId,
+            dateTime,
+            prompt: getStringAttr(attrs, 'prompt') ?? '[Claude Code prompt]',
+            tokens: { input: 0, output: 0, cached: 0, reasoning: 0, written: 0, total: 0 },
+            aiCredits: 0,
+            durationMs: 0,
+            toolCalls: [],
+            skillCount: 0,
+            agentCount: 0,
+            mcpCount: 0,
+            status: 'running',
+        };
+        if (promptId)
+            rememberClaudeEntry(claudePromptEntries, promptId, entry);
+        ensureSession(eventSessionId, resolvedProjectId);
+        upsertTrace(entry);
+        traceEvents.emit('trace:update', entry);
+        return;
+    }
+    if (eventName === 'claude_code.assistant_response') {
+        const existingEntry = promptId ? claudePromptEntries.get(promptId) : undefined;
+        const entry = existingEntry ?? {
+            id: claudeEventId(record, attrs, 'response'),
+            sessionId: eventSessionId,
+            dateTime,
+            prompt: '[Claude Code response]',
+            tokens: { input: 0, output: 0, cached: 0, reasoning: 0, written: 0, total: 0 },
+            aiCredits: 0,
+            durationMs: 0,
+            toolCalls: [],
+            skillCount: 0,
+            agentCount: 0,
+            mcpCount: 0,
+            status: 'running',
+        };
+        entry.response = getStringAttr(attrs, 'response');
+        entry.status = 'done';
+        entry.durationMs = Number(getStringAttr(attrs, 'duration_ms') ?? 0);
+        ensureSession(eventSessionId, resolvedProjectId);
+        upsertTrace(entry);
+        traceEvents.emit('trace:update', entry);
+        traceEvents.emit('trace:done', entry);
+        return;
+    }
+    if (eventName === 'claude_code.tool_result') {
+        const entry = promptId ? claudePromptEntries.get(promptId) : undefined;
+        if (!entry)
+            return;
+        const toolName = getStringAttr(attrs, 'tool_name') ?? 'Claude Code tool';
+        const toolId = getStringAttr(attrs, 'tool_use_id') ?? randomUUID();
+        if (entry.toolCalls.some(call => call.id === toolId))
+            return;
+        entry.toolCalls.push({
+            id: toolId,
+            name: toolName,
+            type: detectToolType(toolName),
+            input: {},
+            startedAt: Date.parse(dateTime),
+            endedAt: Date.parse(dateTime),
+            durationMs: Number(getStringAttr(attrs, 'duration_ms') ?? 0),
+            error: getStringAttr(attrs, 'error'),
+        });
+        upsertTrace(entry);
+        traceEvents.emit('trace:update', entry);
+    }
+}
+function processClaudeLogs(payload, defaultSessionId, projectId) {
+    if (!payload || !Array.isArray(payload.resourceLogs)) {
+        throw new Error('OTLP logs payload must contain resourceLogs');
+    }
+    for (const resourceLogs of payload.resourceLogs ?? []) {
+        const resourceAttrs = resourceLogs.resource?.attributes ?? [];
+        const sessionId = getStringAttr(resourceAttrs, 'session.id') ?? defaultSessionId;
+        const workingDir = detectWorkingDir(resourceAttrs);
+        for (const scopeLogs of resourceLogs.scopeLogs ?? []) {
+            for (const record of scopeLogs.logRecords ?? []) {
+                processClaudeLogRecord(record, resourceAttrs, sessionId, projectId, workingDir);
+            }
+        }
+    }
+}
 function processSpans(spans, sessionId, projectId, workingDir) {
     for (const span of spans) {
         // DEBUG — log raw span to stderr when COPILOT_TRACER_DEBUG=1
@@ -75,6 +207,53 @@ function processSpans(spans, sessionId, projectId, workingDir) {
         const spanName = span.name;
         const traceId = span.traceId;
         const spanId = span.spanId;
+        if (spanName === 'claude_code.interaction') {
+            const attrs = span.attributes ?? [];
+            const inputTokens = Number(getAttr(attrs, 'input_tokens') ?? 0);
+            const outputTokens = Number(getAttr(attrs, 'output_tokens') ?? 0);
+            const entry = {
+                id: spanId,
+                sessionId: getStringAttr(attrs, 'session.id') ?? sessionId,
+                dateTime: nanoToIso(span.startTimeUnixNano),
+                prompt: getStringAttr(attrs, 'user_prompt') ?? '[Claude Code interaction]',
+                tokens: { input: inputTokens, output: outputTokens, cached: Number(getAttr(attrs, 'cache_read_tokens') ?? 0), reasoning: 0, written: outputTokens, total: inputTokens + outputTokens },
+                aiCredits: Number(getAttr(attrs, 'cost_usd') ?? 0),
+                durationMs: Number(getAttr(attrs, 'interaction.duration_ms')
+                    ?? (nanoToMs(span.endTimeUnixNano) - nanoToMs(span.startTimeUnixNano))),
+                toolCalls: [],
+                skillCount: 0,
+                agentCount: 0,
+                mcpCount: 0,
+                status: (span.status?.code ?? 0) === 2 ? 'error' : 'done',
+                error: span.status?.message,
+            };
+            ensureSession(entry.sessionId, resolveProjectId(getAttr(attrs, 'vcs.repository.url'), detectWorkingDir(attrs) ?? workingDir, projectId));
+            upsertTrace(entry);
+            rememberClaudeEntry(claudeInteractionEntries, traceId, entry);
+            traceEvents.emit('trace:update', entry);
+            traceEvents.emit('trace:done', entry);
+            continue;
+        }
+        if (spanName === 'claude_code.llm_request') {
+            const inputTokens = Number(getAttr(attrs, 'input_tokens') ?? 0);
+            const outputTokens = Number(getAttr(attrs, 'output_tokens') ?? 0);
+            const cachedTokens = Number(getAttr(attrs, 'cache_read_tokens') ?? 0);
+            const entry = claudeInteractionEntries.get(traceId);
+            if (entry) {
+                entry.tokens = {
+                    input: entry.tokens.input + inputTokens,
+                    output: entry.tokens.output + outputTokens,
+                    cached: entry.tokens.cached + cachedTokens,
+                    reasoning: 0,
+                    written: entry.tokens.written + outputTokens,
+                    total: entry.tokens.total + inputTokens + outputTokens,
+                };
+                entry.aiCredits += Number(getAttr(attrs, 'cost_usd') ?? 0);
+                upsertTrace(entry);
+                traceEvents.emit('trace:update', entry);
+            }
+            continue;
+        }
         // ── invoke_agent span = top-level agent turn ──────────────────────────
         if (spanName === 'invoke_agent') {
             const startMs = nanoToMs(span.startTimeUnixNano);
@@ -426,8 +605,17 @@ export function registerOtlpRoutes(app, defaultSessionId, projectId) {
             res.status(400).json({ error: 'invalid payload' });
         }
     });
-    // Metrics + logs — accept and ignore
+    app.post('/v1/logs', (req, res) => {
+        try {
+            processClaudeLogs(req.body, defaultSessionId, projectId);
+            res.status(200).json({ partialSuccess: {} });
+        }
+        catch (e) {
+            console.error('[OTLP] log parse error:', e);
+            res.status(400).json({ error: 'invalid payload' });
+        }
+    });
+    // Metrics remain accepted for Claude Code dashboards but are not trace entries.
     app.post('/v1/metrics', (_req, res) => res.status(200).json({ partialSuccess: {} }));
-    app.post('/v1/logs', (_req, res) => res.status(200).json({ partialSuccess: {} }));
-    console.log('  📡 OTLP receiver ready on /v1/traces');
+    console.log('  📡 OTLP receiver ready on /v1/traces and /v1/logs');
 }

package/dist/setup.js

@@ -1,5 +1,5 @@
 /**
- * copilot-tracer setup — auto-detect copilot CLI + VS Code and inject OTLP env config
+ * copilot-tracer setup — auto-detect Copilot/VS Code and inject OTLP env config
  *
  * What it does:
  *  1. Detect copilot CLI (which copilot)
@@ -16,12 +16,26 @@ import os from 'os';
 const OTEL_ENDPOINT_KEY = 'OTEL_EXPORTER_OTLP_ENDPOINT';
 const OTEL_CONTENT_KEY = 'OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT';
 const OTEL_ENABLED_KEY = 'COPILOT_OTEL_ENABLED';
+const CLAUDE_TELEMETRY_KEY = 'CLAUDE_CODE_ENABLE_TELEMETRY';
+const CLAUDE_TRACES_KEY = 'CLAUDE_CODE_ENHANCED_TELEMETRY_BETA';
+const OTEL_LOGS_EXPORTER_KEY = 'OTEL_LOGS_EXPORTER';
+const OTEL_TRACES_EXPORTER_KEY = 'OTEL_TRACES_EXPORTER';
+const OTEL_PROTOCOL_KEY = 'OTEL_EXPORTER_OTLP_PROTOCOL';
+const OTEL_LOG_PROMPTS_KEY = 'OTEL_LOG_USER_PROMPTS';
+const OTEL_LOG_RESPONSES_KEY = 'OTEL_LOG_ASSISTANT_RESPONSES';
 function otelEnvBlock(port) {
     return [
         `# >>> copilot-tracer OTLP config (auto-added) >>>`,
         `export ${OTEL_ENDPOINT_KEY}=http://localhost:${port}`,
         `export ${OTEL_CONTENT_KEY}=true`,
         `export ${OTEL_ENABLED_KEY}=true`,
+        `export ${CLAUDE_TELEMETRY_KEY}=1`,
+        `export ${CLAUDE_TRACES_KEY}=1`,
+        `export ${OTEL_LOGS_EXPORTER_KEY}=otlp`,
+        `export ${OTEL_TRACES_EXPORTER_KEY}=otlp`,
+        `export ${OTEL_PROTOCOL_KEY}=http/json`,
+        `export ${OTEL_LOG_PROMPTS_KEY}=1`,
+        `export ${OTEL_LOG_RESPONSES_KEY}=1`,
         ``,
         `# Tag every copilot prompt with the terminal folder it ran from, so the`,
         `# tracer can attribute it to the right project. OTLP carries no working-dir,`,
@@ -42,6 +56,22 @@ function otelEnvBlock(port) {
         `  export OTEL_RESOURCE_ATTRIBUTES`,
         `  command copilot "\$@"`,
         `}`,
+        ``,
+        `claude() {`,
+        `  local _wd`,
+        `  if command -v python3 >/dev/null 2>&1; then`,
+        `    _wd="$(pwd | python3 -c 'import sys,urllib.parse;print(urllib.parse.quote(sys.stdin.read().strip(), safe="/"))')"`,
+        `  else`,
+        `    _wd="$(pwd)"`,
+        `  fi`,
+        `  if [ -n "\${OTEL_RESOURCE_ATTRIBUTES:-}" ]; then`,
+        `    OTEL_RESOURCE_ATTRIBUTES="\${OTEL_RESOURCE_ATTRIBUTES},claude_code.working_dir=\${_wd}"`,
+        `  else`,
+        `    OTEL_RESOURCE_ATTRIBUTES="claude_code.working_dir=\${_wd}"`,
+        `  fi`,
+        `  export OTEL_RESOURCE_ATTRIBUTES`,
+        `  command claude "\$@"`,
+        `}`,
         `# <<< copilot-tracer <<<`,
     ].join('\n');
 }
@@ -50,6 +80,13 @@ function vscodeEnvBlock(port) {
         [OTEL_ENDPOINT_KEY]: `http://localhost:${port}`,
         [OTEL_CONTENT_KEY]: 'true',
         [OTEL_ENABLED_KEY]: 'true',
+        [CLAUDE_TELEMETRY_KEY]: '1',
+        [CLAUDE_TRACES_KEY]: '1',
+        [OTEL_LOGS_EXPORTER_KEY]: 'otlp',
+        [OTEL_TRACES_EXPORTER_KEY]: 'otlp',
+        [OTEL_PROTOCOL_KEY]: 'http/json',
+        [OTEL_LOG_PROMPTS_KEY]: '1',
+        [OTEL_LOG_RESPONSES_KEY]: '1',
     };
 }
 // ── Detection helpers ─────────────────────────────────────────────────────────
@@ -193,13 +230,13 @@ export function runSetup(port, silent = false) {
         const label = path.basename(profilePath);
         if (result.action === 'added') {
             console.log(`\n${CHECK} Shell profile patched: ${label}`);
-            console.log(`   ${ARROW} Added OTEL env vars (endpoint, content capture)`);
+            console.log(`   ${ARROW} Added Copilot + Claude Code OTLP env vars`);
             console.log(`   ${ARROW} Added copilot() wrapper — tags each prompt with the terminal folder`);
             console.log(`   ${ARROW} Run: source ${profilePath}`);
         }
         else if (result.action === 'updated') {
             console.log(`\n${CHECK} Shell profile updated: ${label}`);
-            console.log(`   ${ARROW} Updated port to ${port} + copilot() wrapper`);
+            console.log(`   ${ARROW} Updated port to ${port} + Claude Code/Copilot OTLP config`);
             console.log(`   ${ARROW} Run: source ${profilePath}`);
         }
         else {
@@ -231,6 +268,13 @@ export function runSetup(port, silent = false) {
     process.env[OTEL_ENDPOINT_KEY] = `http://localhost:${port}`;
     process.env[OTEL_CONTENT_KEY] = 'true';
     process.env[OTEL_ENABLED_KEY] = 'true';
+    process.env[CLAUDE_TELEMETRY_KEY] = '1';
+    process.env[CLAUDE_TRACES_KEY] = '1';
+    process.env[OTEL_LOGS_EXPORTER_KEY] = 'otlp';
+    process.env[OTEL_TRACES_EXPORTER_KEY] = 'otlp';
+    process.env[OTEL_PROTOCOL_KEY] = 'http/json';
+    process.env[OTEL_LOG_PROMPTS_KEY] = '1';
+    process.env[OTEL_LOG_RESPONSES_KEY] = '1';
     // 6. Summary
     if (!silent) {
         const profileBase = profilePath ? path.basename(profilePath) : '.zshrc';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-tracer",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Real-time tracing and prompt-refinement companion for GitHub Copilot CLI and VS Code Copilot — tracks tokens, AI credits, tool calls, and refined prompts with console and web UI",
   "keywords": [
     "copilot",
@@ -14,7 +14,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/chuongnd/copilot-tracer.git"
+    "url": "https://github.com/chuongxl/copilot-tracer.git"
   },
   "engines": {
     "node": ">=18"