SLF4J

https://www.slf4j.org/
Admin
SLF4J is a simple logging facade for Java that provides a unified abstraction layer across various...
Tokens:141,084
Snippets:1,415
Trust Score:9.5
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Sentry Dependencies

Source: https://www.slf4j.org/count/sentry.html

Manual installation commands for Sentry SDKs using package managers.

```Bash
dotnet add package Sentry.Maui -v 5.11.1
```

```Bash
pip install --upgrade sentry-sdk
```

```Bash
npm install @sentry/node
```

```Bash
npm install @sentry/react
```

```Bash
dotnet add package Sentry
```

```Bash
go get "github.com/getsentry/sentry-go"
```

--------------------------------

### start(String name)

Source: https://www.slf4j.org/api/org/slf4j/profiler/StopWatch.html

Starts the time instrument with the given name.

```APIDOC
## start(String name)

### Description
Starts the time instrument with the given name.

### Parameters
- **name** (String) - Required - The name of the instrument.
```

--------------------------------

### Initialize Sentry in PHP

Source: https://www.slf4j.org/count/sentry.html

Install the package via Composer and initialize the SDK with tracing options.

```Bash
composer require sentry/sentry
```

```PHP
\Sentry\init(['dsn' => 'https://<key>@sentry.io/<project>',
    // Specify a fixed sample rate:
    'traces_sample_rate' => 0.2,
    // Or provide a custom sampler:
    'traces_sampler' => function (SentryTracingSamplingContext $context): float {
        // return a number between 0 and 1
    }, ]);
```

--------------------------------

### install()

Source: https://www.slf4j.org/api/org/slf4j/bridge/SLF4JBridgeHandler.html

Adds a SLF4JBridgeHandler instance to the JUL root logger to begin redirecting logs to SLF4J.

```APIDOC
### static void install()

Adds a SLF4JBridgeHandler instance to the JUL root logger. This handler redirects java.util.logging events to SLF4J, provided the logs are enabled in JUL.
```

--------------------------------

### Install Sentry for Vue

Source: https://www.slf4j.org/count/sentry.html

Install the Sentry Vue SDK via npm.

```Bash
npm install @sentry/vue
```

--------------------------------

### Configure Logging Routes

Source: https://www.slf4j.org/count/rainbowgum.html

Example configuration for setting up multiple routes with specific appenders and log levels.

```properties
logging.level=INFO
logging.routes=console,mycompany
logging.route.mycompany.appenders=mycompany
logging.route.mycompany.level.com.mycompany=DEBUG
logging.route.console.level=WARN
logging.route.console.appenders=console
logging.appender.mycompany.output=file:///./mycompany.log
logging.appender.console.output=stdout
```

--------------------------------

### Release Script Execution

Source: https://www.slf4j.org/count/jboss.html

Example command for running the release script with specified release and development versions.

```bash
./release.sh -r 1.0.0.Final -d 1.0.1.Final-SNAPSHOT
```

--------------------------------

### Configure Router via Properties

Source: https://www.slf4j.org/count/rainbowgum.html

Defines a route named 'example' with specific appenders, a publisher, and a level threshold for a package.

```properties
logging.routes=example
logging.route.example.appenders=appender1,appender2
logging.route.example.publisher=async
logging.route.example.level.com.mycompany=DEBUG
```

--------------------------------

### Configure Log4j Core

Source: https://www.slf4j.org/count/log4j2_slf4j_binding.html

Basic configuration examples for Log4j Core using different file formats.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<Configuration xmlns="https://logging.apache.org/xml/ns"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="https://logging.apache.org/xml/ns
                                   https://logging.apache.org/xml/ns/log4j-config-2.xsd">
  <Appenders>
    <Console name="CONSOLE">
      <PatternLayout pattern="%d [%t] %5p %c{1.} - %m%n"/>__**(1)**
    </Console>
  </Appenders>
  <Loggers>
    <Root level="INFO">
      <AppenderRef ref="CONSOLE"/>
    </Root>
  </Loggers>
</Configuration>
```

```json
{
  "Configuration": {
    "Appenders": {
      "Console": {
        "name": "CONSOLE",
        "PatternLayout": {
          "pattern": "%d [%t] %5p %c{1.} - %m%n" __**(1)**
        }
      }
    },
    "Loggers": {
      "Root": {
        "level": "INFO",
        "AppenderRef": {
          "ref": "CONSOLE"
        }
      }
    }
  }
}
```

```yaml
Configuration:
  Appenders:
    Console:
      name: CONSOLE
      PatternLayout:
        pattern: "%d [%t] %5p %c{1.} - %m%n" __**(1)**
  Loggers:
    Root:
      level: INFO
      AppenderRef:
        ref: CONSOLE
```

```properties
appender.0.type = Console
appender.0.name = CONSOLE
appender.0.layout.type = PatternLayout __**(1)**
appender.0.layout.pattern = %d [%t] %5p %c{1.} - %m%n
rootLogger.level = INFO
rootLogger.appenderRef.0.ref = CONSOLE
```

--------------------------------

### Configure Async Publisher

Source: https://www.slf4j.org/count/rainbowgum.html

Example of configuring a route to use an asynchronous publisher with a defined buffer size.

```properties
logging.route.example.publisher=async
logging.publisher.example.bufferSize=1024
```

--------------------------------

### SLF4JBridgeHandler.install()

Source: https://www.slf4j.org/api/org/slf4j/bridge/SLF4JBridgeHandler.html

Installs the SLF4JBridgeHandler as the sole handler for the java.util.logging root logger.

```APIDOC
## SLF4JBridgeHandler.install()

### Description
Adds an instance of SLF4JBridgeHandler to the java.util.logging root logger to redirect all JUL log records to the SLF4J API. This should be performed once during the application initialization phase.

### Method
static void install()

### Usage Example
```java
// add SLF4JBridgeHandler to j.u.l's root logger
SLF4JBridgeHandler.install();
```
```

--------------------------------

### Configure Appender Output via Properties

Source: https://www.slf4j.org/count/rainbowgum.html

Example configuration for an appender's output destination using properties.

```properties
  logging.appenders=myappender
  logging.appender.myappender.output=stdout
```

```properties
  logging.appenders=myappender
```

--------------------------------

### JCL to SLF4J Migration Example

Source: https://www.slf4j.org/migrator.html

Comparison of a Java class before and after migration from JCL to SLF4J.

```java
package some.package; **import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory;** public MyClass { **Log logger = LogFactory.getLog(MyClass.class);** public void someMethod() { logger.info("Hello world"); } }
```

```java
package some.package; **import org.slf4j.Logger; import org.slf4j.LoggerFactory;** public MyClass { **Logger logger = LoggerFactory.getLogger(MyClass.class);** public void someMethod() { logger.info("Hello world"); } }
```

--------------------------------

### Programmatic Installation of SLF4JBridgeHandler

Source: https://www.slf4j.org/api/org/slf4j/bridge/SLF4JBridgeHandler.html

Install the handler by removing existing JUL handlers and adding the SLF4JBridgeHandler to the root logger during application initialization.

```java
// Optionally remove existing handlers attached to j.u.l root logger
 SLF4JBridgeHandler.removeHandlersForRootLogger();  // (since SLF4J 1.6.5)

 // add SLF4JBridgeHandler to j.u.l's root logger, should be done once during
 // the initialization phase of your application
 SLF4JBridgeHandler.install();
```

--------------------------------

### start(String name)

Source: https://www.slf4j.org/api/org/slf4j/profiler/Profiler.html

Starts a child stop watch and stops any previously started time instruments.

```APIDOC
## start(String name)

### Description
Starts a child stop watch and stops any previously started time instruments.

### Parameters
- **name** (String) - Required - The name of the child instrument.
```

--------------------------------

### Install and Configure Sentry for Astro

Source: https://www.slf4j.org/count/sentry.html

Use the CLI to add the integration and configure the DSN in the Astro configuration file.

```Bash
npx astro add @sentry/astro
```

```JavaScript
import { defineConfig } from "astro/config";
import sentry from "@sentry/astro";

export default defineConfig({
  integrations: [
    sentry({
      dsn: "__DSN__",
      sourceMapsUploadOptions: {
        project: "your-project-slug",
        authToken: process.env.SENTRY_AUTH_TOKEN,
      },
      tracesSampleRate: 1.0,
    }),
  ],
});
```

--------------------------------

### Initialize and use Nested Profiler

Source: https://www.slf4j.org/xref-test/org/slf4j/profiler/NestedProfilerDemo.html

Demonstrates creating a root profiler, registering it with the thread context, and starting a nested profiler to measure subtask performance.

```java
public class NestedProfilerDemo {

    public static void main(String[] args) {
        // create a profiler called "DEMO"
        Profiler profiler = new Profiler("DEMO");

        // register this profiler in the thread context's profiler registry
        ProfilerRegistry profilerRegistry = ProfilerRegistry.getThreadContextInstance();
        profiler.registerWith(profilerRegistry);

        // start a stopwatch called "RANDOM"
        profiler.start("RANDOM");
        RandomIntegerArrayGenerator riaGenerator = new RandomIntegerArrayGenerator();
        int n = 10 * 1000;
        int[] randomArray = riaGenerator.generate(n);

        // create and start a nested profiler called "SORT_AND_PRUNE"
        // By virtue of its parent-child relationship with the "DEMO"
        // profiler, and the previous registration of the parent profiler,
        // this nested profiler will be automatically registered
        // with the thread context's profiler registry
        profiler.startNested(SortAndPruneComposites.NESTED_PROFILER_NAME);

        SortAndPruneComposites pruner = new SortAndPruneComposites(randomArray);
        pruner.sortAndPruneComposites();

        // stop and print the "DEMO" printer
        profiler.stop().print();
    }
}
```

--------------------------------

### Profiler Output Example

Source: https://www.slf4j.org/xref-test/org/slf4j/profiler/BasicProfilerDemo.html

Displays the expected console output format when using the SLF4J profiler.

```text
   + Profiler [BASIC]
   |-- elapsed time                      [A]   213.186 milliseconds.
   |-- elapsed time                      [B]  2499.107 milliseconds.
   |-- elapsed time                  [OTHER]  3300.752 milliseconds.
   |-- Total                         [BASIC]  6014.161 milliseconds.
```

--------------------------------

### Install Sentry via Wizard

Source: https://www.slf4j.org/count/sentry.html

Use the Sentry wizard to automatically configure Sentry for specific frameworks.

```Bash
npx @sentry/wizard@latest -i nextjs
```

```Bash
npx @sentry/wizard@latest -i angular
```

```Bash
brew install getsentry/tools/sentry-wizard && sentry-wizard -i android
```

```Bash
brew install getsentry/tools/sentry-wizard && sentry-wizard -i ios
```

```Bash
npx @sentry/wizard@latest -i flutter
```

```Bash
npx @sentry/wizard@latest -i reactNative
```

--------------------------------

### Configure Sentry in Ruby

Source: https://www.slf4j.org/count/sentry.html

Install the gem and initialize Sentry with a DSN and optional custom sampling logic.

```Ruby
gem "sentry-ruby"
```

```Ruby
Sentry.init do |config|
  config.dsn = 'https://<key>@sentry.io/<project>'

  # Set a uniform sample rate between 0.0 and 1.0
  # We recommend adjusting the value in production:
  config.traces_sample_rate = 1.0

  # or control sampling dynamically
  config.traces_sampler = lambda do |sampling_context|
    # sampling_context[:transaction_context] contains the information about the transaction
    # sampling_context[:parent_sampled] contains the transaction's parent's sample decision
    true # return value can be a boolean or a float between 0.0 and 1.0
  end
end
```

--------------------------------

### Configure Appender via URI

Source: https://www.slf4j.org/count/rainbowgum.html

Example of configuring an appender using a URI with query parameters.

```properties
logging.appender.example.encoder=gelf:///?prettyPrint=true
```

--------------------------------

### isInstalled()

Source: https://www.slf4j.org/api/org/slf4j/bridge/SLF4JBridgeHandler.html

Checks if the SLF4JBridgeHandler is currently installed.

```APIDOC
### static boolean isInstalled()

Returns true if SLF4JBridgeHandler has been previously installed, false otherwise.
```

--------------------------------

### Basic Profiler Usage

Source: https://www.slf4j.org/extensions.html

Demonstrates initializing a profiler and measuring execution time of specific code segments using start and stop methods.

```java
32  public class BasicProfilerDemo {
33  
34    public static void main(String[] args) {
35      // create a profiler called "BASIC"
36      **Profiler profiler = new Profiler("BASIC");**
37      **profiler.start("A");**
38      doA();
39  
40      **profiler.start("B");**
41      doB();
42      
43      **profiler.start("OTHER");**
44      doOther();
45      **profiler.stop().print();**
46    }
```

--------------------------------

### Configure Appender and Encoder

Source: https://www.slf4j.org/count/rainbowgum.html

Example of setting appender and encoder properties using interpolated keys.

```properties
logging.appender.example.encoder=gelf
logging.encoder.example.prettyPrint=true
```

--------------------------------

### Install Log4j Core Dependency

Source: https://www.slf4j.org/count/log4j2_slf4j_binding.html

Add the Log4j Core reference implementation to your project dependencies.

```xml
<dependencies>

  <!-- Logging implementation (Log4j Core) -->
  <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <scope>runtime</scope>
  </dependency>

  <!-- Logging bridges will follow... -->

</dependencies>
```

```groovy
runtimeOnly 'org.apache.logging.log4j:log4j-core'
// Logging bridges will follow...
```

--------------------------------

### Install Log4j2 in Spring Boot

Source: https://www.slf4j.org/count/log4j2_slf4j_binding.html

Replace the default logging starter with Log4j2 to enable Log4j Core in Spring Boot applications.

```xml
<dependencies>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
      <exclusion>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-logging</artifactId>
      </exclusion>
    </exclusions>
  </dependency>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
    <scope>runtime</scope>
  </dependency>

</dependencies>
```

```groovy
configurations {
  all.exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging'
}

dependencies {
  runtimeOnly group: 'org.springframework.boot', module: 'spring-boot-starter-log4j2'
}
```

--------------------------------

### Sample SimpleLogger Output

Source: https://www.slf4j.org/api/org/slf4j/simple/SimpleLogger.html

Example of the default log output format showing relative time, thread name, log level, logger name, and message.

```text
 176 [main] INFO examples.Sort - Populating an array of 2 elements in reverse order.
 225 [main] INFO examples.SortAlgo - Entered the sort method.
 304 [main] INFO examples.SortAlgo - Dump of integer array:
 317 [main] INFO examples.SortAlgo - Element [0] = 0
 331 [main] INFO examples.SortAlgo - Element [1] = 1
 343 [main] INFO examples.Sort - The next log statement should be an error message.
 346 [main] ERROR examples.SortAlgo - Tried to dump an uninitialized array.
   at org.log4j.examples.SortAlgo.dump(SortAlgo.java:58)
   at org.log4j.examples.Sort.main(Sort.java:64)
 467 [main] INFO  examples.Sort - Exiting main method.
```

--------------------------------

### Successful SLF4J console output

Source: https://www.slf4j.org/manual.html

Example of the console output when a valid SLF4J provider is correctly configured on the classpath.

```text
0 [main] INFO HelloWorld - Hello World
```

--------------------------------

### Configure Rainbow Gum Appender Output

Source: https://www.slf4j.org/count/rainbowgum.html

Example configuration for defining a log appender output path.

```properties
  logging.appenders=myappender
  logging.appender.myappender.output=/var/log/app.log
```

--------------------------------

### Configure Appender Encoder via Properties

Source: https://www.slf4j.org/count/rainbowgum.html

Example configuration for an appender's encoder using properties, including enabling pretty print.

```properties
logging.appenders=myappender
logging.appender.myappender.encoder=gelf
logging.encoder.myappender.prettyPrint=true
```

--------------------------------

### Identify missing SLF4J provider warnings

Source: https://www.slf4j.org/manual.html

Console output examples indicating that no logging provider was found on the classpath, resulting in a NOP logger.

```text
SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See https://www.slf4j.org/codes.html#noProviders for further details.
```

```text
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See https://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
```

--------------------------------

### Initialize and use a Logger in Java

Source: https://www.slf4j.org/manual.html

Demonstrates the standard approach to obtaining a logger instance and outputting an info-level message.

```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {

  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}
```

--------------------------------

### configureAndWatch(String configFilename, long delay)

Source: https://www.slf4j.org/api/org/apache/log4j/PropertyConfigurator.html

Configures log4j and starts a file watcher to monitor changes to the configuration file.

```APIDOC
## static void configureAndWatch(String configFilename, long delay)

### Description
Configures log4j and starts a file watcher to monitor changes to the configuration file.

### Parameters
- **configFilename** (String) - The path to the configuration file.
- **delay** (long) - The delay in milliseconds between file checks.
```

--------------------------------

### Incorrect exception logging example

Source: https://www.slf4j.org/faq.html

An example of an invalid logging call that fails to print the stack trace.

```java
logger.debug(new Exception("some error"));
```

--------------------------------

### Print Start and Stop Times

Source: https://www.slf4j.org/api/src-html/org/slf4j/agent/AgentPremain.html

Prints the start time to System.err and registers a shutdown hook to print the stop time and elapsed duration.

```java
private static void printStartStopTimes() {
        final long start = System.currentTimeMillis();

        System.err.println("Start at " + new Date());

        Thread hook = new Thread(() -> {
            long timePassed = System.currentTimeMillis() - start;
            System.err.println("Stop at " + new Date() + ", execution time = " + timePassed + " ms");
        });
```

--------------------------------

### elapsedTime()

Source: https://www.slf4j.org/api/org/slf4j/profiler/Profiler.html

Returns the time elapsed between start and stop in nanoseconds.

```APIDOC
## elapsedTime()

### Description
Returns the time elapsed between start and stop, in nanoseconds.

### Returns
- **long** - Time elapsed in nanoseconds.
```

--------------------------------

### get(String key)

Source: https://www.slf4j.org/api/org/apache/log4j/MDC.html

Retrieves a value from the MDC map.

```APIDOC
## get(String key)

### Description
Retrieves the value associated with the specified key from the MDC map.

### Parameters
- **key** (String) - The key to look up.

### Returns
- **Object** - The value associated with the key, or null if not found.
```

--------------------------------

### Typical Logger Usage Pattern

Source: https://www.slf4j.org/api/org/slf4j/Logger.html

Demonstrates how to initialize a logger using LoggerFactory and perform parameterized logging within a class.

```java
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 public class Wombat {

   final static Logger logger = LoggerFactory.getLogger(Wombat.class);
   Integer t;
   Integer oldT;

   public void setTemperature(Integer temperature) {
     oldT = t;
     t = temperature;
     logger.debug("Temperature set to {}. Old temperature was {}.", t, oldT);
     if (temperature.intValue() > 50) {
       logger.info("Temperature has risen above 50 degrees.");
     }
   }
 }
```

--------------------------------

### Get the ILoggerFactory Instance

Source: https://www.slf4j.org/api/src-html/org/slf4j/LoggerFactory.html

Returns the currently bound ILoggerFactory instance.

```java
public static ILoggerFactory getILoggerFactory() {
        return getProvider().getLoggerFactory();
    }
```

--------------------------------

### Level Management

Source: https://www.slf4j.org/api/org/apache/commons/logging/impl/SimpleLog.html

Methods to get and set the current logging level.

```APIDOC
## Methods: getLevel, setLevel

### Description
Manage the logging threshold for the SimpleLog instance.

### Methods
- **int getLevel()**
- **void setLevel(int currentLogLevel)**

### Parameters
- **currentLogLevel** (int) - Required - The new logging level to set.
```

--------------------------------

### Acquire a Log instance using LogFactory

Source: https://www.slf4j.org/api/org/apache/commons/logging/package-summary.html

Demonstrates the standard and shorthand methods for obtaining a Log instance.

```java
  Log log = LogFactory.getFactory().getInstance(Foo.class);
```

```java
  Log log = LogFactory.getLog(Foo.class);
```

--------------------------------

### uninstall()

Source: https://www.slf4j.org/api/org/slf4j/bridge/SLF4JBridgeHandler.html

Removes previously installed SLF4JBridgeHandler instances from the JUL root logger.

```APIDOC
### static void uninstall()

Removes previously installed SLF4JBridgeHandler instances. 

#### Throws
- **SecurityException** - Thrown if a security manager exists and the caller lacks LoggingPermission("control").
```

--------------------------------

### Check Installation Status

Source: https://www.slf4j.org/api/src-html/org/slf4j/bridge/SLF4JBridgeHandler.html

Verifies if an SLF4JBridgeHandler is currently attached to the JUL root logger.

```java
public static boolean isInstalled() {
    java.util.logging.Logger rootLogger = getRootLogger();
    Handler[] handlers = rootLogger.getHandlers();
    for (Handler handler : handlers) {
        if (handler instanceof SLF4JBridgeHandler) {
            return true;
        }
    }
    return false;
}
```

--------------------------------

### Initialize Sentry in Solid

Source: https://www.slf4j.org/count/sentry.html

Initialize the Sentry SDK in the Solid entry point before rendering the application.

```JSX
// index.jsx / index.tsx

import * as Sentry from "@sentry/solid";
import { useBeforeLeave, useLocation } from "@solidjs/router";
import { render } from "solid-js/web";
import App from "./app";

// Initialize the Sentry SDK here 
Sentry.init({
  dsn: "__DSN__",
  integrations: [Sentry.browserTracingIntegration()],

  // Performance Monitoring
  tracesSampleRate: 1.0, //  Capture 100% of the transactions
  // Set 'tracePropagationTargets' to control for which URLs trace propagation should be enabled
  tracePropagationTargets: ["localhost", /^https:\/\/yourserver\.io\/api/],
});

const app = document.getElementById("app");

if (!app) throw new Error("No #app element found in the DOM.");

render(() => <App />, app)
```

--------------------------------

### Perform Initialization and Binding

Source: https://www.slf4j.org/xref/org/slf4j/LoggerFactory.html

Orchestrates the binding process by locating providers and initializing the SLF4J environment.

```java
private final static void performInitialization() {
        bind();
        if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
            versionSanityCheck();
        }
    }

    private final static void bind() {
        try {
            List<SLF4JServiceProvider> providersList = findServiceProviders();
            reportMultipleBindingAmbiguity(providersList);
            if (providersList != null && !providersList.isEmpty()) {
                PROVIDER = providersList.get(0);
                // SLF4JServiceProvider.initialize() is intended to be called here and nowhere else.
                PROVIDER.initialize();
                INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
                reportActualBinding(providersList);
            } else {
                INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
                Util.report("No SLF4J providers were found.");
                Util.report("Defaulting to no-operation (NOP) logger implementation");
                Util.report("See " + NO_PROVIDERS_URL + " for further details.");

                Set<URL> staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportIgnoredStaticLoggerBinders(staticLoggerBinderPathSet);
            }
            postBindCleanUp();
        } catch (Exception e) {
            failedBinding(e);
            throw new IllegalStateException("Unexpected initialization failure", e);
        }
    }
```

--------------------------------

### Get value from MDC

Source: https://www.slf4j.org/api/src-html/org/slf4j/MDC.html

Retrieves the value associated with the specified key from the diagnostic context.

```java
public static String get(String key) throws IllegalArgumentException {
        if (key == null) {
            throw new IllegalArgumentException("key parameter cannot be null");
        }

        if (getMDCAdapter() == null) {
            throw new IllegalStateException(MDC_APAPTER_CANNOT_BE_NULL_MESSAGE);
        }
        return getMDCAdapter().get(key);
    }
```

--------------------------------

### Get XLogger instance by class

Source: https://www.slf4j.org/api/src-html/org/slf4j/ext/XLoggerFactory.html

Creates an XLogger instance named after the provided class.

```java
public static XLogger getXLogger(Class<?> clazz) {
        return getXLogger(clazz.getName());
    }
```

--------------------------------

### get(String key)

Source: https://www.slf4j.org/api/org/slf4j/helpers/BasicMDCAdapter.html

Retrieves a value from the current thread's context map.

```APIDOC
## get(String key)

### Description
Get the context value identified by the key parameter.

### Parameters
- **key** (String) - Required - The key to look up.

### Returns
- **String** - The value associated with the key.
```

--------------------------------

### postInitialization()

Source: https://www.slf4j.org/api/org/slf4j/helpers/SubstituteLoggerFactory.html

Performs post-initialization tasks for the factory.

```APIDOC
## void postInitialization()

### Description
Executes post-initialization logic for the factory.
```

--------------------------------

### Initialize Sentry SDK

Source: https://www.slf4j.org/count/sentry.html

Configuration patterns for initializing the Sentry SDK in various languages.

```Python
import sentry_sdk

sentry_sdk.init(
    "https://<key>@sentry.io/<project>",

    # Set traces_sample_rate to 1.0 to capture 100%
    # of transactions for Tracing.
    # We recommend adjusting this value in production.
    enable_tracing=True,
    traces_sample_rate=1.0,
)
```

```JavaScript
const Sentry = require('@sentry/node');
Sentry.init({ dsn: 'https://<key>@sentry.io/<project>' });
```

```JSX
import { useEffect } from "react";
import * as Sentry from "@sentry/react";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  integrations: [
  ],
  // Set `tracePropagationTargets` to control for which URLs trace propagation should be enabled
  tracePropagationTargets: [/^\[\//, /^https:\/\/yourserver\.io\/api/],
});
```

```JSX
// Sentry initialization should be imported first!
import "./instrument";
import App from "./App";
import { createRoot } from "react-dom/client";

const container = document.getElementById(“app”);
const root = createRoot(container);
root.render(<App />);
```

```C#
using (SentrySdk.Init(o => {
  // Tells which project in Sentry to send events to:
  o.Dsn = "https://<key>@sentry.io/<project>";
  // When configuring for the first time, to see what the SDK is doing:
  o.Debug = true;
  // Set TracesSampleRate to 1.0 to capture 100% of transactions for Tracing.
  // We recommend adjusting this value in production.
  o.TracesSampleRate = 1.0; }))
{
  // App code goes here - Disposing will flush events out
}
```

```Go
package main

import (
	"log"
	"time"

	"github.com/getsentry/sentry-go"
)

func main() {
	err := sentry.Init(sentry.ClientOptions{
		Dsn: "https://<key>@sentry.io/<project>",
    EnableTracing: true,
		// Specify a fixed sample rate:
		// We recommend adjusting this value in production
		TracesSampleRate: 1.0,
		// Or provide a custom sample rate:
		TracesSampler: sentry.TracesSampler(func(ctx sentry.SamplingContext) float64 {
			// As an example, this does not send some
			// transactions to Sentry based on their name.
			if ctx.Span.Name == "GET /health" {
				return 0.0
			}

			return 1.0
		}),
	})
	if err != nil {
		log.Fatalf("sentry.Init: %s", err)
	}
	// Flush buffered events before the program terminates.
	// Set the timeout to the maximum duration the program can afford to wait.
	defer sentry.Flush(2 * time.Second)
}
```

--------------------------------

### Configure Rainbow Gum via System Properties

Source: https://www.slf4j.org/count/rainbowgum.html

Use command-line system properties to configure appenders, encoders, and logging levels.

```bash
  java \
  -Dlogging.appender.console.encoder=pattern \
  -Dlogging.encoder.console.pattern="[%thread] %-5level %logger{15} - %msg%n" \
  -Dlogging.level.com.myapp=DEBUG \
  myapp.jar
```

--------------------------------

### Configure Sentry for Laravel

Source: https://www.slf4j.org/count/sentry.html

Install the Laravel-specific package and integrate Sentry into the application bootstrap and configuration.

```Bash
composer require sentry/sentry-laravel
```

```PHP
<?php

use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;
use Sentry\Laravel\Integration;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        //
    })
    ->withExceptions(function (Exceptions $exceptions) {
        Integration::handles($exceptions);
    })->create();
```

```PHP
// Specify a fixed sample rate:
'traces_sample_rate' => 0.2,
// Or provide a custom sampler:
'traces_sampler' => function (SentryTracingSamplingContext $context): float {
    // return a number between 0 and 1
},
```

```Bash
php artisan sentry:publish --dsn=<paste-your-DSN-here>
```

--------------------------------

### configure(String configFilename)

Source: https://www.slf4j.org/api/org/apache/log4j/PropertyConfigurator.html

Reads configuration options from a configuration file.

```APIDOC
## static void configure(String configFilename)

### Description
Reads configuration options from a configuration file.

### Parameters
- **configFilename** (String) - The path to the configuration file.
```

--------------------------------

### Basic Fluent Logging

Source: https://www.slf4j.org/manual.html

Demonstrates the basic usage of the fluent API compared to the traditional logging method.

```java
logger.atInfo().log("Hello world.");
```

```java
logger.info("Hello world.");
```

--------------------------------

### Redirecting JUL Logging to SLF4J

Source: https://www.slf4j.org/api/src-html/org/slf4j/bridge/SLF4JBridgeHandler.html

Once installed, standard java.util.logging calls are automatically redirected to SLF4J.

```java
import  java.util.logging.Logger;
...
// usual pattern: get a Logger and then log a message
Logger julLogger = Logger.getLogger("org.wombat");
julLogger.fine("hello world"); // this will get redirected to SLF4J
```

--------------------------------

### Logger Usage in JBoss Logging

Source: https://www.slf4j.org/count/jboss.html

Demonstrates how to initialize a logger and use format-style logging methods to improve performance.

```java
private static final Logger LOGGER = Logger.getLogger(Customer.class);

public Customer getCustomer(final int id) {
    LOGGER.debugf("Looking up customer %d", id);
    try {
        final Customer customer = findCustomer(id);
        LOGGER.tracef("Found customer: %s", customer);
        return customer;
    } catch (Exception e) {
        LOGGER.errorf(e, "Error looking up customer %d", id);
    }
    return null;
}
```

--------------------------------

### StackOverflowError from jcl-over-slf4j and slf4j-jcl conflict

Source: https://www.slf4j.org/codes.html

Example stack trace resulting from having both jcl-over-slf4j.jar and slf4j-jcl.jar on the classpath.

```text
Exception in thread "main" java.lang.StackOverflowError
  at java.lang.String.hashCode(String.java:1482)
  at java.util.HashMap.get(HashMap.java:300)
  at org.slf4j.impl.JCLLoggerFactory.getLogger(JCLLoggerFactory.java:67)
  at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:249)
  at org.apache.commons.logging.impl.SLF4JLogFactory.getInstance(SLF4JLogFactory.java:155)
  at org.apache.commons.logging.LogFactory.getLog(LogFactory.java:289)
  at org.slf4j.impl.JCLLoggerFactory.getLogger(JCLLoggerFactory.java:69)
  at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:249)
  at org.apache.commons.logging.impl.SLF4JLogFactory.getInstance(SLF4JLogFactory.java:155)
  subsequent lines omitted...
```

--------------------------------

### StackOverflowError from log4j-over-slf4j and slf4j-reload4j conflict

Source: https://www.slf4j.org/codes.html

Example stack trace resulting from having both log4j-over-slf4j.jar and slf4j-reload4j.jar on the classpath.

```text
Exception in thread "main" java.lang.StackOverflowError
  at java.util.Hashtable.containsKey(Hashtable.java:306)
  at org.apache.log4j.Log4jLoggerFactory.getLogger(Log4jLoggerFactory.java:36)
  at org.apache.log4j.LogManager.getLogger(LogManager.java:39)
  at org.slf4j.impl.Log4jLoggerFactory.getLogger(Log4jLoggerFactory.java:73)
  at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:249)
  at org.apache.log4j.Category.<init>(Category.java:53)
  at org.apache.log4j.Logger..<init>(Logger.java:35)
  at org.apache.log4j.Log4jLoggerFactory.getLogger(Log4jLoggerFactory.java:39)
  at org.apache.log4j.LogManager.getLogger(LogManager.java:39)
  at org.slf4j.impl.Log4jLoggerFactory.getLogger(Log4jLoggerFactory.java:73)
  at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:249)
  at org.apache.log4j.Category.<init>(Category.java:53)
  at org.apache.log4j.Logger..<init>(Logger.java:35)
  at org.apache.log4j.Log4jLoggerFactory.getLogger(Log4jLoggerFactory.java:39)
  at org.apache.log4j.LogManager.getLogger(LogManager.java:39)
  subsequent lines omitted...
```

--------------------------------

### Configure Logging via Properties

Source: https://www.slf4j.org/count/logevents.html

Define log levels and observers using a standard configuration file format.

```properties
root=WARN file,console
logger.org.example=INFO
logger.org.example.myapp=DEBUG,TRACE@marker=HTTP_REQUEST&mdc:user=admin
logevents.status=CONFIG
```

--------------------------------

### Get LoggingEventBuilder at Level

Source: https://www.slf4j.org/api/src-html/org/slf4j/Logger.html

Returns a builder for the specified level, or a NOPLoggingEventBuilder if the logger is disabled for that level.

```java
@CheckReturnValue
default public LoggingEventBuilder atLevel(Level level) {
    if (isEnabledForLevel(level)) {
        return makeLoggingEventBuilder(level);
    } else {
        return NOPLoggingEventBuilder.singleton();
    }
}
```

--------------------------------

### atInfo()

Source: https://www.slf4j.org/api/org/slf4j/Logger.html

Provides an entry point for fluent-logging at the INFO level.

```APIDOC
## LoggingEventBuilder atInfo()

### Description
Entry point for fluent-logging for Level.INFO level.

### Returns
- **LoggingEventBuilder** - Instance as appropriate for level INFO
```

--------------------------------

### Get XLogger instance by name

Source: https://www.slf4j.org/api/src-html/org/slf4j/ext/XLoggerFactory.html

Creates an XLogger instance associated with the provided logger name.

```java
public static XLogger getXLogger(String name) {
        return new XLogger(LoggerFactory.getLogger(name));
    }
```

--------------------------------

### Install SLF4J 1.x to Log4j Bridge

Source: https://www.slf4j.org/count/log4j2_slf4j_binding.html

Use the log4j-slf4j-impl artifact for legacy SLF4J 1.x support.

```xml
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-slf4j-impl</artifactId>
  <scope>runtime</scope>
</dependency>
```

```groovy
runtimeOnly 'org.apache.logging.log4j:log4j-slf4j-impl'
```

--------------------------------

### Install Log4j API Dependency

Source: https://www.slf4j.org/count/log4j2_slf4j_binding.html

Add the Log4j API dependency to your project using Maven or Gradle.

```xml
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-api</artifactId>
  <version>${log4j-api.version}</version>
</dependency>
```

```groovy
implementation 'org.apache.logging.log4j:log4j-api:${log4j-api.version}'
```

--------------------------------

### Initialize and use a Log instance in a component

Source: https://www.slf4j.org/api/org/apache/commons/logging/package-summary.html

Shows a typical implementation pattern for logging within a class, including checking debug levels before logging.

```java
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class MyComponent {

  protected static Log log =
    LogFactory.getLog(MyComponent.class);

  // Called once at startup time
  public void start() {
    ...
    log.info("MyComponent started");
    ...
  }

  // Called once at shutdown time
  public void stop() {
    ...
    log.info("MyComponent stopped");
    ...
  }

  // Called repeatedly to process a particular argument value
  // which you want logged if debugging is enabled
  public void process(String value) {
    ...
    // Do the string concatenation only if logging is enabled
    if (log.isDebugEnabled())
      log.debug("MyComponent processing " + value);
    ...
  }

}
```

--------------------------------

### Perform Initialization and Binding

Source: https://www.slf4j.org/api/src-html/org/slf4j/LoggerFactory.html

Initializes the LoggerFactory by binding to discovered service providers or falling back to a NOP implementation.

```java
private final static void performInitialization() {
        bind();
        if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
            versionSanityCheck();
        }
    }

    private final static void bind() {
        try {
            List<SLF4JServiceProvider> providersList = findServiceProviders();
            reportMultipleBindingAmbiguity(providersList);
            if (providersList != null && !providersList.isEmpty()) {
                PROVIDER = providersList.get(0);
                earlyBindMDCAdapter();
                // SLF4JServiceProvider.initialize() is intended to be called here and nowhere else.
                PROVIDER.initialize();
                INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
                reportActualBinding(providersList);
            } else {
                INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
                Reporter.warn("No SLF4J providers were found.");
                Reporter.warn("Defaulting to no-operation (NOP) logger implementation");
                Reporter.warn("See " + NO_PROVIDERS_URL + " for further details.");

                Set<URL> staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportIgnoredStaticLoggerBinders(staticLoggerBinderPathSet);
            }
            postBindCleanUp();
        } catch (Exception e) {
            failedBinding(e);
```

--------------------------------

### Activate Simple Logger

Source: https://www.slf4j.org/count/log4j2_slf4j_binding.html

Configuration to explicitly enable the Simple Logger implementation via a properties file.

```properties
# Activate Simple Logger implementation
log4j.provider = org.apache.logging.log4j.simple.internal.SimpleProvider
```

--------------------------------

### Install SLF4JBridgeHandler

Source: https://www.slf4j.org/api/src-html/org/slf4j/bridge/SLF4JBridgeHandler.html

Adds a new instance of SLF4JBridgeHandler to the JUL root logger to begin redirecting logs.

```java
public static void install() {
    LogManager.getLogManager().getLogger("").addHandler(new SLF4JBridgeHandler());
}
```

--------------------------------

### Fluent INFO Logging

Source: https://www.slf4j.org/api/src-html/org/slf4j/Logger.html

Entry point for fluent-style logging at the INFO level.

```java
@CheckReturnValue
default public LoggingEventBuilder atInfo() {
    if (isInfoEnabled()) {
        return makeLoggingEventBuilder(INFO);
    } else {
        return NOPLoggingEventBuilder.singleton();
    }
}
```

--------------------------------

### configure()

Source: https://www.slf4j.org/api/org/apache/log4j/BasicConfigurator.html

Adds a ConsoleAppender to the root logger. The output is sent to System.out.

```APIDOC
### static void configure()

Adds a ConsoleAppender to the root logger. The output is sent to System.out.
```

--------------------------------

### Configure Sentry via CDN

Source: https://www.slf4j.org/count/sentry.html

Load the Sentry SDK via script tag and initialize it with a DSN.

```HTML
<script src="https://browser.sentry-cdn.com/<VERSION>/bundle.min.js"></script>
```

```JavaScript
Sentry.init({ dsn: 'https://<key>@sentry.io/<project>',
  // This enables automatic instrumentation (highly recommended),
  // but is not necessary for purely manual usage
  // If you only want to use custom instrumentation:
  // * Remove the BrowserTracing integration
  // * add Sentry.addTracingExtensions() above your Sentry.init() call
  Integrations: [Sentry.browserTracingIntegration()],

  // We recommend adjusting this value in production, or using tracesSampler
  // for finer control
  tracesSampleRate: 1.0,

  // Set tracePropagationTargets to control for which URLs distributed tracing should be enabled
  tracePropagationTargets: ['localhost', /^https://yourserver.io/api/],
});
```

--------------------------------

### Configure Sentry for .NET

Source: https://www.slf4j.org/count/sentry.html

Add the Sentry dependency and configure the SDK via appsettings and the host builder.

```Bash
dotnet add package Sentry.AspNetCore
```

```JavaScript
"Sentry": {
  "Dsn": "https://examplePublicKey@o0.ingest.sentry.io/0",
  "Debug": true,
},
```

```C#
public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            // Add the following line:
            webBuilder.UseSentry();
        });
```

--------------------------------

### Get Fully Qualified Caller Name

Source: https://www.slf4j.org/api/src-html/org/slf4j/reload4j/Reload4jLoggerAdapter.html

Returns the nominal fully qualified caller name for the logger.

```java
@Override
    protected String getFullyQualifiedCallerName() {
        return FQCN_NOMINAL;
    }
```

--------------------------------

### BasicMDCAdapter()

Source: https://www.slf4j.org/api/org/slf4j/helpers/BasicMDCAdapter.html

Constructs a new BasicMDCAdapter instance.

```APIDOC
## BasicMDCAdapter()

### Description
Initializes a new instance of the BasicMDCAdapter.
```

--------------------------------

### Get ServiceLoader with Security Manager Support

Source: https://www.slf4j.org/api/src-html/org/slf4j/LoggerFactory.html

Retrieves a ServiceLoader instance, utilizing AccessController if a SecurityManager is present.

```java
private static ServiceLoader<SLF4JServiceProvider> getServiceLoader(final ClassLoader classLoaderOfLoggerFactory) {
        ServiceLoader<SLF4JServiceProvider> serviceLoader;
        SecurityManager securityManager = System.getSecurityManager();
        if(securityManager == null) {
            serviceLoader = ServiceLoader.load(SLF4JServiceProvider.class, classLoaderOfLoggerFactory);
        } else {
            final PrivilegedAction<ServiceLoader<SLF4JServiceProvider>> action = () -> ServiceLoader.load(SLF4JServiceProvider.class, classLoaderOfLoggerFactory);
            serviceLoader = AccessController.doPrivileged(action);
        }
        return serviceLoader;
    }
```

--------------------------------

### Declare Logback-classic Dependencies

Source: https://www.slf4j.org/manual.html

Configure Logback as the logging framework for Javax or Jakarta EE environments.

```xml
<dependency> 
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.3.14</version>
</dependency>
```

```xml
<dependency> 
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.5.15</version>
</dependency>
```

--------------------------------

### Install JPL to Log4j Bridge

Source: https://www.slf4j.org/count/log4j2_slf4j_binding.html

Bridge Java Platform Logging (JPL) to Log4j using the log4j-jpl artifact.

```xml
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-jpl</artifactId>
  <scope>runtime</scope>
</dependency>
```

```groovy
runtimeOnly 'org.apache.logging.log4j:log4j-jpl'
```

--------------------------------

### Fluent Logging Entry Point

Source: https://www.slf4j.org/api/src-html/org/slf4j/Logger.html

Provides a fluent API for WARN level logging, returning a builder instance.

```java
@CheckReturnValue
default public LoggingEventBuilder atWarn() {
    if (isWarnEnabled()) {
        return makeLoggingEventBuilder(WARN);
    } else {
        return NOPLoggingEventBuilder.singleton();
    }
}
```

--------------------------------

### Install SLF4J 2.x to Log4j Bridge

Source: https://www.slf4j.org/count/log4j2_slf4j_binding.html

Use the log4j-slf4j2-impl artifact to bridge SLF4J 2.x calls to Log4j.

```xml
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-slf4j2-impl</artifactId>
  <scope>runtime</scope>
</dependency>
```

```groovy
runtimeOnly 'org.apache.logging.log4j:log4j-slf4j2-impl'
```

--------------------------------

### Compare localized and non-localized logging conventions

Source: https://www.slf4j.org/localization.html

Demonstrates the difference between MessageFormat convention for localized logs and {} convention for standard logs.

```java
import ...;
public class MyApplication {

  IMessageConveyor  messageConveyor = new MessageConveyor(Locale.UK);
  LocLoggerFactory llFactory_uk = new LocLoggerFactory(messageConveyor);
  LocLogger locLogger = llFactory_uk.getLocLogger(this.getClass());

  public void someMethod() {
    // follows the MessageFormat convention
    locLogger.info(Production.APPLICATION_STARTED, "fooApp");

   // follows the {} convention
   logLogger.info("Hello {}", name);
   ...  
  }  
}
```

--------------------------------

### Create Log instances

Source: https://www.slf4j.org/api/src-html/org/apache/commons/logging/LogFactory.html

Methods to obtain a Log instance by class or by name.

```java
public abstract Log getInstance(Class clazz) throws LogConfigurationException;

    public abstract Log getInstance(String name) throws LogConfigurationException;
```

--------------------------------

### atTrace()

Source: https://www.slf4j.org/api/org/slf4j/Logger.html

Entry point for fluent-logging for the TRACE level.

```APIDOC
## LoggingEventBuilder atTrace()

### Description
Entry point for fluent-logging for `Level.TRACE` level.

### Returns
- **LoggingEventBuilder** - Instance as appropriate for level TRACE.
```

--------------------------------

### Simple Logger Error Message

Source: https://www.slf4j.org/count/log4j2_slf4j_binding.html

Example of the error message generated by the Log4j API when no logging provider is found.

```text
2024-10-03T11:53:34.281462230Z main ERROR Log4j API could not find a logging provider.
```

--------------------------------

### NoClassDefFoundError for LoggingEvent

Source: https://www.slf4j.org/codes.html

Example of the stack trace encountered when using an incompatible version of slf4j-api with Logback 1.1.4 or later.

```text
Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/event/LoggingEvent
        at java.lang.Class.getDeclaredMethods0(Native Method)
        at java.lang.Class.privateGetDeclaredMethods(Class.java:2451)
        at java.lang.Class.privateGetPublicMethods(Class.java:2571)
        at java.lang.Class.getMethods(Class.java:1429)
        at java.beans.Introspector.getPublicDeclaredMethods(Introspector.java:1261)
        at java.beans.Introspector.getTargetMethodInfo(Introspector.java:1122)
        at java.beans.Introspector.getBeanInfo(Introspector.java:414)
        at java.beans.Introspector.getBeanInfo(Introspector.java:161)
```

--------------------------------

### SimpleLog(String name)

Source: https://www.slf4j.org/api/org/apache/commons/logging/impl/SimpleLog.html

Constructs a new SimpleLog instance with the specified name.

```APIDOC
## Constructor: SimpleLog(String name)

### Description
Construct a simple log with the given name.

### Parameters
- **name** (String) - Required - The name of the logger instance.
```

--------------------------------

### Manual String Conversion Requirement

Source: https://www.slf4j.org/migrator.html

Example of a log statement requiring manual modification when using non-string objects.

```java
logger.debug(new Object());
```

```java
logger.debug(new Object().toString());
```

--------------------------------

### Get Fully Qualified Caller Name

Source: https://www.slf4j.org/api/src-html/org/slf4j/simple/SimpleLogger.html

Returns the fully qualified caller name, currently implemented as null.

```java
@Override
    protected String getFullyQualifiedCallerName() {
        return null;
    }
```

--------------------------------

### Sample resource bundle for en_UK locale

Source: https://www.slf4j.org/localization.html

Define localized messages in a properties file using the keys from the enum.

```properties
APPLICATION_STARTED=Application **{0}** has started.
APPLICATION_STOPPED=Application **{0}** has stopped.
... 
```
Tokens:
Raw