Maintenance: Add internal Logging capabilities using zhttp.log

.github/workflows/ci.yml

@@ -74,7 +74,7 @@ jobs:
         run: sbt ++2.13.8 doc
 
       - name: Compress target directories
-        run: tar cf targets.tar target zio-http-test/target zio-http/target zio-http-benchmarks/target example/target project/target
+        run: tar cf targets.tar target zio-http-test/target zio-http/target zio-http-benchmarks/target zio-http-logging/target example/target project/target
 
       - name: Upload target directories
         uses: actions/upload-artifact@v2

build.sbt

@@ -1,8 +1,12 @@
 import BuildHelper._
 import Dependencies._
+import sbt.librarymanagement.ScalaArtifacts.isScala3
 
 val releaseDrafterVersion = "5"
 
+// Setting default log level to INFO
+val _ = sys.props += ("ZHttpLogLevel" -> "INFO")
+
 // CI Configuration
 ThisBuild / githubWorkflowJavaVersions   := Seq(JavaSpec.graalvm("21.1.0", "11"), JavaSpec.temurin("8"))
 ThisBuild / githubWorkflowPREventTypes   := Seq(
@@ -86,6 +90,7 @@ lazy val root = (project in file("."))
     zhttp,
     zhttpBenchmarks,
     zhttpTest,
+    zhttpLogging,
     example,
   )
 
@@ -104,6 +109,7 @@ lazy val zhttp = (project in file("zio-http"))
       `scala-compact-collection`,
     ),
   )
+  .dependsOn(zhttpLogging)
 
 lazy val zhttpBenchmarks = (project in file("zio-http-benchmarks"))
   .enablePlugins(JmhPlugin)
@@ -117,9 +123,23 @@ lazy val zhttpTest = (project in file("zio-http-test"))
   .settings(stdSettings("zhttp-test"))
   .settings(publishSetting(true))
 
+lazy val zhttpLogging = (project in file("zio-http-logging"))
+  .settings(stdSettings("zhttp-logging"))
+  .settings(publishSetting(false))
+  .settings(
+    libraryDependencies ++= {
+      if (isScala3(scalaVersion.value)) Seq.empty
+      else Seq(reflect.value % Provided)
+    },
+  )
+  .settings(
+    testFrameworks += new TestFramework("zio.test.sbt.ZTestFramework"),
+    libraryDependencies ++= Seq(`zio-test`, `zio-test-sbt`),
+  )
+
 lazy val example = (project in file("./example"))
   .settings(stdSettings("example"))
   .settings(publishSetting(false))
-  .settings(runSettings("example.Main"))
+  .settings(runSettings("example.HelloWorld"))
   .settings(libraryDependencies ++= Seq(`jwt-core`))
   .dependsOn(zhttp)

example/src/main/scala/example/PlainTextBenchmarkServer.scala

@@ -1,7 +1,7 @@
 package example
 
 import io.netty.util.AsciiString
-import zhttp.http.{Http, _}
+import zhttp.http._
 import zhttp.service.server.ServerChannelFactory
 import zhttp.service.{EventLoopGroup, Server}
 import zio.{App, ExitCode, UIO, URIO}

project/BuildHelper.scala

@@ -24,40 +24,11 @@ object BuildHelper extends ScalaSettings {
     }
   }
 
-  private val std2xOptions = Seq(
-    "-language:higherKinds",
-    "-language:existentials",
-    "-explaintypes",
-    "-Yrangepos",
-    "-Xlint:_,-missing-interpolator,-type-parameter-shadow",
-    "-Ywarn-numeric-widen",
-    "-Ywarn-macros:after",
-  )
-
-  private def optimizerOptions(optimize: Boolean) =
-    if (optimize)
-      Seq(
-        "-opt:l:inline",
-      )
-    else Nil
-
-  def extraOptions(scalaVersion: String, optimize: Boolean) =
+  def extraOptions(scalaVersion: String) =
     CrossVersion.partialVersion(scalaVersion) match {
-      case Some((3, 0))  =>
-        Seq(
-          "-language:implicitConversions",
-          "-Xignore-scala2-macros",
-          "-noindent",
-        )
-      case Some((2, 12)) =>
-        Seq("-Ywarn-unused:params,-implicits") ++ std2xOptions
-      case Some((2, 13)) =>
-        Seq(
-          "-Ywarn-unused:params,-implicits",
-          "-Ywarn-macros:after",
-          "-Ywarn-value-discard",
-        ) ++ std2xOptions ++ tpoleCatSettings ++
-          optimizerOptions(optimize)
+      case Some((3, 0))  => scala3Settings
+      case Some((2, 12)) => scala212Settings
+      case Some((2, 13)) => scala213Settings
       case _             => Seq.empty
     }
 
@@ -78,11 +49,11 @@ object BuildHelper extends ScalaSettings {
   }
 
   def stdSettings(prjName: String) = Seq(
-    name                           := s"$prjName",
-    ThisBuild / crossScalaVersions := Seq(Scala212, Scala213, ScalaDotty),
-    ThisBuild / scalaVersion       := Scala213,
-    scalacOptions                  := stdOptions ++ extraOptions(scalaVersion.value, optimize = !isSnapshot.value),
-    semanticdbVersion              := scalafixSemanticdb.revision, // use Scalafix compatible version
+    name                                   := s"$prjName",
+    ThisBuild / crossScalaVersions         := Seq(Scala212, Scala213, ScalaDotty),
+    ThisBuild / scalaVersion               := Scala213,
+    scalacOptions                          := stdOptions ++ extraOptions(scalaVersion.value),
+    semanticdbVersion                      := scalafixSemanticdb.revision, // use Scalafix compatible version
     ThisBuild / scalafixScalaBinaryVersion := CrossVersion.binaryScalaVersion(scalaVersion.value),
     ThisBuild / scalafixDependencies ++=
       List(
@@ -92,7 +63,7 @@ object BuildHelper extends ScalaSettings {
     Test / parallelExecution               := true,
     incOptions ~= (_.withLogRecompileOnMacro(false)),
     autoAPIMappings                        := true,
-    ThisBuild / javaOptions                := Seq("-Dio.netty.leakDetectionLevel=paranoid"),
+    ThisBuild / javaOptions                := Seq("-Dio.netty.leakDetectionLevel=paranoid", "-DZHttpLogLevel=INFO"),
     ThisBuild / fork                       := true,
   )
 

project/Dependencies.scala

@@ -1,3 +1,4 @@
+import sbt.Keys.scalaVersion
 import sbt._
 
 object Dependencies {
@@ -27,4 +28,6 @@ object Dependencies {
   val `zio-streams`  = "dev.zio" %% "zio-streams"  % ZioVersion
   val `zio-test`     = "dev.zio" %% "zio-test"     % ZioVersion % "test"
   val `zio-test-sbt` = "dev.zio" %% "zio-test-sbt" % ZioVersion % "test"
+
+  val reflect = Def.map(scalaVersion)("org.scala-lang" % "scala-reflect" % _)
 }

project/ScalaSettings.scala

@@ -1,6 +1,5 @@
 trait ScalaSettings {
-  // RECOMMENDED SETTINGS: https://tpolecat.github.io/2017/04/25/scalac-flags.html
-  val tpoleCatSettings = Seq(
+  private val baseSettings = Seq(
     "-language:postfixOps",      // Added by @tusharmath
     "-deprecation",              // Emit warning and location for usages of deprecated APIs.
     "-encoding",
@@ -25,27 +24,14 @@ trait ScalaSettings {
     "-Xlint:private-shadow",         // A private field (or class parameter) shadows a superclass field.
     "-Xlint:stars-align",            // Pattern sequence wildcard must align with sequence component.
     "-Xlint:type-parameter-shadow",  // A local type parameter shadows a type already in scope.
-    "-Xlint:unused",                 // TODO check if we still need -Wunused below
-    "-Xlint:nonlocal-return",        // A return statement used an exception for flow control.
-    "-Xlint:implicit-not-found",     // Check @implicitNotFound and @implicitAmbiguous messages.
-    "-Xlint:serial",                 // @SerialVersionUID on traits and non-serializable classes.
-    "-Xlint:valpattern",             // Enable pattern checks in val definitions.
-    "-Xlint:eta-zero",               // Warn on eta-expansion (rather than auto-application) of zero-ary method.
-    "-Xlint:eta-sam", // Warn on eta-expansion to meet a Java-defined functional interface that is not explicitly annotated with @FunctionalInterface.
-    "-Xlint:deprecation",                        // Enable linted deprecations.
-    "-Wdead-code",                               // Warn when dead code is identified.
-    "-Wextra-implicit",                          // Warn when more than one implicit parameter section is defined.
-    "-Wmacros:both",                             // Lints code before and after applying a macro
-    "-Wnumeric-widen",                           // Warn when numerics are widened.
-    "-Woctal-literal",                           // Warn on obsolete octal syntax.
-    "-Wunused:imports",                          // Warn if an import selector is not referenced.
-    "-Wunused:patvars",                          // Warn if a variable bound in a pattern is unused.
-    "-Wunused:privates",                         // Warn if a private member is unused.
-    "-Wunused:locals",                           // Warn if a local definition is unused.
-    "-Wunused:explicits",                        // Warn if an explicit parameter is unused.
-    "-Wunused:params",                           // Enable -Wunused:explicits,implicits.
-    "-Wunused:linted",
-    "-Wvalue-discard",                           // Warn when non-Unit expression results are unused.
+    // "-Xlint:unused",                 // TODO check if we still need -Wunused below
+
+    "-Xlint:deprecation", // Enable linted deprecations.
+
+    // "-Wunused:explicits",                        // Warn if an explicit parameter is unused.
+    // "-Wunused:params",                           // Enable -Wunused:explicits,implicits.
+    // "-Wunused:linted",
+
     "-Ybackend-parallelism",
     "8",                                         // Enable paralellisation — change to desired number!
     "-Ycache-plugin-class-loader:last-modified", // Enables caching of classloaders for compiler plugins
@@ -57,4 +43,35 @@ trait ScalaSettings {
     //  "-language:experimental.macros",   // Allow macro definition (besides implementation and application). Disabled, as this will significantly change in Scala 3
     //  "-language:implicitConversions",   // Allow definition of implicit functions called views. Disabled, as it might be dropped in Scala 3. Instead use extension methods (implemented as implicit class Wrapper(val inner: Foo) extends AnyVal {}
   )
+
+  val scala3Settings: Seq[String] = Seq("-Xignore-scala2-macros", "-noindent")
+
+  // RECOMMENDED SETTINGS: https://tpolecat.github.io/2017/04/25/scalac-flags.html
+  val scala213Settings: Seq[String] = baseSettings ++ Seq(
+    "-Xlint:nonlocal-return",    // A return statement used an exception for flow control.
+    "-Xlint:implicit-not-found", // Check @implicitNotFound and @implicitAmbiguous messages.
+    "-Xlint:serial",             // @SerialVersionUID on traits and non-serializable classes.
+    "-Xlint:valpattern",         // Enable pattern checks in val definitions.
+    "-Xlint:eta-zero",           // Warn on eta-expansion (rather than auto-application) of zero-ary method.
+    "-Xlint:eta-sam", // Warn on eta-expansion to meet a Java-defined functional interface that is not explicitly annotated with @FunctionalInterface.
+    "-Wdead-code",       // Warn when dead code is identified.
+    "-Wextra-implicit",  // Warn when more than one implicit parameter section is defined.
+    "-Wmacros:after",    // Lints code before and after applying a macro
+    "-Wnumeric-widen",   // Warn when numerics are widened.
+    "-Woctal-literal",   // Warn on obsolete octal syntax.
+    "-Wunused:imports",  // Warn if an import selector is not referenced.
+    "-Wunused:patvars",  // Warn if a variable bound in a pattern is unused.
+    "-Wunused:privates", // Warn if a private member is unused.
+    "-Wunused:locals",   // Warn if a local definition is unused.
+    "-Wvalue-discard",   // Warn when non-Unit expression results are unused.
+  )
+
+  val scala212Settings: Seq[String] = baseSettings ++ Seq(
+    "-explaintypes",
+    "-Yrangepos",
+    "-Xlint:_,-missing-interpolator,-type-parameter-shadow",
+    "-Ywarn-numeric-widen",
+    "-Ywarn-macros:after",
+    "-Ywarn-unused:-implicits",
+  )
 }

zio-http-logging/src/main/scala-2/zhttp/logging/macros/LoggerMacroExtensions.scala

@@ -0,0 +1,21 @@
+package zhttp.logging.macros
+
+import zhttp.logging.macros.LoggerMacroImpl._
+
+trait LoggerMacroExtensions { self =>
+  import scala.language.experimental.macros
+
+  val isDebugEnabled: Boolean
+  val isErrorEnabled: Boolean
+  val isInfoEnabled: Boolean
+  val isTraceEnabled: Boolean
+  val isWarnEnabled: Boolean
+
+  final def trace(msg: String): Unit = macro logTraceImpl
+  final def debug(msg: String): Unit = macro logDebugImpl
+  final def info(msg: String): Unit = macro logInfoImpl
+  final def warn(msg: String): Unit = macro logWarnImpl
+  final def error(msg: String): Unit = macro logErrorImpl
+  final def error(msg: String, throwable: Throwable): Unit =
+    macro logErrorWithCauseImpl
+}

zio-http-logging/src/main/scala-2/zhttp/logging/macros/LoggerMacroImpl.scala

@@ -0,0 +1,62 @@
+package zhttp.logging.macros
+
+import zhttp.logging.{LogLevel, Logger}
+
+import scala.reflect.macros.whitebox
+
+/**
+ * Macro inspired from log4s.
+ */
+private[zhttp] object LoggerMacroImpl {
+
+  /** A macro context that represents a method call on a Logger instance. */
+  private[this] type LogCtx = whitebox.Context { type PrefixType = Logger }
+
+  /**
+   * Log a message reflectively at a given level.
+   */
+  private[this] def reflectiveLog(
+    c: LogCtx,
+  )(msg: c.Expr[String], error: Option[c.Expr[Throwable]])(logLevel: LogLevel) = {
+    import c.universe._
+    type Tree = c.universe.Tree
+
+    val cname: Tree          = q"${c.internal.enclosingOwner.owner.fullName}"
+    val lno: Tree            = q"${c.enclosingPosition.line}"
+    val sourceLocation: Tree =
+      if (logLevel == LogLevel.Trace)
+        q"Some(_root_.zhttp.logging.Logger.SourcePos($cname, $lno))"
+      else
+        q"None"
+    val logLevelName         = logLevel.name.toLowerCase.capitalize
+    val level: Tree          = q"_root_.zhttp.logging.LogLevel.${TermName(logLevelName)}"
+    val isEnabled: Tree      = q"""${c.prefix.tree}.${TermName(s"is${logLevelName}Enabled")}"""
+
+    if (logLevel >= Logger.detectedLevel)
+      q"""
+      if($isEnabled) {
+        val logMsg = ${msg.tree}
+        ${c.prefix.tree}.dispatch(logMsg, $level, $error, ${sourceLocation})
+      }
+    """
+    else q"()"
+  }
+
+  def logTraceImpl(c: LogCtx)(msg: c.Expr[String]): c.universe.Tree =
+    reflectiveLog(c)(msg, None)(LogLevel.Trace)
+
+  def logInfoImpl(c: LogCtx)(msg: c.Expr[String]): c.universe.Tree =
+    reflectiveLog(c)(msg, None)(LogLevel.Info)
+
+  def logDebugImpl(c: LogCtx)(msg: c.Expr[String]): c.universe.Tree =
+    reflectiveLog(c)(msg, None)(LogLevel.Debug)
+
+  def logWarnImpl(c: LogCtx)(msg: c.Expr[String]): c.universe.Tree =
+    reflectiveLog(c)(msg, None)(LogLevel.Warn)
+
+  def logErrorImpl(c: LogCtx)(msg: c.Expr[String]): c.universe.Tree =
+    reflectiveLog(c)(msg, None)(LogLevel.Error)
+
+  def logErrorWithCauseImpl(c: LogCtx)(msg: c.Expr[String], throwable: c.Expr[Throwable]): c.universe.Tree =
+    reflectiveLog(c)(msg, Some(throwable))(LogLevel.Error)
+}

zio-http-logging/src/main/scala-3/zhttp/logging/macros/LoggerMacroExtensions.scala

@@ -0,0 +1,24 @@
+package zhttp.logging.macros
+
+import zhttp.logging.Logger
+import zhttp.logging.macros.LoggerMacroImpl._
+
+/**
+ * Core Logger class.
+ */
+trait LoggerMacroExtensions{ self: Logger =>
+  import scala.language.experimental.macros
+
+  val isDebugEnabled: Boolean
+  val isErrorEnabled: Boolean
+  val isInfoEnabled: Boolean
+  val isTraceEnabled: Boolean
+  val isWarnEnabled: Boolean
+
+  inline def trace(inline msg: String): Unit = $ { logTraceImpl('self, 'msg) }
+  inline def debug(inline msg: String): Unit = $ { logDebugImpl('self, 'msg) }
+  inline def info(inline msg: String): Unit = $ { logInfoImpl('self, 'msg) }
+  inline def warn(inline msg: String): Unit = $ { logWarnImpl('self, 'msg) }
+  inline def error(inline msg: String): Unit = $ { logErrorImpl('self, 'msg) }
+  inline def error(inline msg: String, throwable: Throwable): Unit = ${logErrorWithCauseImpl('self, 'throwable, 'msg)}
+}