SAM Type Interface

build.sbt

@@ -4,7 +4,7 @@ val Scala213 = "2.13.18"
 val Scala212 = "2.12.21"
 val Scala3 = "3.3.7"
 
-ThisBuild / tlBaseVersion := "2.7"
+ThisBuild / tlBaseVersion := "2.8"
 ThisBuild / crossScalaVersions := Seq(Scala213, Scala212, Scala3)
 ThisBuild / scalaVersion := Scala213
 ThisBuild / startYear := Some(2018)
@@ -52,7 +52,21 @@ lazy val core = crossProject(JSPlatform, JVMPlatform, NativePlatform)
     libraryDependencies ++= {
       if (tlIsScala3.value) Seq.empty
       else Seq("org.scala-lang" % "scala-reflect" % scalaVersion.value % Provided)
-    }
+    },
+    mimaBinaryIssueFilters ++= Seq(
+      // New protected abstract method in 2.8 - expected for minor version bump
+      // This allows implementations to access the underlying kernel for advanced use cases
+      ProblemFilters.exclude[ReversedMissingMethodProblem]("org.typelevel.log4cats.Logger.kernel"),
+      ProblemFilters.exclude[ReversedMissingMethodProblem](
+        "org.typelevel.log4cats.extras.DeferredLogger.kernel"
+      ),
+      ProblemFilters.exclude[ReversedMissingMethodProblem](
+        "org.typelevel.log4cats.extras.DeferredSelfAwareStructuredLogger.kernel"
+      ),
+      ProblemFilters.exclude[ReversedMissingMethodProblem](
+        "org.typelevel.log4cats.extras.DeferredStructuredLogger.kernel"
+      )
+    )
   )
   .nativeSettings(commonNativeSettings)
 

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

@@ -0,0 +1,56 @@
+/*
+ * 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.getOrElse(java.time.Instant.now())
+      val timeStr = 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,48 @@
+/*
+ * 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, Show}
+import cats.kernel.{Eq, Hash}
+
+sealed abstract class KernelLogLevel(val name: String, val value: Int) {
+  def namePadded: String = name.padTo(5, ' ').mkString
+
+  override def toString: String = name
+}
+
+object KernelLogLevel {
+  implicit final val log4catsCatsInstances: Eq[KernelLogLevel] & Hash[KernelLogLevel] & Order[
+    KernelLogLevel
+  ] & Show[KernelLogLevel] =
+    new Hash[KernelLogLevel] with Order[KernelLogLevel] with Show[KernelLogLevel] {
+      override def eqv(x: KernelLogLevel, y: KernelLogLevel): Boolean = x == y
+
+      override def hash(x: KernelLogLevel): Int = x.##
+
+      override def compare(x: KernelLogLevel, y: KernelLogLevel): Int = x.value.compare(y.value)
+
+      override def show(t: KernelLogLevel): String = t.name
+    }
+
+  case object Trace extends KernelLogLevel("TRACE", 100)
+  case object Debug extends KernelLogLevel("DEBUG", 200)
+  case object Info extends KernelLogLevel("INFO", 300)
+  case object Warn extends KernelLogLevel("WARN", 400)
+  case object Error extends KernelLogLevel("ERROR", 500)
+  case object Fatal extends KernelLogLevel("FATAL", 600)
+}