Context bound logger

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

@@ -0,0 +1,85 @@
+package com.typesafe.scalalogging
+
+import org.slf4j.Marker
+
+/**
+ *
+ * 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", 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, cause: Throwable): Unit
+
+  def error(message: String, args: Any*): Unit
+
+  def error(marker: Marker, message: String): Unit
+
+  def error(marker: Marker, message: String, cause: Throwable): Unit
+
+  def error(marker: Marker, message: String, args: Any*): Unit
+
+  // Warn
+
+  def warn(message: String): Unit
+
+  def warn(message: String, cause: Throwable): Unit
+
+  def warn(message: String, args: Any*): Unit
+
+  def warn(marker: Marker, message: String): Unit
+
+  def warn(marker: Marker, message: String, cause: Throwable): Unit
+
+  def warn(marker: Marker, message: String, args: Any*): Unit
+
+  // Info
+
+  def info(message: String): Unit
+
+  def info(message: String, cause: Throwable): Unit
+
+  def info(message: String, args: Any*): Unit
+
+  def info(marker: Marker, message: String): Unit
+
+  def info(marker: Marker, message: String, cause: Throwable): Unit
+
+  def info(marker: Marker, message: String, args: Any*): Unit
+
+  // Debug
+
+  def debug(message: String): Unit
+
+  def debug(message: String, cause: Throwable): Unit
+
+  def debug(message: String, args: Any*): Unit
+
+  def debug(marker: Marker, message: String): Unit
+
+  def debug(marker: Marker, message: String, cause: Throwable): Unit
+
+  def debug(marker: Marker, message: String, args: Any*): Unit
+
+  // Trace
+
+  def trace(message: String): Unit
+
+  def trace(message: String, cause: Throwable): Unit
+
+  def trace(message: String, args: Any*): Unit
+
+  def trace(marker: Marker, message: String): Unit
+
+  def trace(marker: Marker, message: String, cause: Throwable): Unit
+
+  def trace(marker: Marker, message: String, args: Any*): Unit
+
+}
+

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

@@ -37,6 +37,12 @@ object Logger {
   def takingImplicit[A](underlying: Underlying)(implicit ev: CanLog[A]): LoggerTakingImplicit[A] =
     new LoggerTakingImplicit[A](underlying)
 
+  /**
+   * Create a [[LoggerTakingConstructorArg]] wrapping the given underlying `org.slf4j.Logger`.
+   */
+  def inContextOf[A](underlying: Underlying)(implicit ev: CanLog[A], a: A): LoggerTakingConstructorArg[A] =
+    new LoggerTakingConstructorArg[A](underlying, ev, a)
+
   /**
    * Create a [[Logger]] for the given name.
    * Example:
@@ -57,6 +63,16 @@ 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:
+   * {{{
+   *   val logger = Logger.inContextOf[CorrelationId]("application")
+   * }}}
+   */
+  def inContextOf[A](name: String)(implicit ev: CanLog[A], a: A): LoggerTakingConstructorArg[A] =
+    new LoggerTakingConstructorArg[A](LoggerFactory.getLogger(name), ev, a)
+
   /**
    * Create a [[Logger]] wrapping the created underlying `org.slf4j.Logger`.
    */
@@ -69,6 +85,12 @@ object Logger {
   def takingImplicit[A](clazz: Class[_])(implicit ev: CanLog[A]): LoggerTakingImplicit[A] =
     new LoggerTakingImplicit[A](LoggerFactory.getLogger(clazz.getName))
 
+  /**
+   * Create a [[LoggerTakingConstructorArg]] named after the given class parameter.
+   */
+  def inContextOf[A](clazz: Class[_])(implicit ev: CanLog[A], a: A): LoggerTakingConstructorArg[A] =
+    new LoggerTakingConstructorArg[A](LoggerFactory.getLogger(clazz.getName), ev, a)
+
   /**
    * Create a [[Logger]] for the runtime class wrapped by the implicit class
    * tag parameter.
@@ -90,6 +112,17 @@ object Logger {
    */
   def takingImplicit[T, A](implicit ct: ClassTag[T], ev: CanLog[A]): LoggerTakingImplicit[A] =
     new LoggerTakingImplicit[A](LoggerFactory.getLogger(ct.runtimeClass.getName.stripSuffix("$")))
+
+  /**
+   * Create a [[LoggerTakingConstructorArg]] for the runtime class wrapped by the implicit class
+   * tag parameter.
+   * Example:
+   * {{{
+   *   val logger = Logger.inContextOf[MyClass, CorrelationId]
+   * }}}
+   */
+  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)
 }
 
 /**

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

@@ -0,0 +1,83 @@
+package com.typesafe.scalalogging
+
+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 Serializable with LogsAdditionalData[A] {
+
+  // Error
+
+  def error(message: String): Unit = macro LoggerTakingConstructorArgMacro.errorMessage[A]
+
+  def error(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.errorMessageCause[A]
+
+  def error(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.errorMessageArgs[A]
+
+  def error(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.errorMessageMarker[A]
+
+  def error(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.errorMessageCauseMarker[A]
+
+  def error(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.errorMessageArgsMarker[A]
+
+  // Warn
+
+  def warn(message: String): Unit = macro LoggerTakingConstructorArgMacro.warnMessage[A]
+
+  def warn(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.warnMessageCause[A]
+
+  def warn(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.warnMessageArgs[A]
+
+  def warn(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.warnMessageMarker[A]
+
+  def warn(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.warnMessageCauseMarker[A]
+
+  def warn(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.warnMessageArgsMarker[A]
+
+  // Info
+
+  def info(message: String): Unit = macro LoggerTakingConstructorArgMacro.infoMessage[A]
+
+  def info(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.infoMessageCause[A]
+
+  def info(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.infoMessageArgs[A]
+
+  def info(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.infoMessageMarker[A]
+
+  def info(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.infoMessageCauseMarker[A]
+
+  def info(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.infoMessageArgsMarker[A]
+
+  // Debug
+
+  def debug(message: String): Unit = macro LoggerTakingConstructorArgMacro.debugMessage[A]
+
+  def debug(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.debugMessageCause[A]
+
+  def debug(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.debugMessageArgs[A]
+
+  def debug(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.debugMessageMarker[A]
+
+  def debug(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.debugMessageCauseMarker[A]
+
+  def debug(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.debugMessageArgsMarker[A]
+
+  // Trace
+
+  def trace(message: String): Unit = macro LoggerTakingConstructorArgMacro.traceMessage[A]
+
+  def trace(message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.traceMessageCause[A]
+
+  def trace(message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.traceMessageArgs[A]
+
+  def trace(marker: Marker, message: String): Unit = macro LoggerTakingConstructorArgMacro.traceMessageMarker[A]
+
+  def trace(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerTakingConstructorArgMacro.traceMessageCauseMarker[A]
+
+  def trace(marker: Marker, message: String, args: Any*): Unit = macro LoggerTakingConstructorArgMacro.traceMessageArgsMarker[A]
+
+}