Logging level
A logging level is a severity or verbosity classification or setting that determines which log messages a logging system processes, emits, or retains.
ASP.NET Core in Action, 3e
The Information log level records normal application flow and contextual events that help explain subsequent behavior.
- How it is used
- Records normal application flow at Information level to provide context for later errors.
- How deep it goes
- Defines six severity levels, demonstrates ILogger methods, and explains category- and provider-specific minimum-level filtering.
- Examples
- Contrasts recipe-loading Information messages with missing-recipe Warnings and shows appsettings.json filtering rules.
- What you can do after
- Apply it via ASP.NET Core ILogger.LogInformation() and appsettings.json filters to record normal events while controlling output verbosity.
Read how ASP.NET Core in Action, 3e explains logging level →
Troubleshooting Java, Second Edition
A logging level is a configuration category that controls the severity or amount of messages emitted or stored by a logging system.
- How it is used
- Uses severity thresholds to focus application and GC investigations without retaining every available message.
- How deep it goes
- Explains four common severities, demonstrates Log4j thresholds, and extends the idea to GC retention and rotation.
- Examples
- Uses a Java digit extractor, Log4j XML configurations, severity-filtered output, and GC file-rotation commands.
- What you can do after
- Configure Log4j and GC logging to increase diagnostic detail selectively while controlling message volume and storage.
Read how Troubleshooting Java, Second Edition explains logging level →
Building Web APIs with ASP.NET Core
A logging level is a severity classification that determines the minimum importance of events recorded by an application logger.
- How it is used
- Configures which application, framework, and third-party events the ILogger pipeline records.
- How deep it goes
- Defines all enum levels and explains category inheritance, specificity, and minimum-level filtering, but does not detail provider internals.
- Examples
- Uses controller messages, SwaggerUI requests, Visual Studio Output, and appsettings category overrides to demonstrate filtering.
- What you can do after
- Apply named levels and category minimums, then verify emitted events through the Visual Studio Output window.
Read how Building Web APIs with ASP.NET Core explains logging level →
Python How-To
A logging level is a severity classification that determines which log records a logger or handler processes.
- How it is used
- Filters application events by severity to make large logs more useful when investigating failures.
- How deep it goes
- Works through numeric severity order, logger thresholds, separate handler thresholds, and the logger-first filtering rule.
- Examples
- Tests five severity messages against a WARNING threshold and splits file output into WARNING-and-above and CRITICAL-only records.
- What you can do after
- Apply it via Python’s logging module to route records to files at different severity thresholds.
Learn Go with Pocket-Sized Projects
A log level is a category indicating the importance or severity of a recorded log message.
- How it is used
- Uses levels to classify log messages and filter output according to a logger threshold.
- How deep it goes
- Defines ordered levels and implements threshold checks, output decoration, and runtime selection, without detailing a larger severity taxonomy.
- Examples
- Uses Debug, Info, and Error messages, threshold-filtered Debugf calls, colored console inspection, and table-driven logger tests.
- What you can do after
- Build a Go logger with ordered levels, threshold filtering, level-specific methods, and runtime-selected logging.
Read how Learn Go with Pocket-Sized Projects explains logging level →
Cloud Observability in Action
A log level is a classification that indicates the nature or severity of a log event.
- How it is used
- Uses event classification to filter, search, and interpret logs during development, troubleshooting, and operations.
- How deep it goes
- Defines common DEBUG-to-ERROR semantics and demonstrates filtering, but defers implementation-specific conventions and detailed configuration.
- Examples
- Uses DEBUG, INFO, WARNING, and ERROR semantics plus a journalctl priority filter.
- What you can do after
- Operate/configure journalctl queries that restrict output by log priority.
Read how Cloud Observability in Action explains logging level →
Pro ASP.NET Core 7, Tenth Edition
A logging level value is a named setting that specifies the severity threshold or disabled state for log messages.
- How it is used
- Configures which ASP.NET Core log messages remain visible for each category.
- How deep it goes
- Explains severity meanings, category matching, configuration inheritance, development overrides, and disabling; stops short of provider internals.
- Examples
- Uses appsettings files, development overrides, routing diagnostics, population requests, and Entity Framework Core SQL output.
- What you can do after
- Configure logging thresholds by category and verify the resulting diagnostic output.
Read how Pro ASP.NET Core 7, Tenth Edition explains logging level →
Learn Docker in a Month of Lunches, Second Edition
A logging level specifies the severity threshold and amount of diagnostic information an application records.
- How it is used
- Configures application verbosity across containers and Kubernetes deployments while supporting operational diagnosis.
- How deep it goes
- Explains thresholds, configuration injection, Pod replacement, and downstream filtering without detailing logging-level taxonomies.
- Examples
- Uses a to-do application, logging.json, Docker bind mounts, Kubernetes Pods, and Fluentd routing rules.
- What you can do after
- Operate/configure containerized applications with more detailed logs and filter verbose records without changing application containers.
Read how Learn Docker in a Month of Lunches, Second Edition explains logging level →
The Well-Grounded Python Developer: How the pros use Python and Flask
A logging level is a classification that indicates the severity or importance of a log message.
- How it is used
- Controls application observability by filtering runtime messages differently for development and production environments.
- How deep it goes
- Explains severity ordering, threshold filtering, logger and handler configuration, and YAML-driven environment selection.
- Examples
- Uses DEBUG route messages, INFO production output, YAML environment settings, and timestamped console log entries.
- What you can do after
- Operate/configure Python logging to preserve debug diagnostics while controlling production output through INFO and DEBUG thresholds.
Related concepts
- Loggerconfigures · A logger is a software component or interface that records or emits runtime information, such as diagnostic messages, events, or metrics.
- logging moduleused by · Python’s standard-library module provides configurable facilities for creating, filtering, formatting, and routing application log records.
- /loggers endpointconfigured by · The /loggers endpoint is a Spring Boot Actuator HTTP endpoint that reports and changes configured logging levels.
- severityequivalent to · Severity is an assessment or classification of how serious or impactful an issue, event, condition, or finding is, often expressed as an ordered level.
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.