liveBook · Manning

Span

A span is a record of an individual operation within a trace, typically including its timing, context, outcome, and relationships to other operations.

How 6 Manning books explain it

Troubleshooting Java, Second Edition

A span is a recorded unit of work within a distributed trace, including its operation, timing, service, and associated metadata.

How it is used
Uses spans to reconstruct distributed request paths, compare service timing, and isolate failures across multi-hop workflows.
How deep it goes
Explains span relationships, fields, durations, and diagnostic patterns, but stops short of detailed tracing implementation internals.
Examples
Uses checkout traces, Kafka order processing, repeated payment attempts, and client-server timeout timelines.
What you can do after
Diagnose/debug with spans by tracing requests, interpreting timing, identifying retries, and comparing client-server behavior.

Read how Troubleshooting Java, Second Edition explains span →

Cloud Observability in Action

A span is a timed record of an individual operation or service segment within a distributed trace.

How it is used
Uses spans to visualize distributed request execution, investigate latency, troubleshoot failures, and correlate observability signals.
How deep it goes
Defines span structure, identifiers, propagation, sampling, visualization, and troubleshooting, while deferring backend-specific implementation details.
Examples
Uses checkout, billing, payment-provider, Go HTTP, happy-path, and injected-failure examples to demonstrate span timing and diagnosis.
What you can do after
Diagnose/debug with Jaeger by locating slow or failed services and comparing their spans with a healthy trace.

Read how Cloud Observability in Action explains span →

Quarkus in Action

A span is a recorded unit of work within a trace, such as a method invocation, database invocation, or remote request.

How it is used
Uses spans to follow individual operations within distributed requests and locate failures or slow processing.
How deep it goes
Defines span and trace IDs, nesting, and cross-service correlation, then shows how to inspect spans in Jaeger.
Examples
Shows a REST call with two database spans and a car-availability trace spanning three services.
What you can do after
Diagnose/debug with it by inspecting span relationships, timing, and request tags in Jaeger.

Read how Quarkus in Action explains span →

Secure APIs

A span is a recorded unit of work representing a step in the processing of a request or operation.

How it is used
Uses spans to observe API request processing, investigate errors, and expose security-relevant business-layer activity.
How deep it goes
Explains span structure, trace correlation, exception capture, and custom creation with attributes, without developing broader tracing internals.
Examples
Demonstrates GET /books request spans and a cart.create custom span containing user and cart attributes.
What you can do after
Diagnose/debug with it by correlating request events, inspecting attributes, and reconstructing exceptions through trace IDs.

Read how Secure APIs explains span →

gRPC Microservices in Go

A span is a timed record of one operation within a distributed trace, including its metadata and relationships to other operations.

How it is used
Uses spans to inspect individual operations along a request’s path across microservices.
How deep it goes
Defines spans as single-operation records and examines their metadata and timings, while demonstrating interceptor setup rather than manual span creation.
Examples
Examines create-order, Payment Create, and database spans with operation timings, gRPC metadata, and a SQL statement.
What you can do after
Diagnose/debug with it by comparing operation durations and inspecting span metadata in Jaeger.

Read how gRPC Microservices in Go explains span →

Spring AI in Action

A span is a timed record of one operation or component segment within a distributed trace.

How it is used
Uses spans to trace AI request handling across application components, vector-store operations, RAG processing, and model calls.
How deep it goes
Examines nested operations and span tags for diagnosis, but does not detail span creation or trace internals.
Examples
Uses the POST /ask trace, Qdrant query and add spans, RAG processing, and GPT-4o-mini calls.
What you can do after
Diagnose request behavior with Jaeger by inspecting span hierarchies and tags.

Read how Spring AI in Action explains span →

Related concepts

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.