Claude Code observability with OpenObserve: end-to-end guide

⚡ Quick Answer

Claude Code observability means capturing what the agent actually executed, not just what it says it did. OpenObserve gives teams end-to-end AI observability by collecting tool calls, token usage, file changes, latency, and cost in one searchable pipeline.

Why Claude Code observability matters more than agent narration

Claude Code observability matters more than agent narration because summaries compress the story, while telemetry gives you evidence. That's the split that decides whether you debug an incident in minutes or lose a day guessing. A coding agent might say it "updated the test suite," but the trace could reveal three failed shell commands, an unexpected package install, and a write to a config file nobody meant to touch. That's the real event. Honeycomb, Datadog, and OpenTelemetry have been teaching this lesson for years in distributed systems, and AI agents need the same scrutiny now. We'd put it plainly: if you trust the agent's recap over the trace, you're picking narrative comfort over operational truth. Worth noting. Take GitHub Actions as a concrete example. When a repo automation task quietly edits a workflow file, the line between a harmless tweak and a supply-chain risk sits in the file diff and tool-call lineage, not the closing chat message.

How OpenObserve Claude Code integration works end to end

OpenObserve Claude Code integration works by ingesting structured events from the agent runtime and indexing them for search, dashboards, and alerts. The event shape isn't trivial. At minimum, you want task IDs, session IDs, prompt and completion token counts, model name, tool name, tool arguments, exit status, latency, file paths touched, diff summaries, and cost estimates for each action. OpenObserve supports logs, metrics, and traces in one platform, so it fits this job well because AI coding agents emit all three at once. Simple enough. And if you're already working with OpenTelemetry collectors, you can route agent events through a familiar pipeline instead of building custom plumbing from scratch. We think that's the pattern to reach for: treat Claude Code like another production service, but add agent-specific fields that standard APM tools won't capture by default. Here's the thing. Once indexed, that same event stream can answer practical questions, like which prompt patterns trigger expensive retries or which repositories post the highest failure rate per tool call. That's a bigger shift than it sounds.

What telemetry should you track for AI agent telemetry monitoring?

AI agent telemetry monitoring should track execution lineage, cost, latency, and artifact changes, not just chat transcripts. Start with a canonical schema. We recommend four event families: session events, model events, tool events, and artifact events. Session events record user, repo, branch, and task intent. Model events capture token counts, stop reasons, and model versions. Tool events log command execution, permissions, and results. Artifact events store file diffs, test outcomes, and deployment side effects. OpenTelemetry semantic conventions don't yet cover every AI coding detail, so teams usually need a custom namespace for fields like diff_stats, approval_required, and retry_reason. That's fine. Probably necessary. A concrete example makes the case: if Claude Code runs ripgrep, edits three Python files, and opens a pull request, your trace should show that exact chain so an engineer can replay the task path without reading the entire chat log. We'd argue that's consequential.

How to track Claude Code token cost and task-level spend

To track Claude Code token cost well, tie every model call and tool action back to a task-level cost record with timestamps and repository context. Raw token totals won't cut it. Finance and engineering leaders care about cost per bug fix, cost per generated test, and cost per successful merge-ready task. So you need pricing tables by model version, estimated or exact token usage, and rollups that group spend by team, repo, workflow, and user. OpenObserve dashboards can handle that if your event schema includes normalized cost_usd, token_input, token_output, and task_outcome fields. We'd argue per-task cost attribution is the sleeper feature in Claude Code observability, because it turns AI coding from vague spend into measurable unit economics. Not quite flashy. But when one repository suddenly costs 3x more per accepted change, the trace usually points to the reason: looping tool calls, oversized context windows, or retries after permission prompts. Worth watching.

Step-by-Step Guide

1. 1

   Define an agent event schema

   Create a JSON schema for session, model, tool, and artifact events before shipping any instrumentation. Keep field names stable. Include task_id, session_id, repo, branch, user, model, token counts, cost, tool arguments, exit status, and changed files so later dashboards don't become a cleanup project.

2. 2

   Instrument Claude Code execution hooks

   Capture events at the point where Claude Code starts a task, calls a tool, receives output, writes files, and ends a run. Emit structured logs, not plain strings. If approval prompts exist in your workflow, log prompt type, wait time, and user decision because those pauses often explain odd latency and cost patterns.

3. 3

   Send telemetry into OpenObserve

   Use OpenObserve ingestion endpoints directly or route events through an OpenTelemetry collector if you already run one. Batch where you can. But don't delay critical security-relevant events such as shell execution failures or writes to CI configuration files.

4. 4

   Build task and cost dashboards

   Create dashboards for task success rate, median latency, token usage, spend by repo, and tool failure rate. Add a panel for file types changed per task. That one sounds minor, yet it quickly surfaces when an agent starts touching infrastructure or secrets-related files more often than expected.

5. 5

   Create trace views for incident review

   Build a view that lets engineers follow one task from prompt to tool call to file diff to final summary. This is the heart of end-to-end AI observability. When incidents happen, the team needs a replayable path, not a pile of disconnected logs.

6. 6

   Alert on risky agent behaviors

   Set alerts for repeated tool retries, abnormal spend spikes, edits to protected paths, long approval waits, and failed tests after agent changes. Tune thresholds by repository and workflow. A build-tools repo should not alert like a docs repo, and a migration task should not alert like a typo fix.

Key Statistics

Frequently Asked Questions

• ✓Claude Code observability matters because agent summaries often leave out failed or risky execution paths.
• ✓OpenObserve Claude Code integration can track tokens, tool lineage, file diffs, and spend.
• ✓Telemetry beats narration when debugging incidents, governance gaps, or strange agent behavior.
• ✓Per-task cost attribution makes AI coding agents easier to budget and compare.
• ✓Dashboards and alerts turn raw traces into something engineers can actually act on.