update with the suggested changes

Author: Jay-Lokhande

core/shared/src/main/scala/org/typelevel/log4cats/Log.scala

@@ -28,16 +28,14 @@ import scala.concurrent.duration.FiniteDuration
 trait Log[Ctx] {
   def timestamp: Option[FiniteDuration]
   def level: KernelLogLevel
-  def message: String
+  def message: () => String
   def throwable: Option[Throwable]
   def context: Map[String, Ctx]
   def fileName: Option[String]
   def className: Option[String]
   def methodName: Option[String]
   def line: Option[Int]
-
-  def unsafeThrowable: Throwable
-  def unsafeContext: Map[String, Ctx]
+  def levelValue: Int
 }
 
 object Log {
@@ -57,15 +55,25 @@ object Log {
     )(implicit E: Context.Encoder[A, Ctx]): Builder[Ctx] =
       contextMap.foldLeft(this) { case (builder, (k, v)) => builder.withContext(k)(v) }
 
+    def adaptTimestamp(f: FiniteDuration => FiniteDuration): Builder[Ctx]
+    def adaptLevel(f: KernelLogLevel => KernelLogLevel): Builder[Ctx]
+    def adaptMessage(f: String => String): Builder[Ctx]
+    def adaptThrowable(f: Throwable => Throwable): Builder[Ctx]
+    def adaptContext(f: Map[String, Ctx] => Map[String, Ctx]): Builder[Ctx]
+    def adaptFileName(f: String => String): Builder[Ctx]
+    def adaptClassName(f: String => String): Builder[Ctx]
+    def adaptMethodName(f: String => String): Builder[Ctx]
+    def adaptLine(f: Int => Int): Builder[Ctx]
+
     def build(): Log[Ctx]
   }
 
   def mutableBuilder[Ctx](): Builder[Ctx] = new MutableBuilder[Ctx]()
 
   private class MutableBuilder[Ctx] extends Builder[Ctx] {
     private var _timestamp: Option[FiniteDuration] = None
-    private var _level: Option[KernelLogLevel] = None
-    private var _message: Option[String] = None
+    private var _level: KernelLogLevel = KernelLogLevel.Info
+    private var _message: () => String = () => ""
     private var _throwable: Option[Throwable] = None
     private val _context: mutable.Map[String, Ctx] = mutable.Map.empty[String, Ctx]
     private var _fileName: Option[String] = None
@@ -75,16 +83,15 @@ object Log {
 
     def build(): Log[Ctx] = new Log[Ctx] {
       override def timestamp: Option[FiniteDuration] = _timestamp
-      override def level: KernelLogLevel = _level.getOrElse(KernelLogLevel.Info)
-      override def message: String = _message.getOrElse("")
+      override def level: KernelLogLevel = _level
+      override def message: () => String = _message
       override def throwable: Option[Throwable] = _throwable
       override def context: Map[String, Ctx] = _context.toMap
       override def className: Option[String] = _className
       override def fileName: Option[String] = _fileName
       override def methodName: Option[String] = _methodName
       override def line: Option[Int] = _line.filter(_ > 0)
-      override def unsafeThrowable: Throwable = _throwable.get
-      override def unsafeContext: Map[String, Ctx] = _context.toMap
+      override def levelValue: Int = _level.value
     }
 
     override def withTimestamp(value: FiniteDuration): this.type = {
@@ -93,12 +100,60 @@ object Log {
     }
 
     override def withLevel(level: KernelLogLevel): this.type = {
-      _level = Some(level)
+      _level = level
       this
     }
 
     override def withMessage(message: => String): this.type = {
-      _message = Some(message)
+      _message = () => message
+      this
+    }
+
+    override def adaptMessage(f: String => String): this.type = {
+      _message = () => f(_message())
+      this
+    }
+
+    override def adaptTimestamp(f: FiniteDuration => FiniteDuration): this.type = {
+      _timestamp = _timestamp.map(f)
+      this
+    }
+
+    override def adaptLevel(f: KernelLogLevel => KernelLogLevel): this.type = {
+      _level = f(_level)
+      this
+    }
+
+    override def adaptThrowable(f: Throwable => Throwable): this.type = {
+      _throwable = _throwable.map(f)
+      this
+    }
+
+    override def adaptContext(f: Map[String, Ctx] => Map[String, Ctx]): this.type = {
+      val newContext = Map.newBuilder[String, Ctx]
+      newContext.addAll(f(_context.toMap))
+      _context.clear()
+      _context.addAll(newContext.result())
+      this
+    }
+
+    override def adaptFileName(f: String => String): this.type = {
+      _fileName = _fileName.map(f)
+      this
+    }
+
+    override def adaptClassName(f: String => String): this.type = {
+      _className = _className.map(f)
+      this
+    }
+
+    override def adaptMethodName(f: String => String): this.type = {
+      _methodName = _methodName.map(f)
+      this
+    }
+
+    override def adaptLine(f: Int => Int): this.type = {
+      _line = _line.map(f)
       this
     }
 

core/shared/src/main/scala/org/typelevel/log4cats/Recordable.scala

@@ -27,12 +27,10 @@ trait Recordable[Ctx, A] {
 object Recordable {
   def apply[Ctx, A](implicit ev: Recordable[Ctx, A]): ev.type = ev
 
-  // Basic string message recording
   implicit def stringLoggable[Ctx]: Recordable[Ctx, String] = new Recordable[Ctx, String] {
     def record(value: => String) = _.withMessage(value)
   }
 
-  // Context key-value pair recording with proper encoding
   implicit def contextPairLoggable[Ctx, A](implicit
       encoder: Context.Encoder[A, Ctx]
   ): Recordable[Ctx, (String, A)] =
@@ -43,13 +41,11 @@ object Recordable {
       }
     }
 
-  // Throwable recording
   implicit def throwableLoggable[Ctx, T <: Throwable]: Recordable[Ctx, T] =
     new Recordable[Ctx, T] {
       def record(value: => T): LogRecord[Ctx] = _.withThrowable(value)
     }
 
-  // Numeric value recording with automatic string conversion
   implicit def intLoggable[Ctx](implicit
       encoder: Context.Encoder[Int, Ctx]
   ): Recordable[Ctx, Int] =
@@ -90,18 +86,13 @@ object Recordable {
       }
     }
 
-  // Map recording for structured data
   implicit def mapLoggable[Ctx, A](implicit
       encoder: Context.Encoder[A, Ctx]
   ): Recordable[Ctx, Map[String, A]] =
     new Recordable[Ctx, Map[String, A]] {
       def record(value: => Map[String, A]): LogRecord[Ctx] = {
         val map = value
-        (builder: Log.Builder[Ctx]) => {
-          var current = builder
-          map.foreach { case (k, v) => current = current.withContext(k)(v) }
-          current
-        }
+        (builder: Log.Builder[Ctx]) => builder.withContextMap(map)
       }
     }
 }

core/shared/src/main/scala/org/typelevel/log4cats/SamLogger.scala

@@ -121,7 +121,7 @@ object SamLogger {
       def log(level: KernelLogLevel, record: Builder => Builder): F[Unit] = {
         val modifiedRecord = (builder: Builder) => {
           val originalLog = record(builder).build()
-          val modifiedMessage = f(originalLog.message)
+          val modifiedMessage = f(originalLog.message())
 
           val newBuilder = Log
             .mutableBuilder[Ctx]()

core/shared/src/main/scala/org/typelevel/log4cats/SamLoggerAdapter.scala

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2018 Typelevel
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.typelevel.log4cats
+
+/**
+ * Adapter layer to bridge the new SAM LoggerKernel with the existing Logger interface. This allows
+ * gradual migration from the old multi-method design to the new SAM design.
+ *
+ * ## Usage
+ *
+ * ### Converting SAM LoggerKernel to old Logger interface
+ * ```scala
+ * val kernel = Slf4jLoggerKernel.fromName[IO]("MyApp")
+ * val oldLogger = SamLoggerAdapter.toLogger(kernel)
+ *
+ * // Use old API
+ * oldLogger.info("Works with old API")
+ * oldLogger.error(exception)("Works with old API")
+ * ```
+ *
+ * ### Converting old Logger to SAM LoggerKernel
+ * ```scala
+ * val oldLogger = Slf4jLogger.getLogger[IO]
+ * val samLogger = SamLoggerAdapter.loggerToSamLogger(oldLogger)
+ *
+ * // Use new SAM API
+ * samLogger.info("Works with new API", ("key", "value"))
+ * ```
+ *
+ * ## Limitations
+ *
+ *   - **Context Loss**: When converting from LoggerKernel → Logger → LoggerKernel, structured
+ *     context information (key-value pairs) is lost because the old Logger interface doesn't
+ *     support structured logging. Only message and throwable information is preserved.
+ *   - **Performance**: The `toLoggerKernel` method creates a full log record to extract message and
+ *     throwable, which has some overhead.
+ *
+ * ## Best Practices
+ *
+ *   - Use `toLogger` for backward compatibility when migrating to new backends
+ *   - Use `loggerToSamLogger` when you need structured logging capabilities
+ *   - Avoid round-trip conversions (LoggerKernel → Logger → LoggerKernel) as they lose context
+ */
+object SamLoggerAdapter {
+
+  /**
+   * Convert a LoggerKernel to the existing Logger interface.
+   *
+   * This is the primary use case for the adapter - allowing new SAM-based backends to work with
+   * existing code that uses the old Logger interface.
+   *
+   * **Note**: Structured context information is not accessible through the old Logger interface, so
+   * any context added via the SAM API will not be visible when using the returned Logger.
+   */
+  def toLogger[F[_], Ctx](kernel: LoggerKernel[F, Ctx]): Logger[F] = new Logger[F] {
+    def error(message: => String): F[Unit] =
+      kernel.log(KernelLogLevel.Error, _.withMessage(message))
+
+    def error(t: Throwable)(message: => String): F[Unit] =
+      kernel.log(KernelLogLevel.Error, _.withMessage(message).withThrowable(t))
+
+    def warn(message: => String): F[Unit] =
+      kernel.log(KernelLogLevel.Warn, _.withMessage(message))
+
+    def warn(t: Throwable)(message: => String): F[Unit] =
+      kernel.log(KernelLogLevel.Warn, _.withMessage(message).withThrowable(t))
+
+    def info(message: => String): F[Unit] =
+      kernel.log(KernelLogLevel.Info, _.withMessage(message))
+
+    def info(t: Throwable)(message: => String): F[Unit] =
+      kernel.log(KernelLogLevel.Info, _.withMessage(message).withThrowable(t))
+
+    def debug(message: => String): F[Unit] =
+      kernel.log(KernelLogLevel.Debug, _.withMessage(message))
+
+    def debug(t: Throwable)(message: => String): F[Unit] =
+      kernel.log(KernelLogLevel.Debug, _.withMessage(message).withThrowable(t))
+
+    def trace(message: => String): F[Unit] =
+      kernel.log(KernelLogLevel.Trace, _.withMessage(message))
+
+    def trace(t: Throwable)(message: => String): F[Unit] =
+      kernel.log(KernelLogLevel.Trace, _.withMessage(message).withThrowable(t))
+  }
+
+  /**
+   * Convert the existing Logger interface to a LoggerKernel.
+   *
+   * **Important**: This conversion has limitations:
+   *   - Only message and throwable information is preserved
+   *   - All structured context (key-value pairs) is lost because the old Logger interface doesn't
+   *     support structured logging
+   *   - This method is primarily intended for testing and round-trip compatibility
+   *
+   * For production use, prefer using the SAM LoggerKernel directly or use `toLogger` to convert
+   * from LoggerKernel to Logger.
+   */
+  def toLoggerKernel[F[_], Ctx](logger: Logger[F]): LoggerKernel[F, Ctx] =
+    new LoggerKernel[F, Ctx] {
+      def log(level: KernelLogLevel, record: Log.Builder[Ctx] => Log.Builder[Ctx]): F[Unit] = {
+        // Build the log record to extract message and throwable
+        // Note: Context information is intentionally not preserved as the old Logger
+        // interface doesn't support structured logging
+        val logRecord = record(Log.mutableBuilder[Ctx]()).build()
+        val message = logRecord.message()
+        val throwable = logRecord.throwable
+
+        // Route to appropriate logger method based on level and throwable presence
+        (level, throwable) match {
+          case (KernelLogLevel.Error, Some(t)) => logger.error(t)(message)
+          case (KernelLogLevel.Error, None) => logger.error(message)
+          case (KernelLogLevel.Warn, Some(t)) => logger.warn(t)(message)
+          case (KernelLogLevel.Warn, None) => logger.warn(message)
+          case (KernelLogLevel.Info, Some(t)) => logger.info(t)(message)
+          case (KernelLogLevel.Info, None) => logger.info(message)
+          case (KernelLogLevel.Debug, Some(t)) => logger.debug(t)(message)
+          case (KernelLogLevel.Debug, None) => logger.debug(message)
+          case (KernelLogLevel.Trace, Some(t)) => logger.trace(t)(message)
+          case (KernelLogLevel.Trace, None) => logger.trace(message)
+          case _ => logger.info(message) // fallback for unknown levels
+        }
+      }
+    }
+
+  /**
+   * Convert a SamLogger to the existing Logger interface.
+   *
+   * This is a convenience method that delegates to `toLogger`.
+   */
+  def samLoggerToLogger[F[_], Ctx](samLogger: SamLogger[F, Ctx]): Logger[F] = toLogger(samLogger)
+
+  /**
+   * Convert the existing Logger interface to a SamLogger.
+   *
+   * This allows old Logger implementations to be used with the new SAM API, enabling structured
+   * logging capabilities.
+   *
+   * **Note**: The underlying Logger implementation must support the old interface. Any structured
+   * context added via the SAM API will be lost when the underlying Logger processes the log (since
+   * it only receives message and throwable).
+   */
+  def loggerToSamLogger[F[_], Ctx](logger: Logger[F]): SamLogger[F, Ctx] =
+    SamLogger.wrap(toLoggerKernel(logger))
+}