Observability
Observability is the ability to infer a system’s internal state and behavior from its externally available outputs, such as logs, metrics, and traces.
Effective Platform Engineering
Observability is the ability to determine and explain a software system’s internal state and usefulness from its output data.
- How it is used
- Uses output data to diagnose platform and product behavior and demonstrate value to engineering and business stakeholders.
- How deep it goes
- Defines observability, distinguishes it from monitoring, and outlines an incremental implementation sequence without specifying a complete deployment.
- Examples
- Uses failed scheduled tasks, delayed business reports, isolated dashboards, and Kubernetes outages to expose visibility gaps.
- What you can do after
- Build it from scratch incrementally by setting goals, instrumenting code, verifying collection, designing shared access, and assigning responsibility.
Read how Effective Platform Engineering explains observability →
Secure APIs
API observability is the ability to infer the health, behavior, and security-relevant activity of APIs from their telemetry.
- How it is used
- Uses telemetry to understand API behavior, detect threats, investigate incidents, and support timely response and recovery.
- How deep it goes
- Explains observability through logs, traces, metrics, instrumentation, threat signals, and sensitive-data filtering, while deferring detailed implementation beyond focused examples.
- Examples
- Uses endpoint error rates, request traces, malicious input, unauthorized responses, response latency, and filtered order-request logs as concrete examples.
- What you can do after
- Diagnose/debug with it by correlating telemetry, reproducing suspicious requests, identifying malicious activity, and excluding sensitive data from logs.
Grokking AI Applications
The capability to understand an application's internal behavior from its outputs, telemetry, logs, traces, and related runtime signals.
- How it is used
- Makes multi-agent GenAI behavior visible so developers can debug, troubleshoot, and improve tool orchestration.
- How deep it goes
- Demonstrates LangSmith setup and a visual execution trace, without detailing telemetry internals.
- Examples
- Visualizes HungryTraveler coordinating itinerary and recipe agents in a LangSmith trace.
- What you can do after
- Diagnose/debug agent behavior by inspecting its orchestration steps in LangSmith.
Cloud Observability in Action
Observability is the capability to infer and continuously discover a system’s internal state from externally available signals in order to influence that system.
- How it is used
- Guides teams from telemetry collection to actionable decisions about cloud-native systems, incidents, performance, costs, and user experience.
- How deep it goes
- Defines sources, signals, agents, destinations, and telemetry, then demonstrates correlation and operational trade-offs without detailing signal implementations.
- Examples
- Uses the Sock Shop Kubernetes application, shopping traffic, service logs, metrics, traces, dashboards, and role-based investigation flows.
- What you can do after
- Diagnose distributed-service problems, correlate signals, evaluate operational health, and influence systems through human or automated action.
Read how Cloud Observability in Action explains observability →
Microservices Patterns, Second Edition
Observability is the degree to which an application's runtime behavior and user-impacting effects can be understood from its externally visible outputs.
- How it is used
- Supports fast flow by providing production and user feedback and helping keep deployments safe.
- How deep it goes
- Defines observability through quality-attribute scenarios and outlines instrumentation and infrastructure responsibilities, while deferring detailed pattern descriptions.
- Examples
- Uses deployment error rates and latency, plus feature usage, to illustrate operational and user feedback.
- What you can do after
- Evaluate and understand production behavior and deployment outcomes using collected telemetry.
Read how Microservices Patterns, Second Edition explains observability →
Architecting an Apache Iceberg Lakehouse
Observability is the capability to infer a system's internal behavior and resource usage from its emitted telemetry and operational data.
- How it is used
- Supports reliable ingestion, maintainable orchestration, catalog operations, and governed self-service analytics.
- How deep it goes
- Connects metrics, logs, metadata queries, dashboards, and alerts to operational decisions, without specifying complete monitoring configurations.
- Examples
- Uses ingestion metrics, Iceberg metadata queries, external dashboards, query logs, and compaction failure logs.
- What you can do after
- Diagnose failures and emerging performance or storage problems through correlated logs, metrics, metadata, and alerts.
Read how Architecting an Apache Iceberg Lakehouse explains observability →
Acing the Frontend Interview
Observability is the ability to infer a system's internal behavior and health from its emitted telemetry.
- How it is used
- Uses production telemetry to diagnose frontend issues and connect testing, CI/CD, monitoring, and incident response.
- How deep it goes
- Explains logging, monitoring, error tracking, triage, and prevention, but does not descend into telemetry implementation internals.
- Examples
- Uses Winston, LogRocket, Datadog, New Relic, Sentry, test reports, telemetry, and production logs as concrete examples.
- What you can do after
- Diagnose production frontend issues, reproduce them, deploy targeted fixes, and prevent recurrence with tests or observability hooks.
Read how Acing the Frontend Interview explains observability →
Designing AI Systems
The ability to infer a system's internal behavior and health from its emitted telemetry and operational records.
- How it is used
- Unifies platform signals to explain request behavior, health, quality, and cost across AI workflows.
- How deep it goes
- Develops a telemetry architecture and custom instrumentation pattern while separating passive observation from active experimentation.
- Examples
- Uses patient intake latency, guardrail decisions, and a custom reranking span to illustrate operational visibility.
- What you can do after
- Diagnose workflow delays, safety decisions, and cost drivers using correlated telemetry.
Generative AI in Action
Observability is the practice of monitoring, logging, and tracing a system to understand its internal behavior and diagnose problems from its outputs and operational data.
- How it is used
- Supports production LLM application health, reliability, performance, and troubleshooting.
- How deep it goes
- Defines monitoring, logging, and tracing, then illustrates implementation with tools and a chat application.
- Examples
- Uses a Python chat-completion example, an MLflow and Prometheus configuration, and a Traceloop load test.
- What you can do after
- Apply it via MLflow to measure chat-completion latency and count tokens.
Machine Learning Platform Engineering
Observability is the ability to infer the internal state and behavior of a deployed system from its outputs and telemetry, including application-specific information flows.
- How it is used
- Supports production monitoring, diagnosis, optimization, cost control, and review across conventional ML services and LLM applications.
- How deep it goes
- Traces infrastructure, model, retrieval, generation, metadata, errors, costs, and latency, stopping short of detailed implementation beyond Langfuse integration.
- Examples
- Uses ID-card detection, movie recommendation, DakkaBot RAG traces, Langfuse dashboards, and BentoML health and metrics instrumentation.
- What you can do after
- Diagnose with Langfuse by tracing RAG steps, retrieval results, model calls, failures, latency, token usage, and estimated API costs.
Read how Machine Learning Platform Engineering explains observability →
Vibe Engineering
Automated observability is the machine-driven collection and analysis of signals that make a system's behavior, failures, and quality degradation detectable.
- How it is used
- Makes unattended agent failures and production behavior visible for intervention and ongoing evaluation.
- How deep it goes
- Explains operational checks, agent dashboards, and runtime signals, with a parser logging example rather than a complete observability implementation.
- Examples
- Uses a multi-agent pipeline dashboard and a parser that logs large inputs, exceptions, and slow requests.
- What you can do after
- Diagnose/debug agent stalls, cross-agent failures, bottlenecks, and production regressions using operational signals.
Architecting for Autonomy
Observability is the capability to infer a system’s internal state and behavior from its external outputs, telemetry, and traces.
- How it is used
- Supports live supervision of delegated autonomy rather than relying on incidents or delayed reviews.
- How deep it goes
- Explains architectural questions and decision patterns, without specifying telemetry implementation.
- Examples
- Uses diagnostic questions about explaining yesterday’s autonomous decisions and adjusting decision boundaries without redeployment.
- What you can do after
- Evaluate whether autonomous decisions remain visible and aligned with their approved authority.
Automating API Delivery
Observability is the ability to query and analyze instrumented system behavior to determine the causes of previously unanticipated problems.
- How it is used
- Supports continuous production measurement by helping teams investigate unanticipated system problems.
- How deep it goes
- Defines observability and distinguishes it from predefined monitoring, without detailing instrumentation or tool setup.
- Examples
- Uses event data and logs as telemetry, alongside predefined metrics, dashboards, and alerts as monitoring artifacts.
- What you can do after
- Diagnose previously unanticipated production problems by querying and analyzing instrumented system behavior.
Troubleshooting Java, Second Edition
Observability is the ability to infer a system's internal behavior from its emitted telemetry and other external outputs.
- How it is used
- Uses telemetry to debug failures, monitor health, analyze performance, and follow requests across complex architectures.
- How deep it goes
- Explains instrumentation, export, collection, and visualization, then applies traces and percentiles to a timeout failure.
- Examples
- Uses a missing-order investigation and a frontend-to-order-service timeout mismatch with trace durations and latency percentiles.
- What you can do after
- Diagnose distributed failures by instrumenting services, inspecting traces, and comparing observed latency with configured timeouts.
Read how Troubleshooting Java, Second Edition explains observability →
Context Engineering
Observability is the ability to understand a system's internal behavior through signals such as logs, traces, and metrics.
- How it is used
- Explains context-aware system behavior and connects evaluation failures to runtime evidence.
- How deep it goes
- Defines telemetry pillars, contrasts monitoring with observability, and gives instrumentation and operational guidance for AI systems.
- Examples
- Demonstrates a Langfuse-traced tool-using agent and a LangSmith chain that traces context selection.
- What you can do after
- Diagnose context-related failures using Langfuse traces and correlate runtime evidence with evaluation results.
AI Agents in Action, Second Edition
Observability is the practice of inferring and diagnosing a software system's internal state from its externally emitted telemetry.
- How it is used
- Supports debugging, incident resolution, evaluation, optimization, and production monitoring for agentic systems.
- How deep it goes
- Defines traces, metrics, and logs with implementation guidance, but stops short of detailed backend configuration.
- Examples
- Uses Phoenix dashboards, OpenTelemetry traces, correlation metadata, structured logs, evaluator checks, and deployment feedback systems.
- What you can do after
- Diagnose/debug with it by tracing interactions, correlating failures, measuring outcomes, and evaluating changes against curated tests.
Read how AI Agents in Action, Second Edition explains observability →
The Coder Cafe
Observability is the ability to infer a system's internal state from telemetry across diverse and previously unforeseen conditions.
- How it is used
- Guides investigation and decision-making in complex systems where unknown states and failures are inevitable.
- How deep it goes
- Defines telemetry-based state discovery and explains its consequences, but stops short of specifying telemetry implementations.
- Examples
- Uses high-cardinality telemetry, unexpected failures, novel system states, and controlled production changes as practical contexts.
- What you can do after
- Diagnose unexpected system behavior and evaluate changes without shipping new diagnostic code.
AI Model Evaluation
The extent to which a system's internal state can be inferred from its outputs, logs, and other external signals.
- How it is used
- Supports reliable evaluation and production serving by exposing failures, drift, cost, latency, and user-facing risk.
- How deep it goes
- Specifies four monitoring dimensions and concrete logging practices, but stops short of defining a complete dashboard or alert policy.
- Examples
- Uses dashboards, alerts, prompt versions, output hashes, weekly canaries, billing metrics, Prometheus counters, Grafana, and DataDog.
- What you can do after
- Operate evaluation pipelines with reproducible logs, drift detection, cost controls, latency visibility, alerts, and safer online testing.
Grokking Software Architecture
Observability is the practice of making a distributed system's internal state inferable from externally emitted telemetry.
- How it is used
- Frames observability as a runtime quality for seeing what a running system is doing and maintaining software.
- How deep it goes
- Defines observability through logs, metrics, and traces, then ties telemetry and correlation IDs to service failures without detailing instrumentation.
- Examples
- Uses Apollo 13 telemetry and a correlated OrderService crash and ShippingService error as illustrations.
- What you can do after
- Understand how telemetry and correlation IDs help infer system behavior and connect distributed-service errors.
Read how Grokking Software Architecture explains observability →
Logs and Telemetry
Observability is the ability to understand a system's internal state from externally emitted telemetry such as logs, metrics, and traces.
- How it is used
- Uses aggregated telemetry to diagnose failures, understand distributed behavior, and maintain operational awareness.
- How deep it goes
- Explains telemetry types, cross-system aggregation, and operational purpose without detailing instrumentation implementation.
- Examples
- Uses database storage failures, distributed applications, cross-service transactions, and automated build pipelines as operational examples.
- What you can do after
- Diagnose failures by preserving, aggregating, and correlating telemetry across distributed systems.
Digital Twins in Action
Observability is the ability to understand a system's internal condition and behavior from its externally generated outputs and operational signals.
- How it is used
- Supports explaining digital twin behavior and tracing discrepancies during production operation.
- How deep it goes
- Explains logs, metrics, and traces with querying, instrumentation, alerting, and a production-readiness checklist.
- Examples
- Uses temperature prediction drift, a structured log query, and a hallway motion-to-light trace.
- What you can do after
- Diagnose/debug digital twin behavior by correlating logs, monitoring prediction differences, and tracing event latency.
Google Anthos in Action
Observability is the ability to understand a system's internal state from the outputs it produces, such as metrics, logs, and traces.
- How it is used
- Provides operational visibility across microservices, workloads, dependencies, and customer journeys.
- How deep it goes
- Explains proxy-based collection, monitoring destinations, dashboards, topology, and SLOs without detailing telemetry schemas or instrumentation internals.
- Examples
- Uses Anthos Service Mesh dashboards, topology maps, traffic-flow logs, service dependencies, and customer-journey SLOs.
- What you can do after
- Apply it via Anthos Service Mesh to inspect service relationships, review telemetry, and evaluate SLO and SLA impact without changing application code.
AI Agents in Action
Observability is the collection and analysis of execution signals that reveal an agent system's behavior, performance, and failures.
- How it is used
- Uses application tracing to inspect agent interactions and understand problems in complex multi-agent systems.
- How deep it goes
- Configures AgentOps installation, API-key setup, and initialization, then inspects run metrics in a dashboard.
- Examples
- Demonstrates a joke-writing crew dashboard and a customer-review sentiment analysis task.
- What you can do after
- Operate/configure it by connecting AgentOps to CrewAI and inspecting agent interactions, performance, cost, and output accuracy.
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
Observability is the practice of exposing and analyzing detailed telemetry to understand a system's internal behavior from its external outputs.
- How it is used
- Supports production monitoring, incident investigation, and reliability work across distributed microservices.
- How deep it goes
- Defines telemetry, querying, visualization, and correlation, but stops short of implementation code.
- Examples
- Uses Honeycomb traces and questions about users, regions, requests, messages, and error locations.
- What you can do after
- Diagnose/debug distributed failures by querying telemetry, correlating service interactions, and locating problematic microservices.
Building Distributed Applications that Work
Observability is the capability to infer the internal behavior and condition of a system from its externally emitted telemetry.
- How it is used
- Uses telemetry to verify distributed workflows and diagnose failures across service boundaries.
- How deep it goes
- Identifies logs, metrics, and distributed traces and explains their diagnostic role, but does not specify instrumentation steps here.
- Examples
- Follows a shopper’s request through a storefront, API, data stores, and background-processing components.
- What you can do after
- Diagnose/debug with it by following requests across services and identifying failures or performance bottlenecks.
Read how Building Distributed Applications that Work explains observability →
Also covered in
- Spring AI in Action
- First-Party Data Activation
- Build High Value Software SystemsIn early access (MEAP)
- gRPC Microservices in Go
- Software Testing with Generative AI
- Quarkus in Action
- Software Architecture Decision-MakingIn early access (MEAP)
- Architecture Modernization: Socio-technical alignment of software, strategy, and structure
- Learn Docker in a Month of Lunches, Second Edition
- Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
- AI GovernanceIn early access (MEAP)
- Microsoft Azure in Action
What to know first
- monitoringMonitoring is the ongoing observation and measurement of a system or process to assess its behavior or condition and detect changes, failures, or other problems.
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
- meanThe mean is a measure of central location equal to the arithmetic average of numerical observations, or the probability-weighted average of a random variable’s possible values.
Related concepts
- trajectoryhas part · A trajectory is an ordered record of states, actions, events, or operations showing how an agent or system progresses through an execution or process.
- monitoringhas part · Monitoring is the ongoing observation and measurement of a system or process to assess its behavior or condition and detect changes, failures, or other problems.
- telemetryuses · Telemetry is machine-generated or automatically collected data describing a system’s operation, behavior, state, or performance.
- OpenTelemetryimplemented by · OpenTelemetry is an open, vendor-neutral observability standard and framework for instrumenting software and generating, collecting, and exporting telemetry such as traces, metrics, and logs.
- performanceuses · Performance is a measure of how effectively a person, process, model, or system achieves its objectives, including qualities such as output quality, speed, and resource efficiency.
- loghas part · A log is a time-ordered record of events, messages, or activity generated by a system or process.
Questions about observability
What is observability?
Observability is the ability to infer a system’s internal state and behavior from its externally available outputs, such as logs, metrics, and traces.
Which Manning books explain observability?
Effective Platform Engineering, Secure APIs, Grokking AI Applications, Cloud Observability in Action, Microservices Patterns, Second Edition, Architecting an Apache Iceberg Lakehouse, Acing the Frontend Interview, Designing AI Systems and 17 more.
What should I know before learning observability?
Manning books that teach observability usually introduce monitoring, language model, deployment pipeline and mean first.
What are the parts of observability?
Observability includes trajectory, monitoring and log.
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.
























