SAM Type Interface

build.sbt

@@ -31,6 +31,7 @@ val catsEffectV = "3.6.3"
 val slf4jV = "1.7.36"
 val munitCatsEffectV = "2.1.0"
 val logbackClassicV = "1.2.13"
+val sourcecodeV = "0.4.2"
 
 Global / onChangedBuildSource := ReloadOnSourceChanges
 
@@ -47,7 +48,8 @@ lazy val core = crossProject(JSPlatform, JVMPlatform, NativePlatform)
     name := "log4cats-core",
     libraryDependencies ++= Seq(
       "org.typelevel" %%% "cats-core"       % catsV,
-      "org.typelevel" %%% "cats-effect-std" % catsEffectV
+      "org.typelevel" %%% "cats-effect-std" % catsEffectV,
+      "com.lihaoyi" %%% "sourcecode"        % sourcecodeV
     ),
     libraryDependencies ++= {
       if (tlIsScala3.value) Seq.empty

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

@@ -0,0 +1,57 @@
+/*
+ * 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
+
+import cats.effect.kernel.Sync
+
+/**
+ * A simple console implementation of LoggerKernel for testing the SAM design.
+ */
+class ConsoleLoggerKernel[F[_], Ctx](implicit F: Sync[F]) extends LoggerKernel[F, Ctx] {
+
+  def log(level: KernelLogLevel, record: Log.Builder[Ctx] => Log.Builder[Ctx]): F[Unit] = {
+    F.delay {
+      val logRecord = record(Log.mutableBuilder[Ctx]()).build()
+
+      val timestamp = logRecord.timestamp.map(_.toMillis).getOrElse(System.currentTimeMillis())
+      // Use simple timestamp formatting instead of java.time.Instant for Scala Native compatibility
+      val timeStr = s"${new java.util.Date(timestamp).toString}"
+
+      val levelStr = logRecord.level.namePadded
+      val message = logRecord.message
+      val className = logRecord.className.map(c => s"[$c]").getOrElse("")
+      val fileName =
+        logRecord.fileName.map(f => s"($f:${logRecord.line.getOrElse(0)})").getOrElse("")
+
+      val contextStr = if (logRecord.context.nonEmpty) {
+        val contextPairs = logRecord.context.map { case (k, v) => s"$k=$v" }.mkString(", ")
+        s" {$contextPairs}"
+      } else ""
+
+      val throwableStr = logRecord.throwable.map(t => s"\n${t.toString}").getOrElse("")
+
+      val logLine = s"$timeStr $levelStr $className$fileName$contextStr $message$throwableStr"
+
+      println(logLine)
+    }
+  }
+}
+
+object ConsoleLoggerKernel {
+  def apply[F[_], Ctx](implicit F: Sync[F]): ConsoleLoggerKernel[F, Ctx] =
+    new ConsoleLoggerKernel[F, Ctx]
+}

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

@@ -0,0 +1,57 @@
+/*
+ * 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
+
+import scala.concurrent.duration.FiniteDuration
+
+import org.typelevel.log4cats.Context.Encoder
+
+/**
+ * A value that can be written into a json-like construct, provided a visitor.
+ */
+trait Context[C] {
+  def capture[A](a: A)(implicit E: Encoder[A, C]): C
+}
+
+object Context {
+  trait Encoder[A, B] {
+    def encode(a: A): B
+  }
+
+  object Encoder {
+    def apply[A, B](implicit ev: Encoder[A, B]): ev.type = ev
+
+    // Identity encoder for when input and output types are the same
+    implicit def identityEncoder[A]: Encoder[A, A] = a => a
+
+    implicit val stringToStringEncoder: Encoder[String, String] = a => a
+
+    implicit val intToStringEncoder: Encoder[Int, String] = _.toString
+
+    implicit val longToStringEncoder: Encoder[Long, String] = _.toString
+
+    implicit val doubleToStringEncoder: Encoder[Double, String] = _.toString
+
+    implicit val booleanToStringEncoder: Encoder[Boolean, String] = if (_) "true" else "false"
+
+    // Removed Instant encoder for Scala Native compatibility
+    // implicit val instantToStringEncoder: Encoder[Instant, String] =
+    //   DateTimeFormatter.ISO_INSTANT.format(_)
+
+    implicit val finiteDurationToStringEncoder: Encoder[FiniteDuration, String] = _.toString
+  }
+}

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

@@ -0,0 +1,65 @@
+/*
+ * 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
+
+import cats.Order
+
+final case class KernelLogLevel(name: String, value: Int) {
+  def namePadded: String = KernelLogLevel.padded(this)
+
+  KernelLogLevel.add(this)
+}
+
+object KernelLogLevel {
+  private var maxLength = 0
+
+  private var map = Map.empty[String, KernelLogLevel]
+  private var padded = Map.empty[KernelLogLevel, String]
+
+  implicit final val orderKernelLogLevel: Order[KernelLogLevel] =
+    Order.by[KernelLogLevel, Int](-_.value)
+
+  // For Java/legacy interop, if needed (not implicit)
+  val LevelOrdering: Ordering[KernelLogLevel] =
+    Ordering.by[KernelLogLevel, Int](_.value).reverse
+
+  val Trace: KernelLogLevel = KernelLogLevel("TRACE", 100)
+  val Debug: KernelLogLevel = KernelLogLevel("DEBUG", 200)
+  val Info: KernelLogLevel = KernelLogLevel("INFO", 300)
+  val Warn: KernelLogLevel = KernelLogLevel("WARN", 400)
+  val Error: KernelLogLevel = KernelLogLevel("ERROR", 500)
+  val Fatal: KernelLogLevel = KernelLogLevel("FATAL", 600)
+
+  def add(level: KernelLogLevel): Unit = synchronized {
+    val length = level.name.length
+    map += level.name.toLowerCase -> level
+    if (length > maxLength) {
+      maxLength = length
+      padded = map.map { case (_, level) =>
+        level -> level.name.padTo(maxLength, ' ').mkString
+      }
+    } else {
+      padded += level -> level.name.padTo(maxLength, ' ').mkString
+    }
+  }
+
+  def get(name: String): Option[KernelLogLevel] = map.get(name.toLowerCase)
+
+  def apply(name: String): KernelLogLevel = get(name).getOrElse(
+    throw new RuntimeException(s"Level not found by name: $name")
+  )
+}

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

@@ -0,0 +1,192 @@
+/*
+ * 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
+
+import scala.collection.mutable
+import scala.concurrent.duration.FiniteDuration
+
+/**
+ * Low-level interface exposing methods to enrich a log record with relevant information. The
+ * methods are designed to capture elements that cannot be easily captured from a monadic context
+ * (or by running an effect). Elements such as timestamps should be provided by means of
+ * middlewares.
+ */
+trait Log[Ctx] {
+  def timestamp: Option[FiniteDuration]
+  def level: KernelLogLevel
+  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 levelValue: Int
+}
+
+object Log {
+  trait Builder[Ctx] {
+    def withTimestamp(value: FiniteDuration): Builder[Ctx]
+    def withLevel(level: KernelLogLevel): Builder[Ctx]
+    def withMessage(message: => String): Builder[Ctx]
+    def withThrowable(throwable: Throwable): Builder[Ctx]
+    def withContext[A](name: String)(ctx: A)(implicit E: Context.Encoder[A, Ctx]): Builder[Ctx]
+    def withFileName(name: String): Builder[Ctx]
+    def withClassName(name: String): Builder[Ctx]
+    def withMethodName(name: String): Builder[Ctx]
+    def withLine(line: Int): Builder[Ctx]
+
+    final def withContextMap[A](
+        contextMap: Map[String, A]
+    )(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: KernelLogLevel = KernelLogLevel.Info
+    private var _message: () => String = () => ""
+    private var _throwable: Option[Throwable] = None
+    private var _context: mutable.Builder[(String, Ctx), Map[String, Ctx]] =
+      Map.newBuilder[String, Ctx]
+    private var _fileName: Option[String] = None
+    private var _className: Option[String] = None
+    private var _methodName: Option[String] = None
+    private var _line: Option[Int] = None
+
+    def build(): Log[Ctx] = new Log[Ctx] {
+      override def timestamp: Option[FiniteDuration] = _timestamp
+      override def level: KernelLogLevel = _level
+      override def message: () => String = _message
+      override def throwable: Option[Throwable] = _throwable
+      override def context: Map[String, Ctx] = _context.result()
+      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 levelValue: Int = _level.value
+    }
+
+    override def withTimestamp(value: FiniteDuration): this.type = {
+      _timestamp = Some(value)
+      this
+    }
+
+    override def withLevel(level: KernelLogLevel): this.type = {
+      _level = level
+      this
+    }
+
+    override def withMessage(message: => String): this.type = {
+      _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 currentContext = _context.result()
+      _context = Map.newBuilder[String, Ctx]
+      f(currentContext).foreach { case (k, v) => _context += (k -> v) }
+      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
+    }
+
+    override def withThrowable(throwable: Throwable): this.type = {
+      _throwable = Some(throwable)
+      this
+    }
+
+    override def withContext[A](
+        name: String
+    )(ctx: A)(implicit E: Context.Encoder[A, Ctx]): this.type = {
+      _context += (name -> E.encode(ctx))
+      this
+    }
+
+    override def withFileName(name: String): this.type = {
+      _fileName = Some(name)
+      this
+    }
+
+    override def withClassName(name: String): this.type = {
+      _className = Some(name)
+      this
+    }
+
+    override def withMethodName(name: String): this.type = {
+      _methodName = Some(name)
+      this
+    }
+
+    override def withLine(line: Int): this.type = {
+      _line = if (line > 0) Some(line) else None
+      this
+    }
+  }
+}