scala-logging

Scala Logging is a **convenient** and **fast** logging library wrapping [SLF4J](http://www.slf4j.org).

![CI][Badge-CI] [![Version][Badge-Releases]][Link-Releases]

[Badge-CI]: https://github.com/lightbend-labs/scala-logging/actions/workflows/ci.yml/badge.svg
[Badge-Releases]: https://img.shields.io/maven-central/v/com.typesafe.scala-logging/scala-logging_3
[Link-Releases]: https://repo1.maven.org/maven2/com/typesafe/scala-logging/scala-logging_3/

It's convenient, because you can simply call log methods, *without* checking whether the respective log level is enabled:

```scala
logger.debug(s"Some $expensive message!")
```

It's fast, because thanks to Scala macros the *check-enabled-idiom* is applied and the following code is generated:

```scala
if (logger.isDebugEnabled) logger.debug(s"Some $expensive message!")
```

## Prerequisites

* Java 11 or higher
  * Scala Logging 3.x supports Java 8
* Scala 2.12, 2.13 or 3.0
* Logging backend compatible with SLF4J

A compatible logging backend is [Logback](http://logback.qos.ch), add it to your sbt build definition:

```scala
libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.4.14"
```

If you are looking for a version compatible with Scala 2.10, check out Scala Logging 2.x.

**If you are looking for a version compatible with SLF4J 1.x, check out Scala Logging 3.x.**


## Getting Scala Logging

Scala Logging is published to Sonatype OSS and Maven Central:

- Group id / organization: *com.typesafe.scala-logging*
- Artifact id / name: *scala-logging*

sbt users may add this to their `build.sbt`:

```scala
libraryDependencies += "com.typesafe.scala-logging" %% "scala-logging" % "4.0.0-RC1"
```

## Using Scala Logging

The `Logger` class from the `com.typesafe.scalalogging` package wraps an underlying SLF4J logger.
In order to create a `Logger`, you pass a name to the `apply` factory method defined in the `Logger` companion object:

```scala
val logger = Logger("name")
```

Or, you pass in a SLF4J logger instance:

```scala
val logger = Logger(LoggerFactory.getLogger("name"))
```

Or, you pass in the name of the class into which it is defined:

```scala
val logger = Logger(getClass.getName)
```

Or, you pass in a class:

```scala
val logger = Logger(classOf[MyClass])
```

Or, using the runtime class wrapped by the implicit class tag parameter:

```scala
val logger = Logger[MyClass]
```

The `LazyLogging` and `StrictLogging` traits from the `com.typesafe.scalalogging` package define the `logger` member as
a lazy or strict value respectively, whereas the `AnyLogging` trait defines an abstract `logger`.

It depends on the individual use case which trait to use. However, we have defined some scenarios where you can use these traits:

- Use `LazyLogging` if you are creating lots of objects with this trait repetitively.
- Use `StrictLogging` pretty much by default, especially if the class is a singleton, or you know the log methods will always be invoked.
- Use `AnyLogging` when writing some trait