Configuring Logging
This guide explains logging and how to configure it.
Internally, Quarkus uses JBoss Log Manager and the JBoss Logging facade. You can use the JBoss Logging facade inside your code as it’s already provided, or any of the supported Logging API listed in the next chapter as Quarkus will send them to JBoss Log Manager.
All the logging configuration will then be done inside your application.properties
.
Supported Logging APIs
Applications and components may use any of the following APIs for logging, and the logs will be merged:
-
JDK
java.util.logging
(also called JUL)
Internally Quarkus uses JBoss Logging; you can also use it inside your application so that no other dependencies should be added for your logs.
import org.jboss.logging.Logger;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
@Path("/hello")
public class ExampleResource {
private static final Logger LOG = Logger.getLogger(ExampleResource.class);
@GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
LOG.info("Hello");
return "hello";
}
}
If you use JBoss Logging but one of your libraries uses a different logging API, you may need to configure a logging adapter. |
Logging with Panache
Instead of declaring a Logger
field, you can use the simplified logging API:
package com.example;
import io.quarkus.logging.Log; (1)
class MyService { (2)
public void doSomething() {
Log.info("Simple!"); (3)
}
}
1 | The io.quarkus.logging.Log class mirrors the JBoss Logging API, except all methods are static . |
2 | Note that the class doesn’t declare a logger field.
This is because during application build, a private static final org.jboss.logging.Logger field is created automatically, in each class that uses the Log API.
The fully qualified name of the class that calls the Log methods is used as a logger name.
In this example, the logger name would be com.example.MyService . |
3 | Finally, during application build, all calls to Log methods are rewritten to regular JBoss Logging calls on the logger field. |
Only use the Log API in application classes, not in external dependencies.
Log method calls that are not processed by Quarkus at build time will throw an exception.
|
Injecting a Logger
You can also inject a configured org.jboss.logging.Logger
instance in your beans and resource classes.
import org.jboss.logging.Logger;
@ApplicationScoped
class SimpleBean {
@Inject
Logger log; (1)
@LoggerName("foo")
Logger fooLog; (2)
public void ping() {
log.info("Simple!");
fooLog.info("Goes to _foo_ logger!");
}
}
1 | The FQCN of the declaring class is used as a logger name, i.e. org.jboss.logging.Logger.getLogger(SimpleBean.class) will be used. |
2 | In this case, the name foo is used as a logger name, i.e. org.jboss.logging.Logger.getLogger("foo") will be used. |
The logger instances are cached internally. Therefore, a logger injected e.g. into a @RequestScoped bean is shared for all bean instances to avoid possible performance penalty associated with logger instantiation.
|
What about Apache Log4j ?
Log4j is a logging implementation: it contains a logging backend and a logging facade.
Quarkus uses the JBoss Log Manager backend, so you will need to include the log4j2-jboss-logmanager
library to route Log4j logs to JBoss Log Manager.
<dependency>
<groupId>org.jboss.logmanager</groupId>
<artifactId>log4j2-jboss-logmanager</artifactId> (1)
</dependency>
1 | This is the library needed for Log4j version 2; if you use the legacy Log4j version 1 you need to use log4j-jboss-logmanager instead. |
implementation("org.jboss.logmanager:log4j2-jboss-logmanager") (1)
1 | This is the library needed for Log4j version 2; if you use the legacy Log4j version 1 you need to use log4j-jboss-logmanager instead. |
You can then use the Log4j API inside your application.
Do not include any Log4j dependencies. The log4j2-jboss-logmanager library includes what’s needed to use Log4j as a logging facade.
|
Logging levels
These are the log levels used by Quarkus:
OFF |
Special level to turn off logging. |
FATAL |
A critical service failure/complete inability to service requests of any kind. |
ERROR |
A significant disruption in a request or the inability to service a request. |
WARN |
A non-critical service error or problem that may not require immediate correction. |
INFO |
Service lifecycle events or important related very-low-frequency information. |
DEBUG |
Messages that convey extra information regarding lifecycle or non-request-bound events which may be helpful for debugging. |
TRACE |
Messages that convey extra per-request debugging information that may be very high frequency. |
ALL |
Special level for all messages including custom levels. |
In addition, the following levels may be configured for applications and libraries using java.util.logging
:
SEVERE |
Same as ERROR. |
WARNING |
Same as WARN. |
CONFIG |
Service configuration information. |
FINE |
Same as DEBUG. |
FINER |
Same as TRACE. |
FINEST |
Event more debugging information than |
Runtime configuration
Run time logging is configured in the application.properties
file,
for example, to set the default log level to INFO
logging and include Hibernate DEBUG
logs:
quarkus.log.level=INFO
quarkus.log.category."org.hibernate".level=DEBUG
Setting a log level below DEBUG
requires the minimum log level to be adjusted,
either globally via the quarkus.log.min-level
property or per-category as shown in the example above,
as well as adjusting the log level itself.
Minimum logging level sets a floor level that Quarkus will be needed to potentially generate,
opening the door to optimization opportunities.
As an example, in native execution the minimum level enables lower level checks (e.g. isTraceEnabled
) to be folded to false
,
resulting in dead code elimination for code that will never to be executed.
All possible properties are listed in the logging configuration reference section.
If you are adding these properties by using the command line, make sure " is escaped.
For example -Dquarkus.log.category.\"org.hibernate\".level=TRACE .
|
Logging categories
Logging is done on a per-category basis. Each category can be independently configured. A configuration which applies to a category will also apply to all sub-categories of that category, unless there is a more specific matching sub-category configuration. For every category the same settings that are configured on ( console / file / syslog ) apply. These can also be overridden by attaching one or more named handlers to a category. See example in the Named handlers attached to a category output.
Property Name | Default | Description |
---|---|---|
|
|
The level to use to configure the category named |
|
|
The minimum logging level to use to configure the category named |
|
|
Specify whether this logger should send its output to its parent logger. |
|
|
The names of the handlers that you want to attach to a specific category. |
The quotes shown in the property name are required as categories normally contain '.', which must be escaped. See the example in File TRACE Logging Configuration. |
Root logger configuration
The root logger category is handled separately, and is configured via the following properties:
Property Name | Default | Description |
---|---|---|
|
|
The default log level for every log category. |
|
|
The default minimum log level for every log category. |
If no level configuration exists for a given logger category, the enclosing (parent) category is examined. If no categories are configured which enclose the category in question, then the root logger configuration is used.
Logging Format
By default, Quarkus uses a pattern-based logging formatter that generates human-readable text logs.
You can configure the format for each log handler via a dedicated property.
For the console handler, the property is quarkus.log.console.format
.
The logging format string supports the following symbols:
Symbol | Summary | Description |
---|---|---|
|
|
Renders a simple |
|
Category |
Renders the category name. |
|
Source class |
Renders the source class name.[3] |
|
Date |
Renders a date with the given date format string, which uses the syntax defined by |
|
Exception |
Renders the thrown exception, if any. |
|
Source file |
Renders the source file name.[3] |
|
Host name |
Renders the system simple host name. |
|
Qualified host name |
Renders the system’s fully qualified host name, which may be the same as the simple host name, depending on OS configuration. |
|
Process ID |
Render the current process PID. |
|
Source location |
Renders the source location information, which includes source file name, line number, class name, and method name.[3] |
|
Source line |
Renders the source line number.[3] |
|
Full Message |
Renders the log message plus exception (if any). |
|
Source method |
Renders the source method name.[3] |
|
Newline |
Renders the platform-specific line separator string. |
|
Process name |
Render the name of the current process. |
|
Level |
Render the log level of the message. |
|
Relative time |
Render the time in milliseconds since the start of the application log. |
|
Simple message |
Renders just the log message, with no exception trace. |
|
Thread name |
Render the thread name. |
|
Thread ID |
Render the thread ID. |
|
Time zone |
Set the time zone of the output to |
|
Mapped Diagnostics Context Value |
Renders the value from Mapped Diagnostics Context |
|
Mapped Diagnostics Context Values |
Renders all the values from Mapped Diagnostics Context in format {property.key=property.value} |
|
Nested Diagnostics context values |
Renders all the values from Nested Diagnostics Context in format {value1.value2} |
Alternative Console Logging Formats
It is possible to change the output format of the console log. This can be useful in environments where the output of the Quarkus application is captured by a service which can, for example, process and store the log information for later analysis.
JSON Logging Format
In order to configure the JSON logging format, the quarkus-logging-json
extension may be employed.
Add this extension to your build file as the following snippet illustrates:
<dependency>
<groupId>io.quarkus</groupId>
<artifactId>quarkus-logging-json</artifactId>
</dependency>
implementation("io.quarkus:quarkus-logging-json")
The presence of this extension will, by default, replace the output format configuration from the console configuration. This means that the format string and the color settings (if any) will be ignored. The other console configuration items, including those controlling asynchronous logging and the log level, will continue to be applied.
For some, it will make sense to use logging that is humanly readable (unstructured) in dev mode and JSON logging (structured) in production mode. This can be achieved using different profiles, as shown in the following configuration.
%dev.quarkus.log.console.json=false
%test.quarkus.log.console.json=false
Configuration
The JSON logging extension can be configured in various ways. The following properties are supported:
Configuration property fixed at build time - All other configuration properties are overridable at runtime
Type |
Default |
|
---|---|---|
Determine whether to enable the JSON console formatting extension, which disables "normal" console formatting. Environment variable: |
boolean |
|
Enable "pretty printing" of the JSON record. Note that some JSON parsers will fail to read pretty printed output. Environment variable: |
boolean |
|
The date format to use. The special string "default" indicates that the default format should be used. Environment variable: |
string |
|
The special end-of-record delimiter to be used. By default, newline is used as delimiter. Environment variable: |
string |
|
The zone ID to use. The special string "default" indicates that the default zone should be used. Environment variable: |
string |
|
The exception output type to specify. Environment variable: |
|
|
Enable printing of more details in the log. Printing the details can be expensive as the values are retrieved from the caller. The details include the source class name, source file name, source method name and source line number. Environment variable: |
boolean |
|
Override keys with custom values. Omitting this value indicates that no key overrides will be applied. Environment variable: |
string |
|
Keys to be excluded from the Json output. Environment variable: |
list of string |
|
Additional field value. Environment variable: |
string |
required |
Additional field type specification. Supported types: string, int, long String is the default if not specified. Environment variable: |
|
|
Type |
Default |
|
Determine whether to enable the JSON console formatting extension, which disables "normal" console formatting. Environment variable: |
boolean |
|
Enable "pretty printing" of the JSON record. Note that some JSON parsers will fail to read pretty printed output. Environment variable: |
boolean |
|
The date format to use. The special string "default" indicates that the default format should be used. Environment variable: |
string |
|
The special end-of-record delimiter to be used. By default, newline is used as delimiter. Environment variable: |
string |
|
The zone ID to use. The special string "default" indicates that the default zone should be used. Environment variable: |
string |
|
The exception output type to specify. Environment variable: |
|
|
Enable printing of more details in the log. Printing the details can be expensive as the values are retrieved from the caller. The details include the source class name, source file name, source method name and source line number. Environment variable: |
boolean |
|
Override keys with custom values. Omitting this value indicates that no key overrides will be applied. Environment variable: |
string |
|
Keys to be excluded from the Json output. Environment variable: |
list of string |
|
Additional field value. Environment variable: |
string |
required |
Additional field type specification. Supported types: string, int, long String is the default if not specified. Environment variable: |
|
|
Type |
Default |
|
Determine whether to enable the JSON console formatting extension, which disables "normal" console formatting. Environment variable: |
boolean |
|
Enable "pretty printing" of the JSON record. Note that some JSON parsers will fail to read pretty printed output. Environment variable: |
boolean |
|
The date format to use. The special string "default" indicates that the default format should be used. Environment variable: |
string |
|
The special end-of-record delimiter to be used. By default, newline is used as delimiter. Environment variable: |
string |
|
The zone ID to use. The special string "default" indicates that the default zone should be used. Environment variable: |
string |
|
The exception output type to specify. Environment variable: |
|
|
Enable printing of more details in the log. Printing the details can be expensive as the values are retrieved from the caller. The details include the source class name, source file name, source method name and source line number. Environment variable: |
boolean |
|
Override keys with custom values. Omitting this value indicates that no key overrides will be applied. Environment variable: |
string |
|
Keys to be excluded from the Json output. Environment variable: |
list of string |
|
Additional field value. Environment variable: |
string |
required |
Additional field type specification. Supported types: string, int, long String is the default if not specified. Environment variable: |
|
|
Enabling pretty printing might cause certain processors and JSON parsers to fail. |
Printing the details can be expensive as the values are retrieved from the caller. The details include the source class name, source file name, source method name, and source line number. |
Log Handlers
A log handler is a logging component responsible for the emission of log events to a recipient. Quarkus comes with three different log handlers: console, file and syslog.
Console log handler
The console log handler is enabled by default.
It outputs all log events to the console of your application (typically to the system’s stdout
).
For details of its configuration options, see the Console Logging configuration reference.
Logging filters
Log handlers (like the console log handler) can have a filter associated with them, whose purpose is to determine whether a record should actually be logged or not. These filters are registered by placing the Finally, the filter is attached using the Let’s say for example that we wanted to filter out logging records that contained a part of text from the console logs. The text itself is part of the application configuration and is not hardcoded. We could write a filter like so:
and configure it in the usual Quarkus way (for example using
And we would register this filter to the console handler like so:
|
File log handler
The file log handler is disabled by default. It outputs all log events to a file on the application’s host. It supports log file rotation.
For details of its configuration options, see the File Logging configuration reference.
Syslog log handler
Syslog is a protocol for sending log messages on Unix-like systems using a protocol defined by RFC 5424.
The syslog handler sends all log events to a syslog server (by default, the syslog server that is local to the application). It is disabled by default.
For details of its configuration options, see the Syslog Logging configuration reference.
Although the root logger’s handlers are usually configured directly via |
Examples
quarkus.log.console.format=%d{HH:mm:ss} %-5p [%c{2.}] (%t) %s%e%n
quarkus.log.console.level=DEBUG
quarkus.console.color=false
quarkus.log.category."io.quarkus".level=INFO
If you are adding these properties via command line make sure " is escaped.
For example -Dquarkus.log.category.\"io.quarkus\".level=DEBUG .
|
quarkus.log.file.enable=true
# Send output to a trace.log file under the /tmp directory
quarkus.log.file.path=/tmp/trace.log
quarkus.log.file.level=TRACE
quarkus.log.file.format=%d{HH:mm:ss} %-5p [%c{2.}] (%t) %s%e%n
# Set 2 categories (io.quarkus.smallrye.jwt, io.undertow.request.security) to TRACE level
quarkus.log.min-level=TRACE
quarkus.log.category."io.quarkus.smallrye.jwt".level=TRACE
quarkus.log.category."io.undertow.request.security".level=TRACE
As we don’t change the root logger, console log will only contain INFO or higher order logs.
|
# Send output to a trace.log file under the /tmp directory
quarkus.log.file.path=/tmp/trace.log
quarkus.log.console.format=%d{HH:mm:ss} %-5p [%c{2.}] (%t) %s%e%n
# Configure a named handler that logs to console
quarkus.log.handler.console."STRUCTURED_LOGGING".format=%e%n
# Configure a named handler that logs to file
quarkus.log.handler.file."STRUCTURED_LOGGING_FILE".enable=true
quarkus.log.handler.file."STRUCTURED_LOGGING_FILE".format=%e%n
# Configure the category and link the two named handlers to it
quarkus.log.category."io.quarkus.category".level=INFO
quarkus.log.category."io.quarkus.category".handlers=STRUCTURED_LOGGING,STRUCTURED_LOGGING_FILE
# configure a named file handler that sends the output to 'quarkus.log'
quarkus.log.handler.file.CONSOLE_MIRROR.enable=true
quarkus.log.handler.file.CONSOLE_MIRROR.path=quarkus.log
# attach the handler to the root logger
quarkus.log.handlers=CONSOLE_MIRROR
Centralized Log Management
If you want to send your logs to a centralized tool like Graylog, Logstash or Fluentd, you can follow the Centralized log management guide.
How to Configure Logging for @QuarkusTest
If you want to configure logging for your @QuarkusTest
, don’t forget to set up the maven-surefire-plugin
accordingly.
In particular, you need to set the appropriate LogManager
using the java.util.logging.manager
system property.
<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${surefire-plugin.version}</version>
<configuration>
<systemPropertyVariables>
<java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager> (1)
<quarkus.log.level>DEBUG</quarkus.log.level> (2)
<maven.home>${maven.home}</maven.home>
</systemPropertyVariables>
</configuration>
</plugin>
</plugins>
</build>
1 | Make sure the org.jboss.logmanager.LogManager is used. |
2 | Enable debug logging for all logging categories. |
If you are using Gradle, add this to your build.gradle
:
test {
systemProperty "java.util.logging.manager", "org.jboss.logmanager.LogManager"
}
See also Running @QuarkusTest
from an IDE.
Logging Adapters
Quarkus relies on the JBoss Logging library for all the logging requirements.
If you are using libraries that have dependencies on other logging libraries such as Apache Commons Logging, Log4j or SLF4J, you need to exclude them from the dependencies and use one of the adapters provided by JBoss Logging.
This is especially important when building native executables as you could encounter issues similar to the following when compiling the native executable:
Caused by java.lang.ClassNotFoundException: org.apache.commons.logging.impl.LogFactoryImpl
This is due to the logging implementation not being included in the native executable. Using the JBoss Logging adapters will solve this problem.
These adapters are available for most of the common Open Source logging components.
Apache Commons Logging:
<dependency>
<groupId>org.jboss.logging</groupId>
<artifactId>commons-logging-jboss-logging</artifactId>
</dependency>
implementation("org.jboss.logging:commons-logging-jboss-logging")
Log4j:
<dependency>
<groupId>org.jboss.logmanager</groupId>
<artifactId>log4j-jboss-logmanager</artifactId>
</dependency>
implementation("org.jboss.logmanager:log4j-jboss-logmanager")
Log4j 2:
<dependency>
<groupId>org.jboss.logmanager</groupId>
<artifactId>log4j2-jboss-logmanager</artifactId>
</dependency>
implementation("org.jboss.logmanager:log4j2-jboss-logmanager")
And SLF4J:
<dependency>
<groupId>org.jboss.slf4j</groupId>
<artifactId>slf4j-jboss-logmanager</artifactId>
</dependency>
implementation("org.jboss.slf4j:slf4j-jboss-logmanager")
This is not needed for libraries that are dependencies of a Quarkus extension as the extension will take care of this for you. |
Logging configuration reference
Configuration property fixed at build time - All other configuration properties are overridable at runtime
Type |
Default |
|
---|---|---|
The log level of the root category, which is used as the default log level for all categories. JBoss Logging supports Apache style log levels:
In addition, it also supports the standard JDK log levels. Environment variable: |
|
|
The names of additional handlers to link to the root category. These handlers are defined in consoleHandlers, fileHandlers or syslogHandlers. Environment variable: |
list of string |
|
Type |
Default |
|
If console logging should be enabled Environment variable: |
boolean |
|
If console logging should go to Environment variable: |
boolean |
|
The log format. Note that this value will be ignored if an extension is present that takes control of console formatting (e.g. an XML or JSON-format extension). Environment variable: |
string |
|
The console log level. Environment variable: |
|
|
Specify how much the colors should be darkened. Note that this value will be ignored if an extension is present that takes control of console formatting (e.g. an XML or JSON-format extension). Environment variable: |
int |
|
The name of the filter to link to the console handler. Environment variable: |
string |
|
Indicates whether to log asynchronously Environment variable: |
boolean |
|
The queue length to use before flushing writing Environment variable: |
int |
|
Determine whether to block the publisher (rather than drop the message) when the queue is full Environment variable: |
|
|
Type |
Default |
|
If file logging should be enabled Environment variable: |
boolean |
|
The log format Environment variable: |
string |
|
The level of logs to be written into the file. Environment variable: |
|
|
The name of the file in which logs will be written. Environment variable: |
|
|
The name of the filter to link to the file handler. Environment variable: |
string |
|
The character encoding used Environment variable: |
||
Indicates whether to log asynchronously Environment variable: |
boolean |
|
The queue length to use before flushing writing Environment variable: |
int |
|
Determine whether to block the publisher (rather than drop the message) when the queue is full Environment variable: |
|
|
The maximum file size of the log file after which a rotation is executed. Environment variable: |
|
|
The maximum number of backups to keep. Environment variable: |
int |
|
File handler rotation file suffix. When used, the file will be rotated based on its suffix. Example fileSuffix: .yyyy-MM-dd Environment variable: |
string |
|
Indicates whether to rotate log files on server initialization.
You need to either set a Environment variable: |
boolean |
|
Type |
Default |
|
If syslog logging should be enabled Environment variable: |
boolean |
|
The IP address and port of the syslog server Environment variable: |
host:port |
|
The app name used when formatting the message in RFC5424 format Environment variable: |
string |
|
The name of the host the messages are being sent from Environment variable: |
string |
|
Sets the facility used when calculating the priority of the message as defined by RFC-5424 and RFC-3164 Environment variable: |
|
|
Set the Environment variable: |
|
|
Sets the protocol used to connect to the syslog server Environment variable: |
|
|
Set to Environment variable: |
boolean |
|
Set to Environment variable: |
boolean |
|
Enables or disables blocking when attempting to reconnect a Environment variable: |
boolean |
|
The log message format Environment variable: |
string |
|
The log level specifying, which message levels will be logged by syslog logger Environment variable: |
|
|
The name of the filter to link to the file handler. Environment variable: |
string |
|
Indicates whether to log asynchronously Environment variable: |
boolean |
|
The queue length to use before flushing writing Environment variable: |
int |
|
Determine whether to block the publisher (rather than drop the message) when the queue is full Environment variable: |
|
|
Type |
Default |
|
The log level for this category. Note that to get log levels below Environment variable: |
InheritableLevel |
|
The names of the handlers to link to this category. Environment variable: |
list of string |
|
Specify whether this logger should send its output to its parent Logger Environment variable: |
boolean |
|
Type |
Default |
|
If console logging should be enabled Environment variable: |
boolean |
|
If console logging should go to Environment variable: |
boolean |
|
The log format. Note that this value will be ignored if an extension is present that takes control of console formatting (e.g. an XML or JSON-format extension). Environment variable: |
string |
|
The console log level. Environment variable: |
|
|
Specify how much the colors should be darkened. Note that this value will be ignored if an extension is present that takes control of console formatting (e.g. an XML or JSON-format extension). Environment variable: |
int |
|
The name of the filter to link to the console handler. Environment variable: |
string |
|
Indicates whether to log asynchronously Environment variable: |
boolean |
|
The queue length to use before flushing writing Environment variable: |
int |
|
Determine whether to block the publisher (rather than drop the message) when the queue is full Environment variable: |
|
|
Type |
Default |
|
If file logging should be enabled Environment variable: |
boolean |
|
The log format Environment variable: |
string |
|
The level of logs to be written into the file. Environment variable: |
|
|
The name of the file in which logs will be written. Environment variable: |
|
|
The name of the filter to link to the file handler. Environment variable: |
string |
|
The character encoding used Environment variable: |
||
Indicates whether to log asynchronously Environment variable: |
boolean |
|
The queue length to use before flushing writing Environment variable: |
int |
|
Determine whether to block the publisher (rather than drop the message) when the queue is full Environment variable: |
|
|
The maximum file size of the log file after which a rotation is executed. Environment variable: |
|
|
The maximum number of backups to keep. Environment variable: |
int |
|
File handler rotation file suffix. When used, the file will be rotated based on its suffix. Example fileSuffix: .yyyy-MM-dd Environment variable: |
string |
|
Indicates whether to rotate log files on server initialization.
You need to either set a Environment variable: |
boolean |
|
Type |
Default |
|
If syslog logging should be enabled Environment variable: |
boolean |
|
The IP address and port of the syslog server Environment variable: |
host:port |
|
The app name used when formatting the message in RFC5424 format Environment variable: |
string |
|
The name of the host the messages are being sent from Environment variable: |
string |
|
Sets the facility used when calculating the priority of the message as defined by RFC-5424 and RFC-3164 Environment variable: |
|
|
Set the Environment variable: |
|
|
Sets the protocol used to connect to the syslog server Environment variable: |
|
|
Set to Environment variable: |
boolean |
|
Set to Environment variable: |
boolean |
|
Enables or disables blocking when attempting to reconnect a Environment variable: |
boolean |
|
The log message format Environment variable: |
string |
|
The log level specifying, which message levels will be logged by syslog logger Environment variable: |
|
|
The name of the filter to link to the file handler. Environment variable: |
string |
|
Indicates whether to log asynchronously Environment variable: |
boolean |
|
The queue length to use before flushing writing Environment variable: |
int |
|
Determine whether to block the publisher (rather than drop the message) when the queue is full Environment variable: |
|
|
Type |
Default |
|
The message starts to match Environment variable: |
list of string |
|
The new log level for the filtered message, defaults to DEBUG Environment variable: |
|
About the MemorySize format
A size configuration option recognises string in this format (shown as a regular expression): |