logger taking constructor arg macro, for when you have a context, but you don't want to pass it each time via implicit for every call, just set it once when you instantiate the logger.

see lightbend-labs#208

Author: grunzwei

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

@@ -4,82 +4,82 @@ import org.slf4j.Marker
 
 /**
  *
- * abstract class common for both Logger and LoggerTakingConstructorArg,
+ * trait for wrapping Logger and LoggerTakingConstructorArg,
  * if you have a library that is sometimes used in a context - in which case you want to log the context,
- * but other times is used outside of a context in which case you want to log "normally", your base class can have a logger of this abstract type
-*/
+ * but other times is used outside of a context in which case you want to log "normally", you can wrap them with this, as shown in ALoggerAdapter in tests.
+ * due to macro compilation limitations, ALoggerAdapter can't be included in this jar.
+ */
 trait ALogger {
 
   // Error
 
-  def error(message: String): Unit = {}
+  def error(message: String): Unit
 
-  def error(message: String, cause: Throwable): Unit = {}
+  def error(message: String, cause: Throwable): Unit
 
-  def error(message: String, args: Any*): Unit = {}
+  def error(message: String, args: Any*): Unit
 
-  def error(marker: Marker, message: String): Unit = {}
+  def error(marker: Marker, message: String): Unit
 
-  def error(marker: Marker, message: String, cause: Throwable): Unit = {}
+  def error(marker: Marker, message: String, cause: Throwable): Unit
 
-  def error(marker: Marker, message: String, args: Any*): Unit = {}
+  def error(marker: Marker, message: String, args: Any*): Unit
 
   // Warn
 
-  def warn(message: String): Unit = {}
+  def warn(message: String): Unit
 
-  def warn(message: String, cause: Throwable): Unit = {}
+  def warn(message: String, cause: Throwable): Unit
 
-  def warn(message: String, args: Any*): Unit = {}
+  def warn(message: String, args: Any*): Unit
 
-  def warn(marker: Marker, message: String): Unit = {}
+  def warn(marker: Marker, message: String): Unit
 
-  def warn(marker: Marker, message: String, cause: Throwable): Unit = {}
+  def warn(marker: Marker, message: String, cause: Throwable): Unit
 
-  def warn(marker: Marker, message: String, args: Any*): Unit = {}
+  def warn(marker: Marker, message: String, args: Any*): Unit
 
   // Info
 
-  def info(message: String): Unit = {}
+  def info(message: String): Unit
 
-  def info(message: String, cause: Throwable): Unit = {}
+  def info(message: String, cause: Throwable): Unit
 
-  def info(message: String, args: Any*): Unit = {}
+  def info(message: String, args: Any*): Unit
 
-  def info(marker: Marker, message: String): Unit = {}
+  def info(marker: Marker, message: String): Unit
 
-  def info(marker: Marker, message: String, cause: Throwable): Unit = {}
+  def info(marker: Marker, message: String, cause: Throwable): Unit
 
-  def info(marker: Marker, message: String, args: Any*): Unit = {}
+  def info(marker: Marker, message: String, args: Any*): Unit
 
   // Debug
 
-  def debug(message: String): Unit = {}
+  def debug(message: String): Unit
 
-  def debug(message: String, cause: Throwable): Unit = {}
+  def debug(message: String, cause: Throwable): Unit
 
-  def debug(message: String, args: Any*): Unit = {}
+  def debug(message: String, args: Any*): Unit
 
-  def debug(marker: Marker, message: String): Unit = {}
+  def debug(marker: Marker, message: String): Unit
 
-  def debug(marker: Marker, message: String, cause: Throwable): Unit = {}
+  def debug(marker: Marker, message: String, cause: Throwable): Unit
 
-  def debug(marker: Marker, message: String, args: Any*): Unit = {}
+  def debug(marker: Marker, message: String, args: Any*): Unit
 
   // Trace
 
-  def trace(message: String): Unit = {}
+  def trace(message: String): Unit
 
-  def trace(message: String, cause: Throwable): Unit = {}
+  def trace(message: String, cause: Throwable): Unit
 
-  def trace(message: String, args: Any*): Unit = {}
+  def trace(message: String, args: Any*): Unit
 
-  def trace(marker: Marker, message: String): Unit = {}
+  def trace(marker: Marker, message: String): Unit
 
-  def trace(marker: Marker, message: String, cause: Throwable): Unit = {}
+  def trace(marker: Marker, message: String, cause: Throwable): Unit
 
-  def trace(marker: Marker, message: String, args: Any*): Unit = {}
+  def trace(marker: Marker, message: String, args: Any*): Unit
 
 }
 
-

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

@@ -63,7 +63,6 @@ object Logger {
   def takingImplicit[A](name: String)(implicit ev: CanLog[A]): LoggerTakingImplicit[A] =
     new LoggerTakingImplicit[A](LoggerFactory.getLogger(name))
 
-
   /**
    * Create a [[LoggerTakingConstructorArg]] for the given name.
    * Example:
@@ -122,93 +121,93 @@ object Logger {
    *   val logger = Logger.inContextOf[MyClass, CorrelationId]
    * }}}
    */
-  def inContextOf[T,A](implicit ct: ClassTag[T], ev: CanLog[A], a: A): LoggerTakingConstructorArg[A] =
+  def inContextOf[T, A](implicit ct: ClassTag[T], ev: CanLog[A], a: A): LoggerTakingConstructorArg[A] =
     new LoggerTakingConstructorArg[A](LoggerFactory.getLogger(ct.runtimeClass.getName.stripSuffix("$")), ev, a)
 }
 
 /**
  * Implementation of a fast logger based on macros and an underlying `org.slf4j.Logger`.
  */
 @SerialVersionUID(538248225L)
-final class Logger private (val underlying: Underlying) extends ALogger with Serializable {
+final class Logger private (val underlying: Underlying) extends Serializable {
 
   // Error
 
-  override def error(message: String): Unit = macro LoggerMacro.errorMessage
+  def error(message: String): Unit = macro LoggerMacro.errorMessage
 
-  override def error(message: String, cause: Throwable): Unit = macro LoggerMacro.errorMessageCause
+  def error(message: String, cause: Throwable): Unit = macro LoggerMacro.errorMessageCause
 
-  override def error(message: String, args: Any*): Unit = macro LoggerMacro.errorMessageArgs
+  def error(message: String, args: Any*): Unit = macro LoggerMacro.errorMessageArgs
 
-  override def error(marker: Marker, message: String): Unit = macro LoggerMacro.errorMessageMarker
+  def error(marker: Marker, message: String): Unit = macro LoggerMacro.errorMessageMarker
 
-  override def error(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.errorMessageCauseMarker
+  def error(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.errorMessageCauseMarker
 
-  override def error(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.errorMessageArgsMarker
+  def error(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.errorMessageArgsMarker
 
   def whenErrorEnabled(body: Unit): Unit = macro LoggerMacro.errorCode
 
   // Warn
 
-  override def warn(message: String): Unit = macro LoggerMacro.warnMessage
+  def warn(message: String): Unit = macro LoggerMacro.warnMessage
 
-  override def warn(message: String, cause: Throwable): Unit = macro LoggerMacro.warnMessageCause
+  def warn(message: String, cause: Throwable): Unit = macro LoggerMacro.warnMessageCause
 
-  override def warn(message: String, args: Any*): Unit = macro LoggerMacro.warnMessageArgs
+  def warn(message: String, args: Any*): Unit = macro LoggerMacro.warnMessageArgs
 
-  override def warn(marker: Marker, message: String): Unit = macro LoggerMacro.warnMessageMarker
+  def warn(marker: Marker, message: String): Unit = macro LoggerMacro.warnMessageMarker
 
-  override def warn(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.warnMessageCauseMarker
+  def warn(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.warnMessageCauseMarker
 
-  override def warn(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.warnMessageArgsMarker
+  def warn(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.warnMessageArgsMarker
 
   def whenWarnEnabled(body: Unit): Unit = macro LoggerMacro.warnCode
 
   // Info
 
-  override def info(message: String): Unit = macro LoggerMacro.infoMessage
+  def info(message: String): Unit = macro LoggerMacro.infoMessage
 
-  override def info(message: String, cause: Throwable): Unit = macro LoggerMacro.infoMessageCause
+  def info(message: String, cause: Throwable): Unit = macro LoggerMacro.infoMessageCause
 
-  override def info(message: String, args: Any*): Unit = macro LoggerMacro.infoMessageArgs
+  def info(message: String, args: Any*): Unit = macro LoggerMacro.infoMessageArgs
 
-  override def info(marker: Marker, message: String): Unit = macro LoggerMacro.infoMessageMarker
+  def info(marker: Marker, message: String): Unit = macro LoggerMacro.infoMessageMarker
 
-  override def info(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.infoMessageCauseMarker
+  def info(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.infoMessageCauseMarker
 
-  override def info(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.infoMessageArgsMarker
+  def info(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.infoMessageArgsMarker
 
   def whenInfoEnabled(body: Unit): Unit = macro LoggerMacro.infoCode
 
   // Debug
 
-  override def debug(message: String): Unit = macro LoggerMacro.debugMessage
+  def debug(message: String): Unit = macro LoggerMacro.debugMessage
 
-  override def debug(message: String, cause: Throwable): Unit = macro LoggerMacro.debugMessageCause
+  def debug(message: String, cause: Throwable): Unit = macro LoggerMacro.debugMessageCause
 
-  override def debug(message: String, args: Any*): Unit = macro LoggerMacro.debugMessageArgs
+  def debug(message: String, args: Any*): Unit = macro LoggerMacro.debugMessageArgs
 
-  override def debug(marker: Marker, message: String): Unit = macro LoggerMacro.debugMessageMarker
+  def debug(marker: Marker, message: String): Unit = macro LoggerMacro.debugMessageMarker
 
-  override def debug(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.debugMessageCauseMarker
+  def debug(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.debugMessageCauseMarker
 
-  override def debug(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.debugMessageArgsMarker
+  def debug(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.debugMessageArgsMarker
 
   def whenDebugEnabled(body: Unit): Unit = macro LoggerMacro.debugCode
 
   // Trace
 
-  override def trace(message: String): Unit = macro LoggerMacro.traceMessage
+  def trace(message: String): Unit = macro LoggerMacro.traceMessage
 
-  override def trace(message: String, cause: Throwable): Unit = macro LoggerMacro.traceMessageCause
+  def trace(message: String, cause: Throwable): Unit = macro LoggerMacro.traceMessageCause
 
-  override def trace(message: String, args: Any*): Unit = macro LoggerMacro.traceMessageArgs
+  def trace(message: String, args: Any*): Unit = macro LoggerMacro.traceMessageArgs
 
-  override def trace(marker: Marker, message: String): Unit = macro LoggerMacro.traceMessageMarker
+  def trace(marker: Marker, message: String): Unit = macro LoggerMacro.traceMessageMarker
 
-  override def trace(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.traceMessageCauseMarker
+  def trace(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.traceMessageCauseMarker
 
-  override def trace(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.traceMessageArgsMarker
+  def trace(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.traceMessageArgsMarker
 
   def whenTraceEnabled(body: Unit): Unit = macro LoggerMacro.traceCode
 

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

@@ -1,83 +1,83 @@
 package com.typesafe.scalalogging
 
-import org.slf4j.{Marker, Logger => Underlying}
+import org.slf4j.{ Marker, Logger => Underlying }
 
 import scala.language.experimental.macros
 
 /**
  * ALogger that takes some data A and uses it according to strategy CanLog[A] during every log operation.
  * Useful for logging things in a context, such as a request id, assuming it's available during construction time.
- * */
-class LoggerTakingConstructorArg[A] private[scalalogging](val underlying: Underlying, val canLogEv: CanLog[A], val a: A) extends ALogger with Serializable with LogsAdditionalData[A] {
+ */
+class LoggerTakingConstructorArg[A] private[scalalogging] (val underlying: Underlying, val canLogEv: CanLog[A], val a: A) extends Serializable with LogsAdditionalData[A] {
 
   // Error
 
-  override def error(message: String): Unit = macro LoggerTakingConstructorArgMacro.errorMessage[A]
+  def error(message: String): Unit = macro LoggerTakingConstructorArgMacro.errorMessage[A]
 
-  override def error(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.errorMessageCause[A]
+  def error(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.errorMessageCause[A]
 
-  override def error(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.errorMessageArgs[A]
+  def error(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.errorMessageArgs[A]
 
-  override def error(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.errorMessageMarker[A]
+  def error(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.errorMessageMarker[A]
 
-  override def error(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.errorMessageCauseMarker[A]
+  def error(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.errorMessageCauseMarker[A]
 
-  override def error(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.errorMessageArgsMarker[A]
+  def error(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.errorMessageArgsMarker[A]
 
   // Warn
 
-  override def warn(message: String): Unit = macro LoggerTakingConstructorArgMacro.warnMessage[A]
+  def warn(message: String): Unit = macro LoggerTakingConstructorArgMacro.warnMessage[A]
 
-  override def warn(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.warnMessageCause[A]
+  def warn(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.warnMessageCause[A]
 
-  override def warn(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.warnMessageArgs[A]
+  def warn(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.warnMessageArgs[A]
 
-  override def warn(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.warnMessageMarker[A]
+  def warn(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.warnMessageMarker[A]
 
-  override def warn(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.warnMessageCauseMarker[A]
+  def warn(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.warnMessageCauseMarker[A]
 
-  override def warn(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.warnMessageArgsMarker[A]
+  def warn(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.warnMessageArgsMarker[A]
 
   // Info
 
-  override def info(message: String): Unit = macro LoggerTakingConstructorArgMacro.infoMessage[A]
+  def info(message: String): Unit = macro LoggerTakingConstructorArgMacro.infoMessage[A]
 
-  override def info(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.infoMessageCause[A]
+  def info(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.infoMessageCause[A]
 
-  override def info(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.infoMessageArgs[A]
+  def info(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.infoMessageArgs[A]
 
-  override def info(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.infoMessageMarker[A]
+  def info(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.infoMessageMarker[A]
 
-  override def info(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.infoMessageCauseMarker[A]
+  def info(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.infoMessageCauseMarker[A]
 
-  override def info(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.infoMessageArgsMarker[A]
+  def info(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.infoMessageArgsMarker[A]
 
   // Debug
 
-  override def debug(message: String): Unit = macro LoggerTakingConstructorArgMacro.debugMessage[A]
+  def debug(message: String): Unit = macro LoggerTakingConstructorArgMacro.debugMessage[A]
 
-  override def debug(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.debugMessageCause[A]
+  def debug(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.debugMessageCause[A]
 
-  override def debug(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.debugMessageArgs[A]
+  def debug(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.debugMessageArgs[A]
 
-  override def debug(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.debugMessageMarker[A]
+  def debug(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.debugMessageMarker[A]
 
-  override def debug(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.debugMessageCauseMarker[A]
+  def debug(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.debugMessageCauseMarker[A]
 
-  override def debug(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.debugMessageArgsMarker[A]
+  def debug(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.debugMessageArgsMarker[A]
 
   // Trace
 
-  override def trace(message: String): Unit = macro LoggerTakingConstructorArgMacro.traceMessage[A]
+  def trace(message: String): Unit = macro LoggerTakingConstructorArgMacro.traceMessage[A]
 
-  override def trace(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.traceMessageCause[A]
+  def trace(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.traceMessageCause[A]
 
-  override def trace(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.traceMessageArgs[A]
+  def trace(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.traceMessageArgs[A]
 
-  override def trace(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.traceMessageMarker[A]
+  def trace(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.traceMessageMarker[A]
 
-  override def trace(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.traceMessageCauseMarker[A]
+  def trace(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.traceMessageCauseMarker[A]
 
-  override def trace(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.traceMessageArgsMarker[A]
+  def trace(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.traceMessageArgsMarker[A]
 
 }