├── project ├── build.properties ├── plugins.sbt └── Build.scala ├── version.sbt ├── README.md ├── .gitignore ├── scalalogging-slf4j └── src │ └── main │ ├── scala │ └── com │ │ └── typesafe │ │ └── scalalogging │ │ └── slf4j │ │ ├── Logging.scala │ │ ├── Logger.scala │ │ └── LoggerMacros.scala │ └── resources │ └── LICENSE-2.0.txt ├── scalalogging-log4j └── src │ └── main │ └── scala │ └── com │ └── typesafe │ └── scalalogging │ └── log4j │ ├── Logging.scala │ ├── Logger.scala │ └── LoggerMacros.scala ├── scalalogging-slf4j-test └── src │ └── test │ └── scala │ └── com │ └── typesafe │ └── scalalogging │ └── slf4j │ └── Slf4jLoggerSpec.scala └── scalalogging-log4j-test └── src └── test └── scala └── com └── typesafe └── scalalogging └── slf4j └── Log4jLoggerSpec.scala /project/build.properties: -------------------------------------------------------------------------------- 1 | sbt.version=0.13.1 2 | -------------------------------------------------------------------------------- /version.sbt: -------------------------------------------------------------------------------- 1 | version in ThisBuild := "1.1.1-SNAPSHOT" -------------------------------------------------------------------------------- /project/plugins.sbt: -------------------------------------------------------------------------------- 1 | 2 | addSbtPlugin("com.github.gseitz" % "sbt-release" % "0.8") 3 | 4 | addSbtPlugin("com.typesafe.sbt" % "sbt-scalariform" % "1.2.1") 5 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ScalaLogging 2 | ============ 3 | 4 | This repository is end of life. Scala Logging is continued at [github.com/typesafehub/scala-logging](https://github.com/typesafehub/scala-logging). 5 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # SBT 2 | boot/ 3 | lib_managed/ 4 | target/ 5 | .history 6 | 7 | # Eclipse 8 | .cache 9 | .classpath 10 | .project 11 | .scala_dependencies 12 | .settings 13 | .target/ 14 | 15 | # IntelliJ 16 | .idea/ 17 | *.iml 18 | *.ipr 19 | *.iws 20 | out/ 21 | 22 | # TextMate 23 | *.tmproj 24 | 25 | # Mac 26 | .DS_Store 27 | -------------------------------------------------------------------------------- /scalalogging-slf4j/src/main/scala/com/typesafe/scalalogging/slf4j/Logging.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 Copyright 2012 Typesafe Inc. 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package com.typesafe.scalalogging.slf4j 18 | 19 | import org.slf4j.LoggerFactory 20 | 21 | /** 22 | * Requires the member `logger` of type [[$Logger]] to be defined in the class into which this trait is mixed. 23 | * 24 | * @define Logger com.typesafe.scalalogging.slf4j.Logger 25 | */ 26 | trait AbstractLogging { 27 | 28 | protected def logger: Logger 29 | } 30 | 31 | /** 32 | * Adds the lazy val `logger` of type [[$Logger]] to the class into which this trait is mixed. 33 | * 34 | * If you need a non-lazy [[$Logger]], which would probably be a special case, 35 | * use [[com.typesafe.scalalogging.slf4j.StrictLogging]]. 36 | * 37 | * @define Logger com.typesafe.scalalogging.slf4j.Logger 38 | */ 39 | trait Logging extends AbstractLogging { 40 | 41 | protected lazy val logger: Logger = 42 | Logger(LoggerFactory getLogger getClass.getName) 43 | } 44 | 45 | /** 46 | * Adds the non-lazy val `logger` of type [[$Logger]] to the class into which this trait is mixed. 47 | * 48 | * If you need a lazy [[$Logger]], which would probably be preferrable, 49 | * use [[com.typesafe.scalalogging.slf4j.Logging]]. 50 | * 51 | * @define Logger com.typesafe.scalalogging.slf4j.Logger 52 | */ 53 | trait StrictLogging extends AbstractLogging { 54 | 55 | protected val logger: Logger = 56 | Logger(LoggerFactory getLogger getClass.getName) 57 | } 58 | -------------------------------------------------------------------------------- /scalalogging-log4j/src/main/scala/com/typesafe/scalalogging/log4j/Logging.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 Copyright 2012 Typesafe Inc. 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package com.typesafe.scalalogging.log4j 18 | 19 | import org.apache.logging.log4j.LogManager 20 | 21 | /** 22 | * Requires the member `logger` of type [[$Logger]] to be defined in the class into which this trait is mixed. 23 | * 24 | * @define Logger com.typesafe.scalalogging.log4j.Logger 25 | */ 26 | trait AbstractLogging { 27 | 28 | protected def logger: Logger 29 | } 30 | 31 | /** 32 | * Adds the lazy val `logger` of type [[$Logger]] to the class into which this trait is mixed. 33 | * 34 | * If you need a non-lazy [[$Logger]], which would probably be a special case, 35 | * use [[com.typesafe.scalalogging.log4j.StrictLogging]]. 36 | * 37 | * @define Logger com.typesafe.scalalogging.log4j.Logger 38 | */ 39 | trait Logging extends AbstractLogging { 40 | 41 | protected lazy val logger: Logger = 42 | Logger(LogManager getLogger getClass.getName) 43 | } 44 | 45 | /** 46 | * Adds the non-lazy val `logger` of type [[$Logger]] to the class into which this trait is mixed. 47 | * 48 | * If you need a lazy [[$Logger]], which would probably be preferrable, 49 | * use [[com.typesafe.scalalogging.log4j.Logging]]. 50 | * 51 | * @define Logger com.typesafe.scalalogging.log4j.Logger 52 | */ 53 | trait StrictLogging extends AbstractLogging { 54 | 55 | protected val logger: Logger = 56 | Logger(LogManager getLogger getClass.getName) 57 | } 58 | -------------------------------------------------------------------------------- /project/Build.scala: -------------------------------------------------------------------------------- 1 | import sbt._ 2 | import sbt.Keys._ 3 | import com.typesafe.sbt.SbtScalariform._ 4 | import sbtrelease.ReleasePlugin._ 5 | 6 | object Build extends Build { 7 | 8 | val ScalaVersion = "2.10.3" 9 | 10 | lazy val root = Project( 11 | "scalalogging", 12 | file("."), 13 | settings = commonSettings ++ Seq( 14 | publishArtifact := false 15 | ), 16 | aggregate = Seq( 17 | scalaloggingSlf4j, 18 | scalaloggingSlf4jTest, 19 | scalaloggingLog4j, 20 | scalaloggingLog4jTest 21 | ) 22 | ) 23 | 24 | lazy val scalaloggingSlf4j = Project( 25 | "scalalogging-slf4j", 26 | file("scalalogging-slf4j"), 27 | settings = commonSettings ++ Seq( 28 | libraryDependencies := Seq( 29 | Dependencies.Compile.scalaReflect, 30 | Dependencies.Compile.slf4jApi 31 | ), 32 | initialCommands in console := "import com.typesafe.scalalogging.slf4j._" 33 | ) 34 | ) 35 | 36 | lazy val scalaloggingSlf4jTest = Project( 37 | "scalalogging-slf4j-test", 38 | file("scalalogging-slf4j-test"), 39 | settings = commonSettings ++ Seq( 40 | publishArtifact := false 41 | ), 42 | dependencies = Seq(scalaloggingSlf4j) 43 | ) 44 | 45 | lazy val scalaloggingLog4j = Project( 46 | "scalalogging-log4j", 47 | file("scalalogging-log4j"), 48 | settings = commonSettings ++ Seq( 49 | libraryDependencies := Seq( 50 | Dependencies.Compile.scalaReflect, 51 | Dependencies.Compile.log4jApi 52 | ), 53 | initialCommands in console := "import com.typesafe.scalalogging.log4j._" 54 | ) 55 | ) 56 | 57 | lazy val scalaloggingLog4jTest = Project( 58 | "scalalogging-log4j-test", 59 | file("scalalogging-log4j-test"), 60 | settings = commonSettings ++ Seq( 61 | publishArtifact := false 62 | ), 63 | dependencies = Seq(scalaloggingLog4j) 64 | ) 65 | 66 | def commonSettings = 67 | Defaults.defaultSettings ++ 68 | scalariformSettings ++ 69 | releaseSettings ++ 70 | Seq( 71 | organization := "com.typesafe", 72 | scalaVersion := ScalaVersion, 73 | scalacOptions ++= Seq( 74 | "-unchecked", 75 | "-deprecation", 76 | "-Xlint", 77 | "-target:jvm-1.6", 78 | "-encoding", "UTF-8" 79 | ), 80 | libraryDependencies ++= Seq( 81 | Dependencies.Test.specs2, 82 | Dependencies.Test.mockito, 83 | Dependencies.Test.hamcrest 84 | ), 85 | licenses := Seq("Apache 2.0 License" -> url("http://www.apache.org/licenses/LICENSE-2.0.html")), 86 | homepage := Some(url("https://github.com/typesafehub/scalalogging")), 87 | publishTo <<= isSnapshot(isSnapshot => Some(if (isSnapshot) Opts.resolver.sonatypeSnapshots else Opts.resolver.sonatypeStaging)), 88 | publishArtifact in Test := false, 89 | pomIncludeRepository := (_ => false), 90 | pomExtra := 91 | 92 | https://github.com/typesafehub/scalalogging 93 | scm:git:git://github.com/typesafehub/scalalogging.git 94 | 95 | 96 | 97 | hseeberger 98 | Heiko Seeberger 99 | http://heikoseeberger.name 100 | 101 | 102 | ) 103 | 104 | object Dependencies { 105 | 106 | object Compile { 107 | val scalaReflect = "org.scala-lang" % "scala-reflect" % ScalaVersion 108 | val slf4jApi = "org.slf4j" % "slf4j-api" % "1.7.5" 109 | val log4jApi = "org.apache.logging.log4j" % "log4j-api" % "2.0-beta4" 110 | } 111 | 112 | object Test { 113 | val specs2 = "org.specs2" %% "specs2" % "1.14" % "test" 114 | val mockito = "org.mockito" % "mockito-all" % "1.9.0" % "test" 115 | val hamcrest = "org.hamcrest" % "hamcrest-all" % "1.1" % "test" 116 | } 117 | } 118 | } 119 | -------------------------------------------------------------------------------- /scalalogging-slf4j/src/main/scala/com/typesafe/scalalogging/slf4j/Logger.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 Typesafe Inc. 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package com.typesafe.scalalogging.slf4j 18 | 19 | import language.experimental.macros 20 | import org.slf4j.{ Logger => Underlying, Marker } 21 | 22 | object Logger { 23 | 24 | /** 25 | * Create a [[com.typesafe.scalalogging.slf4j.Logger]] wrapping the given underlying `org.slf4j.Logger`. 26 | */ 27 | def apply(underlying: Underlying): Logger = 28 | new Logger(underlying) 29 | } 30 | 31 | /** 32 | * Convenient and performant wrapper around the given underlying `org.slf4j.Logger`. 33 | * 34 | * Convenient, because you can use string formatting, string interpolation or whatever you want 35 | * without thinking too much about performance. 36 | * Performant, because by using macros the log methods are expanded inline to the check-enabled idiom. 37 | */ 38 | final class Logger private (val underlying: Underlying) { 39 | 40 | // Error 41 | 42 | def error(message: String): Unit = macro LoggerMacros.errorMessage 43 | 44 | def error(message: String, params: AnyRef*): Unit = macro LoggerMacros.errorMessageParams 45 | 46 | def error(message: String, t: Throwable): Unit = macro LoggerMacros.errorMessageThrowable 47 | 48 | def error(marker: Marker, message: String): Unit = macro LoggerMacros.errorMarkerMessage 49 | 50 | def error(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.errorMarkerMessageParams 51 | 52 | def error(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.errorMarkerMessageThrowable 53 | 54 | // Warn 55 | 56 | def warn(message: String): Unit = macro LoggerMacros.warnMessage 57 | 58 | def warn(message: String, params: AnyRef*): Unit = macro LoggerMacros.warnMessageParams 59 | 60 | def warn(message: String, t: Throwable): Unit = macro LoggerMacros.warnMessageThrowable 61 | 62 | def warn(marker: Marker, message: String): Unit = macro LoggerMacros.warnMarkerMessage 63 | 64 | def warn(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.warnMarkerMessageParams 65 | 66 | def warn(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.warnMarkerMessageThrowable 67 | 68 | // Info 69 | 70 | def info(message: String): Unit = macro LoggerMacros.infoMessage 71 | 72 | def info(message: String, params: AnyRef*): Unit = macro LoggerMacros.infoMessageParams 73 | 74 | def info(message: String, t: Throwable): Unit = macro LoggerMacros.infoMessageThrowable 75 | 76 | def info(marker: Marker, message: String): Unit = macro LoggerMacros.infoMarkerMessage 77 | 78 | def info(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.infoMarkerMessageParams 79 | 80 | def info(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.infoMarkerMessageThrowable 81 | 82 | // Debug 83 | 84 | def debug(message: String): Unit = macro LoggerMacros.debugMessage 85 | 86 | def debug(message: String, params: AnyRef*): Unit = macro LoggerMacros.debugMessageParams 87 | 88 | def debug(message: String, t: Throwable): Unit = macro LoggerMacros.debugMessageThrowable 89 | 90 | def debug(marker: Marker, message: String): Unit = macro LoggerMacros.debugMarkerMessage 91 | 92 | def debug(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.debugMarkerMessageParams 93 | 94 | def debug(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.debugMarkerMessageThrowable 95 | 96 | // Trace 97 | 98 | def trace(message: String): Unit = macro LoggerMacros.traceMessage 99 | 100 | def trace(message: String, params: AnyRef*): Unit = macro LoggerMacros.traceMessageParams 101 | 102 | def trace(message: String, t: Throwable): Unit = macro LoggerMacros.traceMessageThrowable 103 | 104 | def trace(marker: Marker, message: String): Unit = macro LoggerMacros.traceMarkerMessage 105 | 106 | def trace(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.traceMarkerMessageParams 107 | 108 | def trace(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.traceMarkerMessageThrowable 109 | } 110 | -------------------------------------------------------------------------------- /scalalogging-log4j/src/main/scala/com/typesafe/scalalogging/log4j/Logger.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 Typesafe Inc. 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package com.typesafe.scalalogging.log4j 18 | 19 | import language.experimental.macros 20 | import org.apache.logging.log4j.{ Logger => Underlying, Marker } 21 | 22 | object Logger { 23 | 24 | /** 25 | * Create a [[com.typesafe.scalalogging.log4j.Logger]] wrapping the given underlying 26 | * `org.apache.logging.log4j.Logger`. 27 | */ 28 | def apply(underlying: Underlying): Logger = 29 | new Logger(underlying) 30 | } 31 | 32 | /** 33 | * Convenient and performant wrapper around the given underlying `org.apache.logging.log4j.Logger`. 34 | * 35 | * Convenient, because you can use string formatting, string interpolation or whatever you want 36 | * without thinking too much about performance. 37 | * Performant, because by using macros the log methods are expanded inline to the check-enabled idiom. 38 | */ 39 | final class Logger private (val underlying: Underlying) { 40 | 41 | // Fatal 42 | 43 | def fatal(message: String): Unit = macro LoggerMacros.fatalMessage 44 | 45 | def fatal(marker: Marker, message: String): Unit = macro LoggerMacros.fatalMarkerMessage 46 | 47 | def fatal(message: String, t: Throwable): Unit = macro LoggerMacros.fatalMessageThrowable 48 | 49 | def fatal(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.fatalMarkerMessageThrowable 50 | 51 | def fatal(message: AnyRef): Unit = macro LoggerMacros.fatalAnyRefMessage 52 | 53 | def fatal(marker: Marker, message: AnyRef): Unit = macro LoggerMacros.fatalMarkerAnyRefMessage 54 | 55 | def fatal(message: AnyRef, t: Throwable): Unit = macro LoggerMacros.fatalAnyRefMessageThrowable 56 | 57 | def fatal(marker: Marker, message: AnyRef, t: Throwable): Unit = macro LoggerMacros.fatalMarkerAnyRefMessageThrowable 58 | 59 | def fatal(message: String, params: AnyRef*): Unit = macro LoggerMacros.fatalMessageParams 60 | 61 | def fatal(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.fatalMarkerMessageParams 62 | 63 | // Error 64 | 65 | def error(message: String): Unit = macro LoggerMacros.errorMessage 66 | 67 | def error(marker: Marker, message: String): Unit = macro LoggerMacros.errorMarkerMessage 68 | 69 | def error(message: String, t: Throwable): Unit = macro LoggerMacros.errorMessageThrowable 70 | 71 | def error(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.errorMarkerMessageThrowable 72 | 73 | def error(message: AnyRef): Unit = macro LoggerMacros.errorAnyRefMessage 74 | 75 | def error(marker: Marker, message: AnyRef): Unit = macro LoggerMacros.errorMarkerAnyRefMessage 76 | 77 | def error(message: AnyRef, t: Throwable): Unit = macro LoggerMacros.errorAnyRefMessageThrowable 78 | 79 | def error(marker: Marker, message: AnyRef, t: Throwable): Unit = macro LoggerMacros.errorMarkerAnyRefMessageThrowable 80 | 81 | def error(message: String, params: AnyRef*): Unit = macro LoggerMacros.errorMessageParams 82 | 83 | def error(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.errorMarkerMessageParams 84 | 85 | // Warn 86 | 87 | def warn(message: String): Unit = macro LoggerMacros.warnMessage 88 | 89 | def warn(marker: Marker, message: String): Unit = macro LoggerMacros.warnMarkerMessage 90 | 91 | def warn(message: String, t: Throwable): Unit = macro LoggerMacros.warnMessageThrowable 92 | 93 | def warn(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.warnMarkerMessageThrowable 94 | 95 | def warn(message: AnyRef): Unit = macro LoggerMacros.warnAnyRefMessage 96 | 97 | def warn(marker: Marker, message: AnyRef): Unit = macro LoggerMacros.warnMarkerAnyRefMessage 98 | 99 | def warn(message: AnyRef, t: Throwable): Unit = macro LoggerMacros.warnAnyRefMessageThrowable 100 | 101 | def warn(marker: Marker, message: AnyRef, t: Throwable): Unit = macro LoggerMacros.warnMarkerAnyRefMessageThrowable 102 | 103 | def warn(message: String, params: AnyRef*): Unit = macro LoggerMacros.warnMessageParams 104 | 105 | def warn(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.warnMarkerMessageParams 106 | 107 | // Info 108 | 109 | def info(message: String): Unit = macro LoggerMacros.infoMessage 110 | 111 | def info(marker: Marker, message: String): Unit = macro LoggerMacros.infoMarkerMessage 112 | 113 | def info(message: String, t: Throwable): Unit = macro LoggerMacros.infoMessageThrowable 114 | 115 | def info(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.infoMarkerMessageThrowable 116 | 117 | def info(message: AnyRef): Unit = macro LoggerMacros.infoAnyRefMessage 118 | 119 | def info(marker: Marker, message: AnyRef): Unit = macro LoggerMacros.infoMarkerAnyRefMessage 120 | 121 | def info(message: AnyRef, t: Throwable): Unit = macro LoggerMacros.infoAnyRefMessageThrowable 122 | 123 | def info(marker: Marker, message: AnyRef, t: Throwable): Unit = macro LoggerMacros.infoMarkerAnyRefMessageThrowable 124 | 125 | def info(message: String, params: AnyRef*): Unit = macro LoggerMacros.infoMessageParams 126 | 127 | def info(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.infoMarkerMessageParams 128 | 129 | // Debug 130 | 131 | def debug(message: String): Unit = macro LoggerMacros.debugMessage 132 | 133 | def debug(marker: Marker, message: String): Unit = macro LoggerMacros.debugMarkerMessage 134 | 135 | def debug(message: String, t: Throwable): Unit = macro LoggerMacros.debugMessageThrowable 136 | 137 | def debug(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.debugMarkerMessageThrowable 138 | 139 | def debug(message: AnyRef): Unit = macro LoggerMacros.debugAnyRefMessage 140 | 141 | def debug(marker: Marker, message: AnyRef): Unit = macro LoggerMacros.debugMarkerAnyRefMessage 142 | 143 | def debug(message: AnyRef, t: Throwable): Unit = macro LoggerMacros.debugAnyRefMessageThrowable 144 | 145 | def debug(marker: Marker, message: AnyRef, t: Throwable): Unit = macro LoggerMacros.debugMarkerAnyRefMessageThrowable 146 | 147 | def debug(message: String, params: AnyRef*): Unit = macro LoggerMacros.debugMessageParams 148 | 149 | def debug(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.debugMarkerMessageParams 150 | 151 | // Trace 152 | 153 | def trace(message: String): Unit = macro LoggerMacros.traceMessage 154 | 155 | def trace(marker: Marker, message: String): Unit = macro LoggerMacros.traceMarkerMessage 156 | 157 | def trace(message: String, t: Throwable): Unit = macro LoggerMacros.traceMessageThrowable 158 | 159 | def trace(marker: Marker, message: String, t: Throwable): Unit = macro LoggerMacros.traceMarkerMessageThrowable 160 | 161 | def trace(message: AnyRef): Unit = macro LoggerMacros.traceAnyRefMessage 162 | 163 | def trace(marker: Marker, message: AnyRef): Unit = macro LoggerMacros.traceMarkerAnyRefMessage 164 | 165 | def trace(message: AnyRef, t: Throwable): Unit = macro LoggerMacros.traceAnyRefMessageThrowable 166 | 167 | def trace(marker: Marker, message: AnyRef, t: Throwable): Unit = macro LoggerMacros.traceMarkerAnyRefMessageThrowable 168 | 169 | def trace(message: String, params: AnyRef*): Unit = macro LoggerMacros.traceMessageParams 170 | 171 | def trace(marker: Marker, message: String, params: AnyRef*): Unit = macro LoggerMacros.traceMarkerMessageParams 172 | } 173 | 174 | -------------------------------------------------------------------------------- /scalalogging-slf4j/src/main/scala/com/typesafe/scalalogging/slf4j/LoggerMacros.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 Typesafe Inc. 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package com.typesafe.scalalogging.slf4j 18 | 19 | import org.slf4j.Marker 20 | import scala.reflect.macros.Context 21 | 22 | private object LoggerMacros { 23 | 24 | type LoggerContext = Context { type PrefixType = Logger } 25 | 26 | // Error 27 | 28 | def errorMessage(c: LoggerContext)(message: c.Expr[String]) = 29 | c.universe.reify( 30 | if (c.prefix.splice.underlying.isErrorEnabled) 31 | c.prefix.splice.underlying.error(message.splice) 32 | ) 33 | 34 | def errorMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 35 | logParams(c)(message, params, None)("error") 36 | 37 | def errorMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 38 | c.universe.reify( 39 | if (c.prefix.splice.underlying.isErrorEnabled) 40 | c.prefix.splice.underlying.error(message.splice, t.splice) 41 | ) 42 | 43 | def errorMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 44 | c.universe.reify( 45 | if (c.prefix.splice.underlying.isErrorEnabled) 46 | c.prefix.splice.underlying.error(marker.splice, message.splice) 47 | ) 48 | 49 | def errorMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 50 | logParams(c)(message, params, Some(marker))("error") 51 | 52 | def errorMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 53 | c.universe.reify( 54 | if (c.prefix.splice.underlying.isErrorEnabled) 55 | c.prefix.splice.underlying.error(marker.splice, message.splice, t.splice) 56 | ) 57 | 58 | // Warn 59 | 60 | def warnMessage(c: LoggerContext)(message: c.Expr[String]) = 61 | c.universe.reify( 62 | if (c.prefix.splice.underlying.isWarnEnabled) 63 | c.prefix.splice.underlying.warn(message.splice) 64 | ) 65 | 66 | def warnMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 67 | logParams(c)(message, params, None)("warn") 68 | 69 | def warnMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 70 | c.universe.reify( 71 | if (c.prefix.splice.underlying.isWarnEnabled) 72 | c.prefix.splice.underlying.warn(message.splice, t.splice) 73 | ) 74 | 75 | def warnMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 76 | c.universe.reify( 77 | if (c.prefix.splice.underlying.isWarnEnabled) 78 | c.prefix.splice.underlying.warn(marker.splice, message.splice) 79 | ) 80 | 81 | def warnMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 82 | logParams(c)(message, params, Some(marker))("warn") 83 | 84 | def warnMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 85 | c.universe.reify( 86 | if (c.prefix.splice.underlying.isWarnEnabled) 87 | c.prefix.splice.underlying.warn(marker.splice, message.splice, t.splice) 88 | ) 89 | 90 | // Info 91 | 92 | def infoMessage(c: LoggerContext)(message: c.Expr[String]) = 93 | c.universe.reify( 94 | if (c.prefix.splice.underlying.isInfoEnabled) 95 | c.prefix.splice.underlying.info(message.splice) 96 | ) 97 | 98 | def infoMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 99 | logParams(c)(message, params, None)("info") 100 | 101 | def infoMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 102 | c.universe.reify( 103 | if (c.prefix.splice.underlying.isInfoEnabled) 104 | c.prefix.splice.underlying.info(message.splice, t.splice) 105 | ) 106 | 107 | def infoMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 108 | c.universe.reify( 109 | if (c.prefix.splice.underlying.isInfoEnabled) 110 | c.prefix.splice.underlying.info(marker.splice, message.splice) 111 | ) 112 | 113 | def infoMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 114 | logParams(c)(message, params, Some(marker))("info") 115 | 116 | def infoMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 117 | c.universe.reify( 118 | if (c.prefix.splice.underlying.isInfoEnabled) 119 | c.prefix.splice.underlying.info(marker.splice, message.splice, t.splice) 120 | ) 121 | 122 | // Debug 123 | 124 | def debugMessage(c: LoggerContext)(message: c.Expr[String]) = 125 | c.universe.reify( 126 | if (c.prefix.splice.underlying.isDebugEnabled) 127 | c.prefix.splice.underlying.debug(message.splice) 128 | ) 129 | 130 | def debugMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 131 | logParams(c)(message, params, None)("debug") 132 | 133 | def debugMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 134 | c.universe.reify( 135 | if (c.prefix.splice.underlying.isDebugEnabled) 136 | c.prefix.splice.underlying.debug(message.splice, t.splice) 137 | ) 138 | 139 | def debugMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 140 | c.universe.reify( 141 | if (c.prefix.splice.underlying.isDebugEnabled) 142 | c.prefix.splice.underlying.debug(marker.splice, message.splice) 143 | ) 144 | 145 | def debugMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 146 | logParams(c)(message, params, Some(marker))("debug") 147 | 148 | def debugMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 149 | c.universe.reify( 150 | if (c.prefix.splice.underlying.isDebugEnabled) 151 | c.prefix.splice.underlying.debug(marker.splice, message.splice, t.splice) 152 | ) 153 | 154 | // Trace 155 | 156 | def traceMessage(c: LoggerContext)(message: c.Expr[String]) = 157 | c.universe.reify( 158 | if (c.prefix.splice.underlying.isTraceEnabled) 159 | c.prefix.splice.underlying.trace(message.splice) 160 | ) 161 | 162 | def traceMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 163 | logParams(c)(message, params, None)("trace") 164 | 165 | def traceMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 166 | c.universe.reify( 167 | if (c.prefix.splice.underlying.isTraceEnabled) 168 | c.prefix.splice.underlying.trace(message.splice, t.splice) 169 | ) 170 | 171 | def traceMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 172 | c.universe.reify( 173 | if (c.prefix.splice.underlying.isTraceEnabled) 174 | c.prefix.splice.underlying.trace(marker.splice, message.splice) 175 | ) 176 | 177 | def traceMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 178 | logParams(c)(message, params, Some(marker))("trace") 179 | 180 | def traceMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 181 | c.universe.reify( 182 | if (c.prefix.splice.underlying.isTraceEnabled) 183 | c.prefix.splice.underlying.trace(marker.splice, message.splice, t.splice) 184 | ) 185 | 186 | // Common 187 | 188 | private def logParams( 189 | c: LoggerContext)( 190 | message: c.Expr[String], 191 | params: Seq[c.Expr[AnyRef]], 192 | marker: Option[c.Expr[Marker]])( 193 | level: String) = { 194 | import c.universe._ 195 | val isEnabled = Select( 196 | Select(c.prefix.tree, newTermName("underlying")), 197 | newTermName(s"is${level.head.toUpper +: level.tail}Enabled") 198 | ) 199 | val paramsWildcard = Typed( 200 | Apply( 201 | Ident(newTermName("List")), 202 | (params map (_.tree)).toList 203 | ), 204 | Ident(tpnme.WILDCARD_STAR) 205 | ) 206 | val log = Apply( 207 | Select(Select(c.prefix.tree, newTermName("underlying")), newTermName(level)), 208 | marker.foldRight(message.tree +: List(paramsWildcard))(_.tree +: _) 209 | ) 210 | c.Expr(If(isEnabled, log, Literal(Constant(())))) 211 | } 212 | } 213 | -------------------------------------------------------------------------------- /scalalogging-slf4j-test/src/test/scala/com/typesafe/scalalogging/slf4j/Slf4jLoggerSpec.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 Copyright 2012 Typesafe Inc. 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package com.typesafe.scalalogging.slf4j 18 | 19 | import org.slf4j.{ Logger => Underlying, MarkerFactory } 20 | import org.specs2.mock.Mockito 21 | import org.specs2.mutable.Specification 22 | 23 | object Slf4jLoggerSpec extends Specification with Mockito { 24 | 25 | private val Message = "String message!" 26 | 27 | private val AnyRefMessage = new AnyRef 28 | 29 | private val Throwable = new Exception("Exception") 30 | 31 | private val Marker = MarkerFactory getMarker "Marker" 32 | 33 | private val Params = List("1", "2", new java.util.Date(3)) 34 | 35 | "Calling error" should { 36 | "not call the underlying logger if level not enabled" in { 37 | val underlying = mock[Underlying] 38 | underlying.isErrorEnabled returns false 39 | val logger = Logger(underlying) 40 | logger.error(Message) 41 | there was no(underlying).error(Message) 42 | logger.error(Message, "1", "2", new java.util.Date(3)) 43 | there was no(underlying).error(Message, "1", "2", new java.util.Date(3)) 44 | logger.error(Message, Throwable) 45 | there was no(underlying).error(Message, Throwable) 46 | logger.error(Marker, Message) 47 | there was no(underlying).error(Marker, Message) 48 | logger.error(Marker, Message, Params: _*) 49 | there was no(underlying).error(Marker, Message, Params: _*) 50 | logger.error(Marker, Message, Throwable) 51 | there was no(underlying).error(Marker, Message, Throwable) 52 | } 53 | "call the underlying logger if level enabled" in { 54 | val underlying = mock[Underlying] 55 | underlying.isErrorEnabled returns true 56 | val logger = Logger(underlying) 57 | logger.error(Message) 58 | there was one(underlying).error(Message) 59 | logger.error(Message, "1", "2", new java.util.Date(3)) 60 | there was one(underlying).error(Message, "1", "2", new java.util.Date(3)) 61 | logger.error(Message, Throwable) 62 | there was one(underlying).error(Message, Throwable) 63 | logger.error(Marker, Message) 64 | there was one(underlying).error(Marker, Message) 65 | logger.error(Marker, Message, Params: _*) 66 | there was one(underlying).error(Marker, Message, Params: _*) 67 | logger.error(Marker, Message, Throwable) 68 | there was one(underlying).error(Marker, Message, Throwable) 69 | } 70 | } 71 | 72 | "Calling warn" should { 73 | "not call the underlying logger if level not enabled" in { 74 | val underlying = mock[Underlying] 75 | underlying.isWarnEnabled returns false 76 | val logger = Logger(underlying) 77 | logger.warn(Message) 78 | there was no(underlying).warn(Message) 79 | logger.warn(Message, "1", "2", new java.util.Date(3)) 80 | there was no(underlying).warn(Message, "1", "2", new java.util.Date(3)) 81 | logger.warn(Message, Throwable) 82 | there was no(underlying).warn(Message, Throwable) 83 | logger.warn(Marker, Message) 84 | there was no(underlying).warn(Marker, Message) 85 | logger.warn(Marker, Message, Params: _*) 86 | there was no(underlying).warn(Marker, Message, Params: _*) 87 | logger.warn(Marker, Message, Throwable) 88 | there was no(underlying).warn(Marker, Message, Throwable) 89 | } 90 | "call the underlying logger if level enabled" in { 91 | val underlying = mock[Underlying] 92 | underlying.isWarnEnabled returns true 93 | val logger = Logger(underlying) 94 | logger.warn(Message) 95 | there was one(underlying).warn(Message) 96 | logger.warn(Message, "1", "2", new java.util.Date(3)) 97 | there was one(underlying).warn(Message, "1", "2", new java.util.Date(3)) 98 | logger.warn(Message, Throwable) 99 | there was one(underlying).warn(Message, Throwable) 100 | logger.warn(Marker, Message) 101 | there was one(underlying).warn(Marker, Message) 102 | logger.warn(Marker, Message, Params: _*) 103 | there was one(underlying).warn(Marker, Message, Params: _*) 104 | logger.warn(Marker, Message, Throwable) 105 | there was one(underlying).warn(Marker, Message, Throwable) 106 | } 107 | } 108 | 109 | "Calling info" should { 110 | "not call the underlying logger if level not enabled" in { 111 | val underlying = mock[Underlying] 112 | underlying.isInfoEnabled returns false 113 | val logger = Logger(underlying) 114 | logger.info(Message) 115 | there was no(underlying).info(Message) 116 | logger.info(Message, "1", "2", new java.util.Date(3)) 117 | there was no(underlying).info(Message, "1", "2", new java.util.Date(3)) 118 | logger.info(Message, Throwable) 119 | there was no(underlying).info(Message, Throwable) 120 | logger.info(Marker, Message) 121 | there was no(underlying).info(Marker, Message) 122 | logger.info(Marker, Message, Params: _*) 123 | there was no(underlying).info(Marker, Message, Params: _*) 124 | logger.info(Marker, Message, Throwable) 125 | there was no(underlying).info(Marker, Message, Throwable) 126 | } 127 | "call the underlying logger if level enabled" in { 128 | val underlying = mock[Underlying] 129 | underlying.isInfoEnabled returns true 130 | val logger = Logger(underlying) 131 | logger.info(Message) 132 | there was one(underlying).info(Message) 133 | logger.info(Message, "1", "2", new java.util.Date(3)) 134 | there was one(underlying).info(Message, "1", "2", new java.util.Date(3)) 135 | logger.info(Message, Throwable) 136 | there was one(underlying).info(Message, Throwable) 137 | logger.info(Marker, Message) 138 | there was one(underlying).info(Marker, Message) 139 | logger.info(Marker, Message, Params: _*) 140 | there was one(underlying).info(Marker, Message, Params: _*) 141 | logger.info(Marker, Message, Throwable) 142 | there was one(underlying).info(Marker, Message, Throwable) 143 | } 144 | } 145 | 146 | "Calling debug" should { 147 | "not call the underlying logger if level not enabled" in { 148 | val underlying = mock[Underlying] 149 | underlying.isDebugEnabled returns false 150 | val logger = Logger(underlying) 151 | logger.debug(Message) 152 | there was no(underlying).debug(Message) 153 | logger.debug(Message, "1", "2", new java.util.Date(3)) 154 | there was no(underlying).debug(Message, "1", "2", new java.util.Date(3)) 155 | logger.debug(Message, Throwable) 156 | there was no(underlying).debug(Message, Throwable) 157 | logger.debug(Marker, Message) 158 | there was no(underlying).debug(Marker, Message) 159 | logger.debug(Marker, Message, Params: _*) 160 | there was no(underlying).debug(Marker, Message, Params: _*) 161 | logger.debug(Marker, Message, Throwable) 162 | there was no(underlying).debug(Marker, Message, Throwable) 163 | } 164 | "call the underlying logger if level enabled" in { 165 | val underlying = mock[Underlying] 166 | underlying.isDebugEnabled returns true 167 | val logger = Logger(underlying) 168 | logger.debug(Message) 169 | there was one(underlying).debug(Message) 170 | logger.debug(Message, "1", "2", new java.util.Date(3)) 171 | there was one(underlying).debug(Message, "1", "2", new java.util.Date(3)) 172 | logger.debug(Message, Throwable) 173 | there was one(underlying).debug(Message, Throwable) 174 | logger.debug(Marker, Message) 175 | there was one(underlying).debug(Marker, Message) 176 | logger.debug(Marker, Message, Params: _*) 177 | there was one(underlying).debug(Marker, Message, Params: _*) 178 | logger.debug(Marker, Message, Throwable) 179 | there was one(underlying).debug(Marker, Message, Throwable) 180 | } 181 | } 182 | 183 | "Calling trace" should { 184 | "not call the underlying logger if level not enabled" in { 185 | val underlying = mock[Underlying] 186 | underlying.isTraceEnabled returns false 187 | val logger = Logger(underlying) 188 | logger.trace(Message) 189 | there was no(underlying).trace(Message) 190 | logger.trace(Message, "1", "2", new java.util.Date(3)) 191 | there was no(underlying).trace(Message, "1", "2", new java.util.Date(3)) 192 | logger.trace(Message, Throwable) 193 | there was no(underlying).trace(Message, Throwable) 194 | logger.trace(Marker, Message) 195 | there was no(underlying).trace(Marker, Message) 196 | logger.trace(Marker, Message, Params: _*) 197 | there was no(underlying).trace(Marker, Message, Params: _*) 198 | logger.trace(Marker, Message, Throwable) 199 | there was no(underlying).trace(Marker, Message, Throwable) 200 | } 201 | "call the underlying logger if level enabled" in { 202 | val underlying = mock[Underlying] 203 | underlying.isTraceEnabled returns true 204 | val logger = Logger(underlying) 205 | logger.trace(Message) 206 | there was one(underlying).trace(Message) 207 | logger.trace(Message, "1", "2", new java.util.Date(3)) 208 | there was one(underlying).trace(Message, "1", "2", new java.util.Date(3)) 209 | logger.trace(Message, Throwable) 210 | there was one(underlying).trace(Message, Throwable) 211 | logger.trace(Marker, Message) 212 | there was one(underlying).trace(Marker, Message) 213 | logger.trace(Marker, Message, Params: _*) 214 | there was one(underlying).trace(Marker, Message, Params: _*) 215 | logger.trace(Marker, Message, Throwable) 216 | there was one(underlying).trace(Marker, Message, Throwable) 217 | } 218 | } 219 | } 220 | -------------------------------------------------------------------------------- /scalalogging-slf4j/src/main/resources/LICENSE-2.0.txt: -------------------------------------------------------------------------------- 1 | 2 | Apache License 3 | Version 2.0, January 2004 4 | http://www.apache.org/licenses/ 5 | 6 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 7 | 8 | 1. Definitions. 9 | 10 | "License" shall mean the terms and conditions for use, reproduction, 11 | and distribution as defined by Sections 1 through 9 of this document. 12 | 13 | "Licensor" shall mean the copyright owner or entity authorized by 14 | the copyright owner that is granting the License. 15 | 16 | "Legal Entity" shall mean the union of the acting entity and all 17 | other entities that control, are controlled by, or are under common 18 | control with that entity. For the purposes of this definition, 19 | "control" means (i) the power, direct or indirect, to cause the 20 | direction or management of such entity, whether by contract or 21 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 22 | outstanding shares, or (iii) beneficial ownership of such entity. 23 | 24 | "You" (or "Your") shall mean an individual or Legal Entity 25 | exercising permissions granted by this License. 26 | 27 | "Source" form shall mean the preferred form for making modifications, 28 | including but not limited to software source code, documentation 29 | source, and configuration files. 30 | 31 | "Object" form shall mean any form resulting from mechanical 32 | transformation or translation of a Source form, including but 33 | not limited to compiled object code, generated documentation, 34 | and conversions to other media types. 35 | 36 | "Work" shall mean the work of authorship, whether in Source or 37 | Object form, made available under the License, as indicated by a 38 | copyright notice that is included in or attached to the work 39 | (an example is provided in the Appendix below). 40 | 41 | "Derivative Works" shall mean any work, whether in Source or Object 42 | form, that is based on (or derived from) the Work and for which the 43 | editorial revisions, annotations, elaborations, or other modifications 44 | represent, as a whole, an original work of authorship. For the purposes 45 | of this License, Derivative Works shall not include works that remain 46 | separable from, or merely link (or bind by name) to the interfaces of, 47 | the Work and Derivative Works thereof. 48 | 49 | "Contribution" shall mean any work of authorship, including 50 | the original version of the Work and any modifications or additions 51 | to that Work or Derivative Works thereof, that is intentionally 52 | submitted to Licensor for inclusion in the Work by the copyright owner 53 | or by an individual or Legal Entity authorized to submit on behalf of 54 | the copyright owner. For the purposes of this definition, "submitted" 55 | means any form of electronic, verbal, or written communication sent 56 | to the Licensor or its representatives, including but not limited to 57 | communication on electronic mailing lists, source code control systems, 58 | and issue tracking systems that are managed by, or on behalf of, the 59 | Licensor for the purpose of discussing and improving the Work, but 60 | excluding communication that is conspicuously marked or otherwise 61 | designated in writing by the copyright owner as "Not a Contribution." 62 | 63 | "Contributor" shall mean Licensor and any individual or Legal Entity 64 | on behalf of whom a Contribution has been received by Licensor and 65 | subsequently incorporated within the Work. 66 | 67 | 2. Grant of Copyright License. Subject to the terms and conditions of 68 | this License, each Contributor hereby grants to You a perpetual, 69 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 70 | copyright license to reproduce, prepare Derivative Works of, 71 | publicly display, publicly perform, sublicense, and distribute the 72 | Work and such Derivative Works in Source or Object form. 73 | 74 | 3. Grant of Patent License. Subject to the terms and conditions of 75 | this License, each Contributor hereby grants to You a perpetual, 76 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 77 | (except as stated in this section) patent license to make, have made, 78 | use, offer to sell, sell, import, and otherwise transfer the Work, 79 | where such license applies only to those patent claims licensable 80 | by such Contributor that are necessarily infringed by their 81 | Contribution(s) alone or by combination of their Contribution(s) 82 | with the Work to which such Contribution(s) was submitted. If You 83 | institute patent litigation against any entity (including a 84 | cross-claim or counterclaim in a lawsuit) alleging that the Work 85 | or a Contribution incorporated within the Work constitutes direct 86 | or contributory patent infringement, then any patent licenses 87 | granted to You under this License for that Work shall terminate 88 | as of the date such litigation is filed. 89 | 90 | 4. Redistribution. You may reproduce and distribute copies of the 91 | Work or Derivative Works thereof in any medium, with or without 92 | modifications, and in Source or Object form, provided that You 93 | meet the following conditions: 94 | 95 | (a) You must give any other recipients of the Work or 96 | Derivative Works a copy of this License; and 97 | 98 | (b) You must cause any modified files to carry prominent notices 99 | stating that You changed the files; and 100 | 101 | (c) You must retain, in the Source form of any Derivative Works 102 | that You distribute, all copyright, patent, trademark, and 103 | attribution notices from the Source form of the Work, 104 | excluding those notices that do not pertain to any part of 105 | the Derivative Works; and 106 | 107 | (d) If the Work includes a "NOTICE" text file as part of its 108 | distribution, then any Derivative Works that You distribute must 109 | include a readable copy of the attribution notices contained 110 | within such NOTICE file, excluding those notices that do not 111 | pertain to any part of the Derivative Works, in at least one 112 | of the following places: within a NOTICE text file distributed 113 | as part of the Derivative Works; within the Source form or 114 | documentation, if provided along with the Derivative Works; or, 115 | within a display generated by the Derivative Works, if and 116 | wherever such third-party notices normally appear. The contents 117 | of the NOTICE file are for informational purposes only and 118 | do not modify the License. You may add Your own attribution 119 | notices within Derivative Works that You distribute, alongside 120 | or as an addendum to the NOTICE text from the Work, provided 121 | that such additional attribution notices cannot be construed 122 | as modifying the License. 123 | 124 | You may add Your own copyright statement to Your modifications and 125 | may provide additional or different license terms and conditions 126 | for use, reproduction, or distribution of Your modifications, or 127 | for any such Derivative Works as a whole, provided Your use, 128 | reproduction, and distribution of the Work otherwise complies with 129 | the conditions stated in this License. 130 | 131 | 5. Submission of Contributions. Unless You explicitly state otherwise, 132 | any Contribution intentionally submitted for inclusion in the Work 133 | by You to the Licensor shall be under the terms and conditions of 134 | this License, without any additional terms or conditions. 135 | Notwithstanding the above, nothing herein shall supersede or modify 136 | the terms of any separate license agreement you may have executed 137 | with Licensor regarding such Contributions. 138 | 139 | 6. Trademarks. This License does not grant permission to use the trade 140 | names, trademarks, service marks, or product names of the Licensor, 141 | except as required for reasonable and customary use in describing the 142 | origin of the Work and reproducing the content of the NOTICE file. 143 | 144 | 7. Disclaimer of Warranty. Unless required by applicable law or 145 | agreed to in writing, Licensor provides the Work (and each 146 | Contributor provides its Contributions) on an "AS IS" BASIS, 147 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 148 | implied, including, without limitation, any warranties or conditions 149 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 150 | PARTICULAR PURPOSE. You are solely responsible for determining the 151 | appropriateness of using or redistributing the Work and assume any 152 | risks associated with Your exercise of permissions under this License. 153 | 154 | 8. Limitation of Liability. In no event and under no legal theory, 155 | whether in tort (including negligence), contract, or otherwise, 156 | unless required by applicable law (such as deliberate and grossly 157 | negligent acts) or agreed to in writing, shall any Contributor be 158 | liable to You for damages, including any direct, indirect, special, 159 | incidental, or consequential damages of any character arising as a 160 | result of this License or out of the use or inability to use the 161 | Work (including but not limited to damages for loss of goodwill, 162 | work stoppage, computer failure or malfunction, or any and all 163 | other commercial damages or losses), even if such Contributor 164 | has been advised of the possibility of such damages. 165 | 166 | 9. Accepting Warranty or Additional Liability. While redistributing 167 | the Work or Derivative Works thereof, You may choose to offer, 168 | and charge a fee for, acceptance of support, warranty, indemnity, 169 | or other liability obligations and/or rights consistent with this 170 | License. However, in accepting such obligations, You may act only 171 | on Your own behalf and on Your sole responsibility, not on behalf 172 | of any other Contributor, and only if You agree to indemnify, 173 | defend, and hold each Contributor harmless for any liability 174 | incurred by, or claims asserted against, such Contributor by reason 175 | of your accepting any such warranty or additional liability. 176 | 177 | END OF TERMS AND CONDITIONS 178 | 179 | APPENDIX: How to apply the Apache License to your work. 180 | 181 | To apply the Apache License to your work, attach the following 182 | boilerplate notice, with the fields enclosed by brackets "[]" 183 | replaced with your own identifying information. (Don't include 184 | the brackets!) The text should be enclosed in the appropriate 185 | comment syntax for the file format. We also recommend that a 186 | file or class name and description of purpose be included on the 187 | same "printed page" as the copyright notice for easier 188 | identification within third-party archives. 189 | 190 | Copyright [yyyy] [name of copyright owner] 191 | 192 | Licensed under the Apache License, Version 2.0 (the "License"); 193 | you may not use this file except in compliance with the License. 194 | You may obtain a copy of the License at 195 | 196 | http://www.apache.org/licenses/LICENSE-2.0 197 | 198 | Unless required by applicable law or agreed to in writing, software 199 | distributed under the License is distributed on an "AS IS" BASIS, 200 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 201 | See the License for the specific language governing permissions and 202 | limitations under the License. 203 | -------------------------------------------------------------------------------- /scalalogging-log4j/src/main/scala/com/typesafe/scalalogging/log4j/LoggerMacros.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 Typesafe Inc. 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package com.typesafe.scalalogging.log4j 18 | 19 | import org.apache.logging.log4j.Marker 20 | import scala.reflect.macros.Context 21 | 22 | private object LoggerMacros { 23 | 24 | type LoggerContext = Context { type PrefixType = Logger } 25 | 26 | // Fatal 27 | 28 | def fatalMessage(c: LoggerContext)(message: c.Expr[String]) = 29 | c.universe.reify( 30 | if (c.prefix.splice.underlying.isFatalEnabled) 31 | c.prefix.splice.underlying.fatal(message.splice) 32 | ) 33 | 34 | def fatalMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 35 | c.universe.reify( 36 | if (c.prefix.splice.underlying.isFatalEnabled) 37 | c.prefix.splice.underlying.fatal(marker.splice, message.splice) 38 | ) 39 | 40 | def fatalMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 41 | c.universe.reify( 42 | if (c.prefix.splice.underlying.isFatalEnabled) 43 | c.prefix.splice.underlying.fatal(message.splice, t.splice) 44 | ) 45 | 46 | def fatalMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 47 | c.universe.reify( 48 | if (c.prefix.splice.underlying.isFatalEnabled) 49 | c.prefix.splice.underlying.fatal(marker.splice, message.splice, t.splice) 50 | ) 51 | 52 | def fatalAnyRefMessage(c: LoggerContext)(message: c.Expr[AnyRef]) = 53 | c.universe.reify( 54 | if (c.prefix.splice.underlying.isFatalEnabled) 55 | c.prefix.splice.underlying.fatal(message.splice) 56 | ) 57 | 58 | def fatalMarkerAnyRefMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = 59 | c.universe.reify( 60 | if (c.prefix.splice.underlying.isFatalEnabled) 61 | c.prefix.splice.underlying.fatal(marker.splice, message.splice) 62 | ) 63 | 64 | def fatalAnyRefMessageThrowable(c: LoggerContext)(message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 65 | c.universe.reify( 66 | if (c.prefix.splice.underlying.isFatalEnabled) 67 | c.prefix.splice.underlying.fatal(message.splice, t.splice) 68 | ) 69 | 70 | def fatalMarkerAnyRefMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 71 | c.universe.reify( 72 | if (c.prefix.splice.underlying.isFatalEnabled) 73 | c.prefix.splice.underlying.fatal(marker.splice, message.splice, t.splice) 74 | ) 75 | 76 | def fatalMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 77 | logParams(c)(message, params, None)("fatal") 78 | 79 | def fatalMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 80 | logParams(c)(message, params, Some(marker))("fatal") 81 | 82 | // Error 83 | 84 | def errorMessage(c: LoggerContext)(message: c.Expr[String]) = 85 | c.universe.reify( 86 | if (c.prefix.splice.underlying.isErrorEnabled) 87 | c.prefix.splice.underlying.error(message.splice) 88 | ) 89 | 90 | def errorMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 91 | c.universe.reify( 92 | if (c.prefix.splice.underlying.isErrorEnabled) 93 | c.prefix.splice.underlying.error(marker.splice, message.splice) 94 | ) 95 | 96 | def errorMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 97 | c.universe.reify( 98 | if (c.prefix.splice.underlying.isErrorEnabled) 99 | c.prefix.splice.underlying.error(message.splice, t.splice) 100 | ) 101 | 102 | def errorMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 103 | c.universe.reify( 104 | if (c.prefix.splice.underlying.isErrorEnabled) 105 | c.prefix.splice.underlying.error(marker.splice, message.splice, t.splice) 106 | ) 107 | 108 | def errorAnyRefMessage(c: LoggerContext)(message: c.Expr[AnyRef]) = 109 | c.universe.reify( 110 | if (c.prefix.splice.underlying.isErrorEnabled) 111 | c.prefix.splice.underlying.error(message.splice) 112 | ) 113 | 114 | def errorMarkerAnyRefMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = 115 | c.universe.reify( 116 | if (c.prefix.splice.underlying.isErrorEnabled) 117 | c.prefix.splice.underlying.error(marker.splice, message.splice) 118 | ) 119 | 120 | def errorAnyRefMessageThrowable(c: LoggerContext)(message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 121 | c.universe.reify( 122 | if (c.prefix.splice.underlying.isErrorEnabled) 123 | c.prefix.splice.underlying.error(message.splice, t.splice) 124 | ) 125 | 126 | def errorMarkerAnyRefMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 127 | c.universe.reify( 128 | if (c.prefix.splice.underlying.isErrorEnabled) 129 | c.prefix.splice.underlying.error(marker.splice, message.splice, t.splice) 130 | ) 131 | 132 | def errorMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 133 | logParams(c)(message, params, None)("error") 134 | 135 | def errorMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 136 | logParams(c)(message, params, Some(marker))("error") 137 | 138 | // Warn 139 | 140 | def warnMessage(c: LoggerContext)(message: c.Expr[String]) = 141 | c.universe.reify( 142 | if (c.prefix.splice.underlying.isWarnEnabled) 143 | c.prefix.splice.underlying.warn(message.splice) 144 | ) 145 | 146 | def warnMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 147 | c.universe.reify( 148 | if (c.prefix.splice.underlying.isWarnEnabled) 149 | c.prefix.splice.underlying.warn(marker.splice, message.splice) 150 | ) 151 | 152 | def warnMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 153 | c.universe.reify( 154 | if (c.prefix.splice.underlying.isWarnEnabled) 155 | c.prefix.splice.underlying.warn(message.splice, t.splice) 156 | ) 157 | 158 | def warnMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 159 | c.universe.reify( 160 | if (c.prefix.splice.underlying.isWarnEnabled) 161 | c.prefix.splice.underlying.warn(marker.splice, message.splice, t.splice) 162 | ) 163 | 164 | def warnAnyRefMessage(c: LoggerContext)(message: c.Expr[AnyRef]) = 165 | c.universe.reify( 166 | if (c.prefix.splice.underlying.isWarnEnabled) 167 | c.prefix.splice.underlying.warn(message.splice) 168 | ) 169 | 170 | def warnMarkerAnyRefMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = 171 | c.universe.reify( 172 | if (c.prefix.splice.underlying.isWarnEnabled) 173 | c.prefix.splice.underlying.warn(marker.splice, message.splice) 174 | ) 175 | 176 | def warnAnyRefMessageThrowable(c: LoggerContext)(message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 177 | c.universe.reify( 178 | if (c.prefix.splice.underlying.isWarnEnabled) 179 | c.prefix.splice.underlying.warn(message.splice, t.splice) 180 | ) 181 | 182 | def warnMarkerAnyRefMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 183 | c.universe.reify( 184 | if (c.prefix.splice.underlying.isWarnEnabled) 185 | c.prefix.splice.underlying.warn(marker.splice, message.splice, t.splice) 186 | ) 187 | 188 | def warnMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 189 | logParams(c)(message, params, None)("warn") 190 | 191 | def warnMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 192 | logParams(c)(message, params, Some(marker))("warn") 193 | 194 | // Info 195 | 196 | def infoMessage(c: LoggerContext)(message: c.Expr[String]) = 197 | c.universe.reify( 198 | if (c.prefix.splice.underlying.isInfoEnabled) 199 | c.prefix.splice.underlying.info(message.splice) 200 | ) 201 | 202 | def infoMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 203 | c.universe.reify( 204 | if (c.prefix.splice.underlying.isInfoEnabled) 205 | c.prefix.splice.underlying.info(marker.splice, message.splice) 206 | ) 207 | 208 | def infoMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 209 | c.universe.reify( 210 | if (c.prefix.splice.underlying.isInfoEnabled) 211 | c.prefix.splice.underlying.info(message.splice, t.splice) 212 | ) 213 | 214 | def infoMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 215 | c.universe.reify( 216 | if (c.prefix.splice.underlying.isInfoEnabled) 217 | c.prefix.splice.underlying.info(marker.splice, message.splice, t.splice) 218 | ) 219 | 220 | def infoAnyRefMessage(c: LoggerContext)(message: c.Expr[AnyRef]) = 221 | c.universe.reify( 222 | if (c.prefix.splice.underlying.isInfoEnabled) 223 | c.prefix.splice.underlying.info(message.splice) 224 | ) 225 | 226 | def infoMarkerAnyRefMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = 227 | c.universe.reify( 228 | if (c.prefix.splice.underlying.isInfoEnabled) 229 | c.prefix.splice.underlying.info(marker.splice, message.splice) 230 | ) 231 | 232 | def infoAnyRefMessageThrowable(c: LoggerContext)(message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 233 | c.universe.reify( 234 | if (c.prefix.splice.underlying.isInfoEnabled) 235 | c.prefix.splice.underlying.info(message.splice, t.splice) 236 | ) 237 | 238 | def infoMarkerAnyRefMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 239 | c.universe.reify( 240 | if (c.prefix.splice.underlying.isInfoEnabled) 241 | c.prefix.splice.underlying.info(marker.splice, message.splice, t.splice) 242 | ) 243 | 244 | def infoMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 245 | logParams(c)(message, params, None)("info") 246 | 247 | def infoMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 248 | logParams(c)(message, params, Some(marker))("info") 249 | 250 | // Debug 251 | 252 | def debugMessage(c: LoggerContext)(message: c.Expr[String]) = 253 | c.universe.reify( 254 | if (c.prefix.splice.underlying.isDebugEnabled) 255 | c.prefix.splice.underlying.debug(message.splice) 256 | ) 257 | 258 | def debugMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 259 | c.universe.reify( 260 | if (c.prefix.splice.underlying.isDebugEnabled) 261 | c.prefix.splice.underlying.debug(marker.splice, message.splice) 262 | ) 263 | 264 | def debugMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 265 | c.universe.reify( 266 | if (c.prefix.splice.underlying.isDebugEnabled) 267 | c.prefix.splice.underlying.debug(message.splice, t.splice) 268 | ) 269 | 270 | def debugMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 271 | c.universe.reify( 272 | if (c.prefix.splice.underlying.isDebugEnabled) 273 | c.prefix.splice.underlying.debug(marker.splice, message.splice, t.splice) 274 | ) 275 | 276 | def debugAnyRefMessage(c: LoggerContext)(message: c.Expr[AnyRef]) = 277 | c.universe.reify( 278 | if (c.prefix.splice.underlying.isDebugEnabled) 279 | c.prefix.splice.underlying.debug(message.splice) 280 | ) 281 | 282 | def debugMarkerAnyRefMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = 283 | c.universe.reify( 284 | if (c.prefix.splice.underlying.isDebugEnabled) 285 | c.prefix.splice.underlying.debug(marker.splice, message.splice) 286 | ) 287 | 288 | def debugAnyRefMessageThrowable(c: LoggerContext)(message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 289 | c.universe.reify( 290 | if (c.prefix.splice.underlying.isDebugEnabled) 291 | c.prefix.splice.underlying.debug(message.splice, t.splice) 292 | ) 293 | 294 | def debugMarkerAnyRefMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 295 | c.universe.reify( 296 | if (c.prefix.splice.underlying.isDebugEnabled) 297 | c.prefix.splice.underlying.debug(marker.splice, message.splice, t.splice) 298 | ) 299 | 300 | def debugMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 301 | logParams(c)(message, params, None)("debug") 302 | 303 | def debugMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 304 | logParams(c)(message, params, Some(marker))("debug") 305 | 306 | // Trace 307 | 308 | def traceMessage(c: LoggerContext)(message: c.Expr[String]) = 309 | c.universe.reify( 310 | if (c.prefix.splice.underlying.isTraceEnabled) 311 | c.prefix.splice.underlying.trace(message.splice) 312 | ) 313 | 314 | def traceMarkerMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = 315 | c.universe.reify( 316 | if (c.prefix.splice.underlying.isTraceEnabled) 317 | c.prefix.splice.underlying.trace(marker.splice, message.splice) 318 | ) 319 | 320 | def traceMessageThrowable(c: LoggerContext)(message: c.Expr[String], t: c.Expr[Throwable]) = 321 | c.universe.reify( 322 | if (c.prefix.splice.underlying.isTraceEnabled) 323 | c.prefix.splice.underlying.trace(message.splice, t.splice) 324 | ) 325 | 326 | def traceMarkerMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], t: c.Expr[Throwable]) = 327 | c.universe.reify( 328 | if (c.prefix.splice.underlying.isTraceEnabled) 329 | c.prefix.splice.underlying.trace(marker.splice, message.splice, t.splice) 330 | ) 331 | 332 | def traceAnyRefMessage(c: LoggerContext)(message: c.Expr[AnyRef]) = 333 | c.universe.reify( 334 | if (c.prefix.splice.underlying.isTraceEnabled) 335 | c.prefix.splice.underlying.trace(message.splice) 336 | ) 337 | 338 | def traceMarkerAnyRefMessage(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = 339 | c.universe.reify( 340 | if (c.prefix.splice.underlying.isTraceEnabled) 341 | c.prefix.splice.underlying.trace(marker.splice, message.splice) 342 | ) 343 | 344 | def traceAnyRefMessageThrowable(c: LoggerContext)(message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 345 | c.universe.reify( 346 | if (c.prefix.splice.underlying.isTraceEnabled) 347 | c.prefix.splice.underlying.trace(message.splice, t.splice) 348 | ) 349 | 350 | def traceMarkerAnyRefMessageThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], t: c.Expr[Throwable]) = 351 | c.universe.reify( 352 | if (c.prefix.splice.underlying.isTraceEnabled) 353 | c.prefix.splice.underlying.trace(marker.splice, message.splice, t.splice) 354 | ) 355 | 356 | def traceMessageParams(c: LoggerContext)(message: c.Expr[String], params: c.Expr[AnyRef]*) = 357 | logParams(c)(message, params, None)("trace") 358 | 359 | def traceMarkerMessageParams(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], params: c.Expr[AnyRef]*) = 360 | logParams(c)(message, params, Some(marker))("trace") 361 | 362 | // Common 363 | 364 | private def logParams( 365 | c: LoggerContext)( 366 | message: c.Expr[String], 367 | params: Seq[c.Expr[AnyRef]], 368 | marker: Option[c.Expr[Marker]])( 369 | level: String) = { 370 | import c.universe._ 371 | val isEnabled = Select( 372 | Select(c.prefix.tree, newTermName("underlying")), 373 | newTermName(s"is${level.head.toUpper +: level.tail}Enabled") 374 | ) 375 | val log = Apply( 376 | Select(Select(c.prefix.tree, newTermName("underlying")), newTermName(level)), 377 | marker.foldRight(message.tree +: (params map (_.tree)).toList)(_.tree +: _) 378 | ) 379 | c.Expr(If(isEnabled, log, Literal(Constant(())))) 380 | } 381 | } 382 | -------------------------------------------------------------------------------- /scalalogging-log4j-test/src/test/scala/com/typesafe/scalalogging/slf4j/Log4jLoggerSpec.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 Copyright 2012 Typesafe Inc. 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package com.typesafe.scalalogging.log4j 18 | 19 | import org.apache.logging.log4j.{ Logger => Underlying, MarkerManager } 20 | import org.specs2.mock.Mockito 21 | import org.specs2.mutable.Specification 22 | 23 | object Log4jLoggerSpec extends Specification with Mockito { 24 | 25 | private val Message = "String message!" 26 | 27 | private val AnyRefMessage = new AnyRef 28 | 29 | private val Throwable = new Exception("Exception") 30 | 31 | private val Marker = MarkerManager getMarker "Marker" 32 | 33 | private val Params = List("1", "2", new java.util.Date(3)) 34 | 35 | "Calling fatal" should { 36 | "not call the underlying logger if level not enabled" in { 37 | val underlying = mock[Underlying] 38 | underlying.isFatalEnabled returns false 39 | val logger = Logger(underlying) 40 | logger.fatal(Message) 41 | there was no(underlying).fatal(Message) 42 | logger.fatal(Marker, Message) 43 | there was no(underlying).fatal(Marker, Message) 44 | logger.fatal(Message, Throwable) 45 | there was no(underlying).fatal(Message, Throwable) 46 | logger.fatal(Marker, Message, Throwable) 47 | there was no(underlying).fatal(Marker, Message, Throwable) 48 | logger.fatal(AnyRefMessage) 49 | there was no(underlying).fatal(AnyRefMessage) 50 | logger.fatal(Marker, AnyRefMessage) 51 | there was no(underlying).fatal(Marker, AnyRefMessage) 52 | logger.fatal(AnyRefMessage, Throwable) 53 | there was no(underlying).fatal(AnyRefMessage, Throwable) 54 | logger.fatal(Marker, AnyRefMessage, Throwable) 55 | there was no(underlying).fatal(Marker, AnyRefMessage, Throwable) 56 | logger.fatal(Message, Params: _*) 57 | there was no(underlying).fatal(Message, Params: _*) 58 | logger.fatal(Marker, Message, Params: _*) 59 | there was no(underlying).fatal(Marker, Message, Params: _*) 60 | } 61 | "call the underlying logger if level enabled" in { 62 | val underlying = mock[Underlying] 63 | underlying.isFatalEnabled returns true 64 | val logger = Logger(underlying) 65 | logger.fatal(Message) 66 | there was one(underlying).fatal(Message) 67 | logger.fatal(Marker, Message) 68 | there was one(underlying).fatal(Marker, Message) 69 | logger.fatal(Message, Throwable) 70 | there was one(underlying).fatal(Message, Throwable) 71 | logger.fatal(Marker, Message, Throwable) 72 | there was one(underlying).fatal(Marker, Message, Throwable) 73 | logger.fatal(AnyRefMessage) 74 | there was one(underlying).fatal(AnyRefMessage) 75 | logger.fatal(Marker, AnyRefMessage) 76 | there was one(underlying).fatal(Marker, AnyRefMessage) 77 | logger.fatal(AnyRefMessage, Throwable) 78 | there was one(underlying).fatal(AnyRefMessage, Throwable) 79 | logger.fatal(Marker, AnyRefMessage, Throwable) 80 | there was one(underlying).fatal(Marker, AnyRefMessage, Throwable) 81 | logger.fatal(Message, Params: _*) 82 | there was one(underlying).fatal(Message, Params: _*) 83 | logger.fatal(Marker, Message, Params: _*) 84 | there was one(underlying).fatal(Marker, Message, Params: _*) 85 | } 86 | } 87 | 88 | "Calling error" should { 89 | "not call the underlying logger if level not enabled" in { 90 | val underlying = mock[Underlying] 91 | underlying.isErrorEnabled returns false 92 | val logger = Logger(underlying) 93 | logger.error(Message) 94 | there was no(underlying).error(Message) 95 | logger.error(Marker, Message) 96 | there was no(underlying).error(Marker, Message) 97 | logger.error(Message, Throwable) 98 | there was no(underlying).error(Message, Throwable) 99 | logger.error(Marker, Message, Throwable) 100 | there was no(underlying).error(Marker, Message, Throwable) 101 | logger.error(AnyRefMessage) 102 | there was no(underlying).error(AnyRefMessage) 103 | logger.error(Marker, AnyRefMessage) 104 | there was no(underlying).error(Marker, AnyRefMessage) 105 | logger.error(AnyRefMessage, Throwable) 106 | there was no(underlying).error(AnyRefMessage, Throwable) 107 | logger.error(Marker, AnyRefMessage, Throwable) 108 | there was no(underlying).error(Marker, AnyRefMessage, Throwable) 109 | logger.error(Message, Params: _*) 110 | there was no(underlying).error(Message, Params: _*) 111 | logger.error(Marker, Message, Params: _*) 112 | there was no(underlying).error(Marker, Message, Params: _*) 113 | } 114 | "call the underlying logger if level enabled" in { 115 | val underlying = mock[Underlying] 116 | underlying.isErrorEnabled returns true 117 | val logger = Logger(underlying) 118 | logger.error(Message) 119 | there was one(underlying).error(Message) 120 | logger.error(Marker, Message) 121 | there was one(underlying).error(Marker, Message) 122 | logger.error(Message, Throwable) 123 | there was one(underlying).error(Message, Throwable) 124 | logger.error(Marker, Message, Throwable) 125 | there was one(underlying).error(Marker, Message, Throwable) 126 | logger.error(AnyRefMessage) 127 | there was one(underlying).error(AnyRefMessage) 128 | logger.error(Marker, AnyRefMessage) 129 | there was one(underlying).error(Marker, AnyRefMessage) 130 | logger.error(AnyRefMessage, Throwable) 131 | there was one(underlying).error(AnyRefMessage, Throwable) 132 | logger.error(Marker, AnyRefMessage, Throwable) 133 | there was one(underlying).error(Marker, AnyRefMessage, Throwable) 134 | logger.error(Message, Params: _*) 135 | there was one(underlying).error(Message, Params: _*) 136 | logger.error(Marker, Message, Params: _*) 137 | there was one(underlying).error(Marker, Message, Params: _*) 138 | } 139 | } 140 | 141 | "Calling warn" should { 142 | "not call the underlying logger if level not enabled" in { 143 | val underlying = mock[Underlying] 144 | underlying.isWarnEnabled returns false 145 | val logger = Logger(underlying) 146 | logger.warn(Message) 147 | there was no(underlying).warn(Message) 148 | logger.warn(Marker, Message) 149 | there was no(underlying).warn(Marker, Message) 150 | logger.warn(Message, Throwable) 151 | there was no(underlying).warn(Message, Throwable) 152 | logger.warn(Marker, Message, Throwable) 153 | there was no(underlying).warn(Marker, Message, Throwable) 154 | logger.warn(AnyRefMessage) 155 | there was no(underlying).warn(AnyRefMessage) 156 | logger.warn(Marker, AnyRefMessage) 157 | there was no(underlying).warn(Marker, AnyRefMessage) 158 | logger.warn(AnyRefMessage, Throwable) 159 | there was no(underlying).warn(AnyRefMessage, Throwable) 160 | logger.warn(Marker, AnyRefMessage, Throwable) 161 | there was no(underlying).warn(Marker, AnyRefMessage, Throwable) 162 | logger.warn(Message, Params: _*) 163 | there was no(underlying).warn(Message, Params: _*) 164 | logger.warn(Marker, Message, Params: _*) 165 | there was no(underlying).warn(Marker, Message, Params: _*) 166 | } 167 | "call the underlying logger if level enabled" in { 168 | val underlying = mock[Underlying] 169 | underlying.isWarnEnabled returns true 170 | val logger = Logger(underlying) 171 | logger.warn(Message) 172 | there was one(underlying).warn(Message) 173 | logger.warn(Marker, Message) 174 | there was one(underlying).warn(Marker, Message) 175 | logger.warn(Message, Throwable) 176 | there was one(underlying).warn(Message, Throwable) 177 | logger.warn(Marker, Message, Throwable) 178 | there was one(underlying).warn(Marker, Message, Throwable) 179 | logger.warn(AnyRefMessage) 180 | there was one(underlying).warn(AnyRefMessage) 181 | logger.warn(Marker, AnyRefMessage) 182 | there was one(underlying).warn(Marker, AnyRefMessage) 183 | logger.warn(AnyRefMessage, Throwable) 184 | there was one(underlying).warn(AnyRefMessage, Throwable) 185 | logger.warn(Marker, AnyRefMessage, Throwable) 186 | there was one(underlying).warn(Marker, AnyRefMessage, Throwable) 187 | logger.warn(Message, Params: _*) 188 | there was one(underlying).warn(Message, Params: _*) 189 | logger.warn(Marker, Message, Params: _*) 190 | there was one(underlying).warn(Marker, Message, Params: _*) 191 | } 192 | } 193 | 194 | "Calling info" should { 195 | "not call the underlying logger if level not enabled" in { 196 | val underlying = mock[Underlying] 197 | underlying.isInfoEnabled returns false 198 | val logger = Logger(underlying) 199 | logger.info(Message) 200 | there was no(underlying).info(Message) 201 | logger.info(Marker, Message) 202 | there was no(underlying).info(Marker, Message) 203 | logger.info(Message, Throwable) 204 | there was no(underlying).info(Message, Throwable) 205 | logger.info(Marker, Message, Throwable) 206 | there was no(underlying).info(Marker, Message, Throwable) 207 | logger.info(AnyRefMessage) 208 | there was no(underlying).info(AnyRefMessage) 209 | logger.info(Marker, AnyRefMessage) 210 | there was no(underlying).info(Marker, AnyRefMessage) 211 | logger.info(AnyRefMessage, Throwable) 212 | there was no(underlying).info(AnyRefMessage, Throwable) 213 | logger.info(Marker, AnyRefMessage, Throwable) 214 | there was no(underlying).info(Marker, AnyRefMessage, Throwable) 215 | logger.info(Message, Params: _*) 216 | there was no(underlying).info(Message, Params: _*) 217 | logger.info(Marker, Message, Params: _*) 218 | there was no(underlying).info(Marker, Message, Params: _*) 219 | } 220 | "call the underlying logger if level enabled" in { 221 | val underlying = mock[Underlying] 222 | underlying.isInfoEnabled returns true 223 | val logger = Logger(underlying) 224 | logger.info(Message) 225 | there was one(underlying).info(Message) 226 | logger.info(Marker, Message) 227 | there was one(underlying).info(Marker, Message) 228 | logger.info(Message, Throwable) 229 | there was one(underlying).info(Message, Throwable) 230 | logger.info(Marker, Message, Throwable) 231 | there was one(underlying).info(Marker, Message, Throwable) 232 | logger.info(AnyRefMessage) 233 | there was one(underlying).info(AnyRefMessage) 234 | logger.info(Marker, AnyRefMessage) 235 | there was one(underlying).info(Marker, AnyRefMessage) 236 | logger.info(AnyRefMessage, Throwable) 237 | there was one(underlying).info(AnyRefMessage, Throwable) 238 | logger.info(Marker, AnyRefMessage, Throwable) 239 | there was one(underlying).info(Marker, AnyRefMessage, Throwable) 240 | logger.info(Message, Params: _*) 241 | there was one(underlying).info(Message, Params: _*) 242 | logger.info(Marker, Message, Params: _*) 243 | there was one(underlying).info(Marker, Message, Params: _*) 244 | } 245 | } 246 | 247 | "Calling debug" should { 248 | "not call the underlying logger if level not enabled" in { 249 | val underlying = mock[Underlying] 250 | underlying.isDebugEnabled returns false 251 | val logger = Logger(underlying) 252 | logger.debug(Message) 253 | there was no(underlying).debug(Message) 254 | logger.debug(Marker, Message) 255 | there was no(underlying).debug(Marker, Message) 256 | logger.debug(Message, Throwable) 257 | there was no(underlying).debug(Message, Throwable) 258 | logger.debug(Marker, Message, Throwable) 259 | there was no(underlying).debug(Marker, Message, Throwable) 260 | logger.debug(AnyRefMessage) 261 | there was no(underlying).debug(AnyRefMessage) 262 | logger.debug(Marker, AnyRefMessage) 263 | there was no(underlying).debug(Marker, AnyRefMessage) 264 | logger.debug(AnyRefMessage, Throwable) 265 | there was no(underlying).debug(AnyRefMessage, Throwable) 266 | logger.debug(Marker, AnyRefMessage, Throwable) 267 | there was no(underlying).debug(Marker, AnyRefMessage, Throwable) 268 | logger.debug(Message, Params: _*) 269 | there was no(underlying).debug(Message, Params: _*) 270 | logger.debug(Marker, Message, Params: _*) 271 | there was no(underlying).debug(Marker, Message, Params: _*) 272 | } 273 | "call the underlying logger if level enabled" in { 274 | val underlying = mock[Underlying] 275 | underlying.isDebugEnabled returns true 276 | val logger = Logger(underlying) 277 | logger.debug(Message) 278 | there was one(underlying).debug(Message) 279 | logger.debug(Marker, Message) 280 | there was one(underlying).debug(Marker, Message) 281 | logger.debug(Message, Throwable) 282 | there was one(underlying).debug(Message, Throwable) 283 | logger.debug(Marker, Message, Throwable) 284 | there was one(underlying).debug(Marker, Message, Throwable) 285 | logger.debug(AnyRefMessage) 286 | there was one(underlying).debug(AnyRefMessage) 287 | logger.debug(Marker, AnyRefMessage) 288 | there was one(underlying).debug(Marker, AnyRefMessage) 289 | logger.debug(AnyRefMessage, Throwable) 290 | there was one(underlying).debug(AnyRefMessage, Throwable) 291 | logger.debug(Marker, AnyRefMessage, Throwable) 292 | there was one(underlying).debug(Marker, AnyRefMessage, Throwable) 293 | logger.debug(Message, Params: _*) 294 | there was one(underlying).debug(Message, Params: _*) 295 | logger.debug(Marker, Message, Params: _*) 296 | there was one(underlying).debug(Marker, Message, Params: _*) 297 | } 298 | } 299 | 300 | "Calling trace" should { 301 | "not call the underlying logger if level not enabled" in { 302 | val underlying = mock[Underlying] 303 | underlying.isTraceEnabled returns false 304 | val logger = Logger(underlying) 305 | logger.trace(Message) 306 | there was no(underlying).trace(Message) 307 | logger.trace(Marker, Message) 308 | there was no(underlying).trace(Marker, Message) 309 | logger.trace(Message, Throwable) 310 | there was no(underlying).trace(Message, Throwable) 311 | logger.trace(Marker, Message, Throwable) 312 | there was no(underlying).trace(Marker, Message, Throwable) 313 | logger.trace(AnyRefMessage) 314 | there was no(underlying).trace(AnyRefMessage) 315 | logger.trace(Marker, AnyRefMessage) 316 | there was no(underlying).trace(Marker, AnyRefMessage) 317 | logger.trace(AnyRefMessage, Throwable) 318 | there was no(underlying).trace(AnyRefMessage, Throwable) 319 | logger.trace(Marker, AnyRefMessage, Throwable) 320 | there was no(underlying).trace(Marker, AnyRefMessage, Throwable) 321 | logger.trace(Message, Params: _*) 322 | there was no(underlying).trace(Message, Params: _*) 323 | logger.trace(Marker, Message, Params: _*) 324 | there was no(underlying).trace(Marker, Message, Params: _*) 325 | } 326 | "call the underlying logger if level enabled" in { 327 | val underlying = mock[Underlying] 328 | underlying.isTraceEnabled returns true 329 | val logger = Logger(underlying) 330 | logger.trace(Message) 331 | there was one(underlying).trace(Message) 332 | logger.trace(Marker, Message) 333 | there was one(underlying).trace(Marker, Message) 334 | logger.trace(Message, Throwable) 335 | there was one(underlying).trace(Message, Throwable) 336 | logger.trace(Marker, Message, Throwable) 337 | there was one(underlying).trace(Marker, Message, Throwable) 338 | logger.trace(AnyRefMessage) 339 | there was one(underlying).trace(AnyRefMessage) 340 | logger.trace(Marker, AnyRefMessage) 341 | there was one(underlying).trace(Marker, AnyRefMessage) 342 | logger.trace(AnyRefMessage, Throwable) 343 | there was one(underlying).trace(AnyRefMessage, Throwable) 344 | logger.trace(Marker, AnyRefMessage, Throwable) 345 | there was one(underlying).trace(Marker, AnyRefMessage, Throwable) 346 | logger.trace(Message, Params: _*) 347 | there was one(underlying).trace(Message, Params: _*) 348 | logger.trace(Marker, Message, Params: _*) 349 | there was one(underlying).trace(Marker, Message, Params: _*) 350 | } 351 | } 352 | } 353 | --------------------------------------------------------------------------------