Visualize Spans and Traces

Overview

When you open a trace or a span in Explore tracing, the drilldown drawer provides multiple ways to analyze the same request. Each view highlights a different aspect of the trace so you can move from high-level architecture to precise root cause without losing context.

These views are designed for investigation, not just visualization:

• Dependencies shows who talks to whom (services or spans) and how the request moves through your architecture.
• Flame shows where time is spent by highlighting the biggest contributors to end-to-end latency.
• Gantt shows when things happened by showing the true timing, ordering, and overlap of operations.

The Action bar stays consistent across views, so you can search, filter, and navigate results the same way no matter which perspective you’re using.

How to navigate

1. Select a trace or span in Explore Tracing to open the trace drilldown.
2. Select your preferred visualization mode—Dependencies, Gantt, or Flame view—to explore varied views of the span data.

How these views speed up investigations

Together, the Action bar + views enable a fast, repeatable workflow:

• Find what matters (Search / Highlight errors).
• Navigate confidently (Next/previous highlights, zoom/pan, maximize).
• Switch perspectives without losing context (Dependencies ↔ Flame ↔ Gantt).
• Drill down from architecture → hotspot → exact timing to reach root cause faster.

Action bar

The Action bar provides a set of global controls shared across trace views. Use it to keep your investigation focused while switching between Dependencies, Flame, and Gantt.

Some controls appear only in certain views (for example, depth in Gantt, rerouting in Flame, grouping in Dependencies).

Search

Search for any key or value across the trace (for example: service name, operation, span attribute, URL, host, error message).

Use it to

• Quickly find the span/service you care about in large traces.
• Reduce noise by focusing attention on a subset of relevant elements.

What to expect

• When search is active, non-matching elements are visually de-emphasized (dimmed), making matches easier to spot.
• Use navigation controls to jump between matches.

Show errors

Highlight spans that contain errors and show the count of error spans.

Use it to

• Immediately see where failures occur in the trace.
• Prioritize investigation on spans most likely to explain user impact.

Navigate matches

Move between highlighted results (internal spans, errors, search matches) and keep the graph focused on the current selection.

Use it to

• Move through matches sequentially instead of scanning the trace manually.
• Stay oriented in large traces by keeping the current match in view.

Internal spans toggle

Show or hide internal spans.

Use it to

• Hide internal spans to simplify the view and focus on service-to-service behavior and major boundaries.
• Show internal spans when you need detailed implementation context inside a service.

Color by and Legend

Color spans/services by a chosen dimension (such as duration, operation, or service). From the menu, select Color by and use the legend to understand what the colors mean.

Use it to

• Visually cluster related work and spot outliers faster.
• Understand what "hot" or "unhealthy" spans represent at a glance.

Zoom and pan

All trace views support zooming and scrolling when content exceeds the viewport.

Use it to

• Navigate from the full request (macro) to a suspicious region (micro).
• Inspect dense traces without losing your place.

Expand view

Expand the drilldown visualization area to use the full screen.

Use it to

• Reduce clutter and increase visibility for dense graphs.
• Make complex traces easier to read and navigate.

Aggregation (Dependencies only)

Choose the aggregation used for the Dependencies view.

Use it to

• Switch the question you’re asking about connections (for example, focusing on "worst case" vs "typical" behavior).
• Align the map with your investigation goal (finding spikes vs patterns).

Group by (Dependencies only)

Group the Dependencies view using selected tags/fields (and pair with an aggregation when relevant).

Use it to

• Reorganize the map around the dimension that explains the issue (service, operation, environment tags, etc.).
• Surface patterns like repeated calls, heavy fan-out, or hotspots within a group.

Change trace layout (Flame only)

Rotate the flame chart orientation (top-down or upside-down). From the menu, select Trace layout, then Flame or Icicle to match your preferred reading direction.

Use it to

• Focus on the part of the trace you’re investigating (a specific service path or span chain).
• Make large traces easier to understand by emphasizing a relevant route.

Depth (Gantt only)

Control how much of the hierarchy is expanded/collapsed. To set it up, select Depth from the menu.

Use it to

• Collapse noise and focus on top-level structure.
• Expand only as deep as needed to validate a suspected path.

Manage columns (Gantt only)

Customize which columns appear alongside the timeline table.

Use it to

• Bring critical context (service, operation, status, tags) into view while investigating timing.
• Add the fields you rely on most during troubleshooting.

How investigations flow across views

A common workflow that gets to root cause quickly:

1. Start in Dependencies (Service view) to understand which parts of the architecture were involved.
2. Switch to Flame to find the biggest contributors to latency and identify likely bottlenecks.
3. Open Gantt to confirm the true timeline (ordering, overlap, gaps, and concurrency).
4. Drill into the selected span/service details to validate errors, attributes, events, and correlated logs.

Since the view state is preserved while switching, you can iterate without losing your place.

Dependencies view

Use Dependencies to understand how the request flows through your system - either at the service level (architecture and handoffs) or at the span level (exact operations and call trajectory).

This view is especially useful when you want to answer:

• "Which service called what, and in what order?"
• "Where does the request fan out or bottleneck?"
• "Which dependency is failing or adding latency?"
• "Is this a single bad operation or a broader service-to-service issue?"

Service view

Service view summarizes the trace as a service-to-service map.

Use it to

• Validate the route of the request across microservices.
• Spot unexpected fan-out, extra hops, or indirect routing.
• Identify the dependency edge that looks slow or failing and drill into it.

Drilldown actions

• Select a service node to open the Info panel and drill into its underlying spans (incoming, outgoing, internal).
• From the panel, select a span to investigate errors, attributes, events, and correlated logs for the operation.

Edge metrics

Choose what an edge represents (for example: span count vs. duration) depending on the question you’re asking:

• Span count → fan-out / repeated calls
• Duration metric → slow handoffs between services

Span view

Span view shows the trace as a sequence of spans so you can follow the exact operations underlying the service interactions.

Use it to

• Pinpoint the specific operation responsible for a bottleneck or error.
• Understand how the trace branches and converges.
• Validate the downstream chain under a particular operation.

Drilldown actions

• Hover to preview key context (service + operation + timing).
• Select edges/links to review repeated interactions and compare durations.
• Use Group By + aggregation to reorganize the view around what matters (max for worst offender, avg for consistent slowness, sum for cumulative repeated cost).

Flame view

Use Flame when you want to answer: “Where did the time go?”

Flame visualizes spans as a flame graph so you can quickly identify:

• The biggest contributors to latency.
• Slow operations hidden inside deep call stacks.
• Services or operations dominating end-to-end time.

Flame is not a strictly time-based layout like Gantt. It’s designed to highlight dominant contributors and the structure of execution.

Visualization (how to read it)

• Width = duration of the span.
• X-axis = execution time position. X-axis does not represent time. Spans are arranged horizontally to highlight hierarchy and latency contribution, while Gantt should be used to analyze the exact timing and ordering of operations.
• Y-axis = hierarchy:
  • Height reflects nesting level (parent/child spans).
  • Helps distinguish parent waiting time vs child execution time, and makes blocking vs async work easier to interpret.

Tooltip (what you learn on hover)

Hover a span to see key investigation context, such as:

• Service name + type
• Operation name, application, subsystem
• Duration and % of total trace
• Error details (status + message), when present

Drilldown actions

• Select a span to focus your investigation and open span details in the side panel.
• Use search + highlight to locate repeated patterns (for example: repeated DB call, specific endpoint, particular host).
• Use color + legend to cluster related work (for example: by service or duration bands).

Gantt view

Use Gantt when you want to answer: “What happened in this trace timeline?”

Gantt represents spans as a true timeline chart so you can understand:

• Exact ordering of operations
• Overlap and concurrency (what ran in parallel vs. sequentially)
• Gaps, waiting time, and blocking behavior

Visualization (how to read it)

• X-axis = time progression, starting at 0 (trace start) through total trace duration.
• Each row = a span.
• Bar position shows when a span started relative to the trace start.
• Bar length shows the span’s duration.

Tooltip (what you learn on hover)

Hover a bar to get quick context such as:

• Service name + type
• Operation name, application, subsystem
• Duration and % of total trace
• Error details (status + message), when present
• Relevant events (when available)

Events

When drilling into a specific trace or span, Gantt view displays events directly on the timeline. Quickly understand what happened at each point in the execution flow without leaving the trace.

Gantt view surfaces events from:

• HTTP requests

• gRPC calls

• Database operations

• Span-level events

Events are displayed directly within the relevant spans on the timeline, with each event appearing at its exact timestamp.

Hovering over any event instantly reveals all relevant details, speeding up investigations and reducing MTTR. For example, for an HTTP request you’ll see service, operation, http.method, http.status_code, and http.url. Easily copy values such as URLs or queries for further analysis.

Drilldown actions

• Select a span to open span details in the side panel and validate the full context (errors, attributes, events, correlated logs).
• Follow the downstream path to understand what the selected span triggered next.
• Use highlight and navigation to walk through errors or search matches in time order.