Trace Viewer for OpenTelemetry, Jaeger & Zipkin JSON

About the Trace Viewer for OpenTelemetry, Jaeger & Zipkin JSON

Open a trace export — OTLP/JSON from an OpenTelemetry collector or SDK (also one request per line, as the collector’s file exporter writes), the JSON the Jaeger UI downloads, or Zipkin v2 JSON — and read it as a waterfall coloured by service, with every span’s attributes, resource, events and links a click away. Files up to about 100 MB are read in a background worker; a file with several traces lists them, and spans whose parent is missing and children that start before their parent (clock skew between hosts) are pointed out.

Beyond the waterfall you get the critical path (the chain of work the end of the trace waited for), self time per service and operation, the error spans, N+1 patterns (five or more similar calls one after another under one parent, database statements grouped with their values replaced), and a comparison with a second trace, operation by operation. Spans that follow the OpenTelemetry GenAI conventions or OpenInference become a readable timeline of model and tool calls with their messages, token totals per model and a cost estimate at the prices you enter.

Nothing is uploaded. Without a pass the result is a free preview: the waterfall of the first spans (up to 50, and at most half of a smaller trace) and the totals of the whole trace; the full waterfall, the tables, the LLM timeline and the exports (SVG and PNG pictures, a Markdown summary, a sanitised copy) unlock with a Pro pass.

Common uses

• Finding the slow part of a request when the tracing backend is not at hand, or the trace came from a colleague or a customer.
• Spotting N+1 queries and retries that a trace shows but a dashboard hides.
• Reading what an LLM agent did — each model call, tool call and message — and what its tokens cost.
• Comparing a slow and a fast run of the same request, operation by operation.
• Sharing a trace without its cookies, API keys, prompts or customer data.

What the viewer reads

• OTLP/JSON: resourceSpans → scopeSpans → spans, with hex trace and span ids and times in Unix nanoseconds as strings or numbers, as the OTLP specification defines its JSON encoding. Files with base64 ids (against the spec, but some exporters write them) and the older instrumentationLibrarySpans are read too, and the page says so.
• Jaeger: data[] with spans (references, startTime and duration in microseconds, tags, logs) and processes. This is the format the Jaeger UI uses internally, which Jaeger itself documents as unofficial; Jaeger’s documented v3 query API answers in OTLP/JSON, which is read as OTLP.
• Zipkin v2: an array of spans (or of traces) with traceId, id, parentId, timestamp and duration in microseconds, localEndpoint.serviceName, tags and annotations.

Times are kept exact to the nanosecond: OTLP’s 19-digit nanosecond values are read as whole numbers before anything is subtracted.

Critical path and self time

The critical path starts at the end of the main root span and walks back: the time belongs to the child that finished last before that point, then — inside that child — to its own last child, and so on; between children it belongs to the parent itself. A child that runs longer than its parent is clipped to its parent first, so asynchronous work and clock skew cannot stretch the path. This is the method the Jaeger UI uses. Self time is a span’s duration minus the time its children cover (overlapping children counted once), which tells you where the work itself happened rather than where it waited.

LLM and agent spans

Model calls are read from the OpenTelemetry GenAI attributes — gen_ai.operation.name, gen_ai.request.model and gen_ai.response.model, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens and gen_ai.usage.cache_read.input_tokens, gen_ai.response.finish_reasons, gen_ai.response.time_to_first_chunk, and the opt-in gen_ai.input.messages, gen_ai.output.messages and gen_ai.system_instructions — and from the names older instrumentations used (gen_ai.system, gen_ai.usage.prompt_tokens, the indexed gen_ai.prompt.0.content and gen_ai.completion.0.content, the gen_ai.content.prompt and gen_ai.content.completion events). OpenInference spans are read from openinference.span.kind, llm.model_name, llm.token_count.prompt and .completion and the indexed llm.input_messages and llm.output_messages. The GenAI conventions are still marked as in development, so names may change; the viewer reads both. Cached input tokens are part of the input count, and are charged at the cached price when you enter one.

Sources

• OTLP specification — the JSON encoding of traces
• GenAI semantic conventions — the gen_ai.* attributes
• OpenInference semantic conventions — the llm.* attributes
• Zipkin API — the v2 span model
• Jaeger APIs — the internal JSON and the v3 query API

Limitations

• The viewer reads exported files; it does not connect to a collector, Jaeger or Zipkin.
• Very large files (hundreds of thousands of spans) take a moment and a good deal of memory on a phone; the waterfall then shows 400 rows at a time. Values longer than 20,000 characters are shortened in the viewer (the sanitised copy keeps them whole).
• Times are shown as the hosts recorded them: clock skew is reported, not corrected.
• The N+1 check groups calls by name or by their database statement; calls whose statements differ in more than their values are not grouped.
• Costs use only the prices you enter; the viewer knows no price list.
• The sanitised copy rewrites attribute values (of spans, resources, events and links); span names, status messages and exception messages stay as they are, so read them before you share the file.
• OTLP times written as JSON numbers instead of strings keep only the precision a JSON number has, about a quarter of a microsecond, in the viewer and in the sanitised copy.

Privacy

On this device: nothing is sent

Everything happens in your browser. What you enter or open here is not uploaded or stored by MySmartCoPilot.