NLog/NLog

Features

• Structured Log Capture - Stores log parameters as key-value pairs instead of flat strings to enable precise querying and serialization.
• Structured Logging - Captures log events as structured data with named properties to enable precise querying and analysis.
• Log Metadata Injectors - Automatically attaches metadata such as timestamps and thread IDs to every log entry.
• Object Representation Transformations - NLog filters complex objects before serialization to control exactly what data appears in logs.
• Structured Log Serializers - Outputs event properties as JSON or XML using configurable layouts.
• Service Configuration Reloading - Monitors configuration files for changes and applies updates automatically without restarting the application.
• Structured Logging Libraries - Provides a library for capturing named parameters and properties as searchable machine-readable data.
• XML Configurations - Allows directing log output and defining rules via XML files without requiring recompilation.
• Severity-Based Routing - Directs log events to specific outputs based on the logger name and severity level.
• Asynchronous Logging - Offloads log writing and message formatting to background threads to prevent logging overhead from blocking application execution.
• Application Log Routing - Directs application events to various destinations like files, databases, and network services based on severity and source.
• Log Context Renderers - Formats captured context properties, scope details, and trace identifiers into log output using layout renderers.
• Dynamic Configuration Reloading - Monitors configuration files for changes and reapplies targets, rules, and variables without requiring an application restart.
• Log Event Filtering - Evaluates log events against boolean logic or regular expressions to determine if they should be written.
• Log Routing Engines - Functions as a routing engine that directs log messages to files, databases, or network services.
• Logging Framework Bridges - Provides interoperability layers that allow the underlying logging implementation to be swapped without modifying application code.
• Runtime Logging Configurations - Allows updating logging targets, filters, and formats while the application is running without requiring a restart.
• Structured Log Field Attachments - Captures key-value data with each message and renders them using layout renderers.
• Logging Frameworks - Implements a comprehensive logging framework for .NET featuring structured logging and dynamic configuration.
• Logging Integrations - Routes events through standard extension interfaces so a single backend can handle output from multiple logging libraries.
• Microsoft Extensions Logging Bridges - Bridges log data to standard Microsoft extension interfaces to enable structured logging through a common provider.
• XML-Based Log Routing - Maps loggers to specific output destinations using an XML configuration that defines severity filters and target rules.
• Logging Configuration Pipelines - Uses an XML-based configuration pipeline to define logging targets, rules, and layouts that can be reloaded at runtime.
• Log Output Templates - Constructs log output formats from string templates containing renderer placeholders that evaluate dynamic values at runtime.
• Write Throughput Optimizations - Implements write throughput optimizations using buffering and batching to increase disk efficiency for log files.
• Log Scope Capture - Pushes properties onto the current execution scope to ensure all events within that scope carry the associated metadata.
• Relational Database Connectors - Provides dedicated targets for writing log entries directly to relational database tables.
• Log Target Wrappers - Nests existing targets inside wrapper targets to add cross-cutting behaviors like asynchronous writes, buffering, and failover.
• Deferred Log Evaluation - Moves message processing and layout rendering to background threads to reduce main-thread latency.
• Conditional Compilation - Removes trace and debug calls from release builds at compile time to eliminate runtime overhead.
• Log Delivery Reliability - Improves reliability by wrapping targets with asynchronous execution and message buffering.
• Remote Log Collection Protocols - Sends log entries over TCP, UDP, or HTTP to remote log collection services.
• Dynamic Filter Application - Modifies log filtering logic in code at runtime using custom predicates.
• Extension Loaders - Automatically discovers and registers custom targets, renderers, and filters by scanning assemblies with specific naming prefixes.
• Logger Injection Patterns - Supports injecting logger instances into application classes via constructor injection for structured logging.
• Custom Log Formatting - Allows replacing default formatters with custom implementations to control data serialization.
• Log Filter Condition Registration - Allows registration of custom methods or lambdas to extend the filtering logic for log messages.
• Dynamic Template Construction - Constructs log output templates from strings or expressions that parse renderers at runtime.
• Process Exception Interception - Intercepts application-wide unhandled exceptions and forwards them to the logging system.
• Execution Scope Tracking - Assigns names to nested execution scopes to create a hierarchical trace of operation sequences within logs.
• Facades - Implements a facade pattern to provide a simplified unified interface for routing messages through industry-standard abstractions.
• Custom Log Renderer Implementations - Supports the creation of custom renderer classes to append dynamic, user-defined text to log events.
• Custom Output Destinations - Provides capabilities to develop custom output destinations and layout renderers for proprietary logging needs.
• Programmatic Configurations - Provides a fluent API to define logging targets and rules directly in code.
• Hierarchical Context Scopes - Supports pushing named states onto a thread-local scope to provide hierarchical context for structured logging.
• Severity Level Filtering - Controls log output by filtering messages based on predefined severity levels across the system.
• Custom Log Destinations - Enables the development of custom target classes to route logs to external systems or APIs.
• HTTP Endpoint Log Exporters - Posts log entries as HTTP requests to REST or SOAP web service endpoints for remote collection.
• Global Log Contexts - Stores application-wide static values at startup to be included with every log event produced by the system.
• Extensible Framework Architectures - Supports an extensible platform where custom targets and renderers can be loaded from external assemblies.
• Global Severity Thresholds - NLog enforces a minimum severity level across all loggers to suppress low-priority logs.
• Log Buffer Flushers - Provides the capability to force all buffered log entries to be written to their targets immediately on demand.
• Logger-Level Property Attachments - Attaches properties directly to a logger instance so they are automatically included in every event produced by that logger.
• Regex-Based Log Filtering - NLog applies regular expression patterns to log events to include or exclude them from the output.
• ASP.NET Core - Integrates the logging provider directly into the ASP.NET Core host building process to capture framework and application events.
• OpenTelemetry Trace ID Renderers - Renders current OpenTelemetry trace and span identifiers from activity diagnostics directly into log events.
• Thread-Local Property Scopes - Maintains a stack of named properties on the current execution thread to attach hierarchical metadata to log events.
• Logging Configuration Files - Reads logging configuration from standard application settings files like appsettings.json instead of dedicated XML files.
• Logging - Advanced logging framework with structured support.
• Logging and Monitoring - Advanced logging framework for .NET and Silverlight.
• Logging Frameworks - Flexible and high-performance logging platform for various targets.

Historial de estrellas