Added LoggerTakingImplicit

Author: paweliwanow

README.md

@@ -79,6 +79,45 @@ class MyClass extends LazyLogging {
 }
 ```
 
+`LoggerTakingImplicit` provides the same methods as `Logger` class, but with additional implicit parameter `A`.
+During creation of the `LoggerTakingImplicit` evidence `CanLog[A]` is required.
+It may be useful when contextual parameter (e.g. _Correlation ID_) is being passed around and you would like to include it in the log messages:
+ 
+```scala
+case class CorrelationId(value: String)
+implicit case object CanLogCorrelationId extends CanLog[CorrelationId] {
+  override def logMessage(originalMsg: String, a: CorrelationId): String = s"${a.value} $originalMsg"
+}
+
+ 
+implicit val correlationId = CorrelationId("ID") 
+ 
+val logger = Logger.takingImplicit[CorrelationId]("test")
+logger.info("Test") // logs "ID Test"
+```
+ 
+It's possible to use `MDC` through `CanLog` without any troubles with execution context.
+
+```scala
+case class CorrelationId(value: String)
+implicit case object CanLogCorrelationId extends CanLog[CorrelationId] {
+  override def logMessage(originalMsg: String, a: CorrelationId): String = {
+    MDC.put("correlationId", a.value)
+    originalMsg
+  }
+  
+  override def afterLog(a: A): Unit = {
+    MDC.remove("correlationId")
+  }
+}
+
+ 
+implicit val correlationId = CorrelationId("ID") 
+ 
+val logger = Logger.takingImplicit[CorrelationId]("test")
+Future(logger.info("Test"))
+```
+
 ### What's new?
 
 ##### 3.5.0

src/main/scala/com/typesafe/scalalogging/Logger.scala

@@ -31,6 +31,12 @@ object Logger {
   def apply(underlying: Underlying): Logger =
     new Logger(underlying)
 
+  /**
+    * Create a [[LoggerTakingImplicit]] wrapping the given underlying `org.slf4j.Logger`.
+    */
+  def takingImplicit[A](underlying: Underlying)(implicit ev: CanLog[A]): LoggerTakingImplicit[A] =
+    new LoggerTakingImplicit[A](underlying)
+
   /**
    * Create a [[Logger]] for the given name.
    * Example:
@@ -41,12 +47,28 @@ object Logger {
   def apply(name: String): Logger =
     new Logger(LoggerFactory.getLogger(name))
 
+  /**
+    * Create a [[LoggerTakingImplicit]] for the given name.
+    * Example:
+    * {{{
+    *   val logger = Logger.takingImplicit[CorrelationId]("application")
+    * }}}
+    */
+  def takingImplicit[A](name: String)(implicit ev: CanLog[A]): LoggerTakingImplicit[A] =
+    new LoggerTakingImplicit[A](LoggerFactory.getLogger(name))
+
   /**
    * Create a [[Logger]] wrapping the created underlying `org.slf4j.Logger`.
    */
-  def apply(clazz: Class[_]): Logger =
+  def apply[A](clazz: Class[_]): Logger =
     new Logger(LoggerFactory.getLogger(clazz.getName))
 
+  /**
+    * Create a [[LoggerTakingImplicit]] wrapping the created underlying `org.slf4j.Logger`.
+    */
+  def takingImplicit[A](clazz: Class[_])(implicit ev: CanLog[A]): LoggerTakingImplicit[A] =
+    new LoggerTakingImplicit[A](LoggerFactory.getLogger(clazz.getName))
+
   /**
    * Create a [[Logger]] for the runtime class wrapped by the implicit class
    * tag parameter.
@@ -57,6 +79,17 @@ object Logger {
    */
   def apply[T](implicit ct: ClassTag[T]): Logger =
     new Logger(LoggerFactory.getLogger(ct.runtimeClass.getName.stripSuffix("$")))
+
+  /**
+    * Create a [[LoggerTakingImplicit]] for the runtime class wrapped by the implicit class
+    * tag parameter.
+    * Example:
+    * {{{
+    *   val logger = Logger.takingImplicit[MyClass]
+    * }}}
+    */
+  def takingImplicit[T, A](implicit ct: ClassTag[T], ev: CanLog[A]): LoggerTakingImplicit[A] =
+    new LoggerTakingImplicit[A](LoggerFactory.getLogger(ct.runtimeClass.getName.stripSuffix("$")))
 }
 
 /**

src/main/scala/com/typesafe/scalalogging/LoggerTakingImplicit.scala

@@ -0,0 +1,84 @@
+package com.typesafe.scalalogging
+
+import org.slf4j.{ Marker, Logger => Underlying }
+
+trait CanLog[A] { this: Serializable =>
+  def logMessage(originalMsg: String, a: A): String
+  def afterLog(a: A): Unit = ()
+}
+
+@SerialVersionUID(957385465L)
+final class LoggerTakingImplicit[A] private[scalalogging] (val underlying: Underlying)
+    (implicit val canLogEv: CanLog[A]) extends Serializable {
+
+  // Error
+
+  def error(message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessage[A]
+
+  def error(message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessageCause[A]
+
+  def error(message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessageArgs[A]
+
+  def error(marker: Marker, message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessageMarker[A]
+
+  def error(marker: Marker, message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessageCauseMarker[A]
+
+  def error(marker: Marker, message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessageArgsMarker[A]
+
+  // Warn
+
+  def warn(message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessage[A]
+
+  def warn(message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessageCause[A]
+
+  def warn(message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessageArgs[A]
+
+  def warn(marker: Marker, message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessageMarker[A]
+
+  def warn(marker: Marker, message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessageCauseMarker[A]
+
+  def warn(marker: Marker, message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessageArgsMarker[A]
+
+  // Info
+
+  def info(message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessage[A]
+
+  def info(message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessageCause[A]
+
+  def info(message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessageArgs[A]
+
+  def info(marker: Marker, message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessageMarker[A]
+
+  def info(marker: Marker, message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessageCauseMarker[A]
+
+  def info(marker: Marker, message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessageArgsMarker[A]
+
+  // Debug
+
+  def debug(message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessage[A]
+
+  def debug(message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessageCause[A]
+
+  def debug(message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessageArgs[A]
+
+  def debug(marker: Marker, message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessageMarker[A]
+
+  def debug(marker: Marker, message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessageCauseMarker[A]
+
+  def debug(marker: Marker, message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessageArgsMarker[A]
+
+  // Trace
+
+  def trace(message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessage[A]
+
+  def trace(message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessageCause[A]
+
+  def trace(message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessageArgs[A]
+
+  def trace(marker: Marker, message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessageMarker[A]
+
+  def trace(marker: Marker, message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessageCauseMarker[A]
+
+  def trace(marker: Marker, message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessageArgsMarker[A]
+
+}