liveBook · Manning

Log

A log is a time-ordered record of events, messages, or activity generated by a system or process.

How 21 Manning books explain it

Building Web APIs with ASP.NET Core

Logging is the recording of application events and diagnostic information for later inspection.

How it is used
Records web API events for later investigation, monitoring, and compliance.
How deep it goes
Defines logs and works through controller entries, severity levels, structured storage, file output, and verification.
Examples
Uses a board-game controller message, a Visual Studio Output entry, a LogEvents table, and a daily rolling file.
What you can do after
Operate/configure it by writing ILogger entries, setting Serilog destinations and levels, and checking the recorded events.

Read how Building Web APIs with ASP.NET Core explains log →

ASP.NET Core in Action, 3e

A structured log is a log record whose message details are represented as named fields, commonly as key-value pairs.

How it is used
Uses structured logs to make application events searchable for troubleshooting and pattern analysis.
How deep it goes
Explains placeholder capture, provider configuration, querying, and shared scope properties through practical examples.
Examples
Illustrates recipe counts and missing-recipe warnings with named fields, JSON output, and Seq queries.
What you can do after
Apply structured logging via ASP.NET Core ILogger and Seq to capture and search named event properties.

Read how ASP.NET Core in Action, 3e explains log →

Think Like a CTO

Logging is the recording of system or application events in persistent logs for monitoring, diagnosis, auditing, or analysis.

How it is used
Uses logs to monitor production, diagnose faults, audit activity, and investigate possible security breaches.
How deep it goes
Develops collection, review, data-handling, and incident-use decisions without specifying log formats or implementation code.
Examples
Illustrates risks with clear-text passwords in request logs and diagnosis with web-application SQL errors pointing toward database trouble.
What you can do after
Operate/configure it by centralizing and reviewing logs, masking sensitive values, and documenting signals that require action.

Read how Think Like a CTO explains log →

AI Model Evaluation

Logging is the practice of recording detailed information about system behavior, user interactions, and outcomes.

How it is used
Supports offline diagnostics, counterfactual evaluation, and interpretation of online experiments by preserving decisions and outcomes.
How deep it goes
Provides field-level logging checklists, quality checks, and latency trade-offs for evaluation workflows.
Examples
Uses a movie recommendation diagnostic schema and a search-ranking event with candidate products and action probabilities.
What you can do after
Operate/configure logging to capture evaluation-relevant decisions, outcomes, and serving paths while monitoring data quality.

Read how AI Model Evaluation explains log →

Acing the Frontend Interview

Structured logging records diagnostic events as consistently formatted fields, commonly in JSON, to support automated analysis.

How it is used
Supports production observability and incident triage alongside monitoring and client-side error tracking.
How deep it goes
Names structured logging and its diagnostic role but does not specify a record schema or configuration steps.
Examples
Uses a production-issue response and a Jest test that mocks a logger; the test does not demonstrate structured output.
What you can do after
Diagnose/debug with logs and telemetry to triage production issues and guide targeted fixes.

Read how Acing the Frontend Interview explains log →

Delivering Machine Learning Projects: From design to deployment

Logging is the recording of software or system events, states, and messages for operational analysis and troubleshooting.

How it is used
Supports production operations and troubleshooting for ML systems.
How deep it goes
Specifies events to capture and factors governing frequency, density, retention, and cost, without detailing a logging implementation.
Examples
Uses database connections, user logins, data updates, model decisions, and a Splunk integration as concrete examples.
What you can do after
Operate/configure logging alongside monitoring and alerts for production support.

Read how Delivering Machine Learning Projects: From design to deployment explains log →

AI Governance

Logging is the recording of system events and associated information for monitoring, audit, or analysis.

How it is used
Supports monitoring, incident investigation, and compliance evidence for deployed GenAI systems.
How deep it goes
Specifies request fields, event linkage, privacy safeguards, and retention considerations without implementing a logging pipeline.
Examples
Uses a medical pilot’s missing prompt and model-version records to illustrate an investigation gap.
What you can do after
Diagnose incidents by identifying missing request, tool, safeguard, and approval records.

Read how AI Governance explains log →

Troubleshooting Java: Read, debug, and optimize JVM applications

A record of events or messages generated during software execution.

How it is used
Uses stored execution messages as a starting point for investigating past application behavior and security issues.
How deep it goes
Explains message fields and investigation techniques, including timing, exception analysis, multithreading, and logging tradeoffs.
Examples
Illustrates a NullPointerException investigation and a Java database-operation timing log.
What you can do after
Diagnose/debug with logs to reconstruct execution, identify investigation leads, and measure a suspected slow operation.

Read how Troubleshooting Java: Read, debug, and optimize JVM applications explains log →

Google Anthos in Action

Logging is the recording of system and application events for analysis, troubleshooting, and auditing.

How it is used
Supports Kubernetes operations, workload investigation, and security observability through recorded system, application, and access events.
How deep it goes
Distinguishes log sources, retrieval, and forwarding paths, without detailing log formats or analysis procedures.
Examples
Uses Kubernetes service and workload logs, pod output, stdout, and /var/log/syslog as concrete sources.
What you can do after
Operate log retrieval through the Connect Agent and kubectl logs, and forward node logs to Cloud Logging with the operations suite agent enabled.

Read how Google Anthos in Action explains log →

Acing the Certified Kubernetes Administrator Exam, Second Edition

A log is time-based behavioral data recorded as text to provide information about events or problems in a running system.

How it is used
Uses application logs to troubleshoot Kubernetes problems and detect failures in running containers.
How deep it goes
Traces stdout and stderr to node log files and demonstrates retrieval for one or all pod containers.
Examples
Uses a MySQL CrashLoopBackOff diagnosis and a two-container BusyBox pod to demonstrate log retrieval.
What you can do after
Diagnose pod failures by retrieving container logs with kubectl and identifying error messages.

Read how Acing the Certified Kubernetes Administrator Exam, Second Edition explains log →

Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform

Logging is the practice of recording runtime events, messages, and diagnostic information generated by software.

How it is used
Uses event records to monitor microservice behavior and support investigation of problems.
How deep it goes
Explains console output, log selection, aggregation, and retrieval without requiring a sophisticated logging system.
Examples
Shows console output, Docker Compose log capture and search, and Kubernetes pod-log retrieval.
What you can do after
Operate Docker Compose, kubectl, or Stern to collect and inspect microservice logs.

Read how Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform explains log →

Secrets of the JavaScript Ninja, Second Edition

The practice of recording useful runtime information to help understand program behavior or diagnose problems.

How it is used
Records useful runtime information to understand program behavior and investigate bugs.
How deep it goes
Defines logging and works through proxy get and set traps, demonstrating property access logging without covering broader instrumentation.
Examples
Uses a Ninja skillLevel getter and setter, then a makeLoggable proxy that reports reads and writes.
What you can do after
Apply it via JavaScript Proxy traps to log property reads and writes without scattering statements through domain code.

Read how Secrets of the JavaScript Ninja, Second Edition explains log →

Microsoft Azure in Action

Logging is the practice of recording system or application events and diagnostic information.

How it is used
Diagnoses VM problems, audits Azure actions, and investigates recorded AI decisions.
How deep it goes
Distinguishes VM log types and demonstrates centralized queries for investigating unexpected restarts.
Examples
Uses VM heartbeat gaps, Windows Event Logs, Linux syslog, Azure activity records, and logged recommendation rationales.
What you can do after
Diagnose unexpected VM restarts by correlating heartbeat, operating-system, and activity records.

Read how Microsoft Azure in Action explains log →

gRPC Microservices in Go

A log is a recorded event or message describing activity in a software system.

How it is used
Uses application logs to investigate live-service problems and track anomalies across microservices.
How deep it goes
Works through structured log fields and a context-aware Go formatter, then identifies a cluster logging pipeline.
Examples
Shows order-ID metadata, a CreateOrder log entry, and trace and span IDs in formatted output.
What you can do after
Apply it via logrus to produce filterable contextual logs, then search related entries in a logging backend.

Read how gRPC Microservices in Go explains log →

Learn Haskell by Example

An event log is an ordered record of events produced during computation.

How it is used
Collects synchronization outcomes during effectful file operations and optionally reports them through a command-line interface.
How deep it goes
Defines event constructors, a list wrapper, accumulation instances, and formatted output, but does not develop persistent log storage.
Examples
Uses file-copy success, IOException failure, skipped files, and a verbose synchronization run as concrete examples.
What you can do after
Build it from scratch with typed entries, WriterT accumulation, derived combination instances, and optional formatted printing.

Read how Learn Haskell by Example explains log →

Learn Go with Pocket-Sized Projects

A structured log message represents log information as machine-parseable fields with defined meanings rather than as unstructured prose.

How it is used
Turns log output into machine-parseable fields that programs can use to generate dashboard information.
How deep it goes
Shows JSON fields and Go marshaling with exported struct fields, while deferring time validation.
Examples
Uses a JSON warning record with time, level, and message fields.
What you can do after
Apply it via Go's encoding/json package to serialize exported log fields as JSON.

Read how Learn Go with Pocket-Sized Projects explains log →

Designing AI Systems

The recording of application or system events, diagnostics, and operational information.

How it is used
Connects service-level events to distributed traces for operational investigation of AI requests.
How deep it goes
Defines a shared event schema and operational query, privacy, and retention practices.
Examples
Uses provider-fallback events, trace-filtered investigations, and guardrail-policy attribute queries.
What you can do after
Diagnose slow or anomalous requests by retrieving correlated events and filtering their attributes.

Read how Designing AI Systems explains log →

Functional Design and Architecture: Examples in Haskell

Structured logging is the recording of log events as machine-readable data with defined fields rather than only unstructured text.

How it is used
Routes machine-readable event data to external log aggregation services such as Sentry or Fluentd.
How deep it goes
Contrasts parseable text with JSON, then works through field-bearing interfaces and Sentry timestamp encoding.
Examples
Uses a meteor observation carrying a Sentry event identifier and timestamp as a concrete logging example.
What you can do after
Build it from scratch by defining a structured logger interface and adding service-specific fields to events.

Read how Functional Design and Architecture: Examples in Haskell explains log →

Pro ASP.NET Core 7, Tenth Edition

The practice of recording informational, diagnostic, warning, and error messages generated by software.

How it is used
Records application state to track errors, monitor performance, and help diagnose problems.
How deep it goes
Works through providers, categories, severity levels, class and Program.cs logging, and console verification.
Examples
Logs request start and completion for a population endpoint and startup pipeline configuration.
What you can do after
Apply it via ILogger<T> or app.Logger to emit categorized, leveled messages and verify them in console output.

Read how Pro ASP.NET Core 7, Tenth Edition explains log →

MongoDB 8.0 in Action, Third Edition

Logging is the systematic recording of system activities, user actions, and application events for later review and analysis.

How it is used
Uses logs to troubleshoot database issues, check performance, and detect security problems.
How deep it goes
Details log categories, retention, access, and filtering, but does not specify a full analysis procedure.
Examples
Shows database, audit, trigger, and mongosh logs, plus Atlas CLI downloads and mongosh log paths.
What you can do after
Diagnose database problems and investigate performance bottlenecks or potential security issues by reviewing logs.

Read how MongoDB 8.0 in Action, Third Edition explains log →

Grokking Software Architecture

The recording of software events, states, or diagnostic information for operational analysis.

How it is used
Uses logging as an injected technical concern and as evidence for understanding failures in distributed systems.
How deep it goes
Explains logger injection, testing, and failure reconstruction without detailing log formats or recording mechanics.
Examples
Uses an injected OrderService logger and Apollo 13 event correlations to illustrate testing and diagnosis.
What you can do after
Diagnose failures by correlating emitted events when interactive debugging is unavailable.

Read how Grokking Software Architecture explains log →

Also covered in

What to know first

Related concepts

Questions about log

What is log?

A log is a time-ordered record of events, messages, or activity generated by a system or process.

Which Manning books explain log?

Building Web APIs with ASP.NET Core, ASP.NET Core in Action, 3e, Think Like a CTO, AI Model Evaluation, Acing the Frontend Interview, Delivering Machine Learning Projects: From design to deployment, AI Governance, Troubleshooting Java: Read, debug, and optimize JVM applications and 13 more.

What should I know before learning log?

Manning books that teach log usually introduce monitoring, server, language model and metric first.

What is the difference between log and sensitive information?

A log is a time-ordered record of events, messages, or activity generated by a system or process. Sensitive information is information whose access, disclosure, alteration, or misuse may cause harm or violate privacy, security, or confidentiality requirements.

What is log a kind of?

Log is a kind of monitoring. 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.

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.