Repository: logging-log4j2 Updated Branches: refs/heads/LOG4J-1181 a14bdc96e -> 816c92889
Support Object (AnyRef) messages in Scala Logger Project: http://git-wip-us.apache.org/repos/asf/logging-log4j2/repo Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j2/commit/816c9288 Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j2/tree/816c9288 Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j2/diff/816c9288 Branch: refs/heads/LOG4J-1181 Commit: 816c92889b5128d15cbf756991af1d01f2d1a45d Parents: a14bdc9 Author: Mikael Ståldal <[email protected]> Authored: Thu Jun 9 15:36:54 2016 +0200 Committer: Mikael Ståldal <[email protected]> Committed: Thu Jun 9 15:36:54 2016 +0200 ---------------------------------------------------------------------- .../org/apache/logging/log4j/scala/Logger.scala | 157 ++++++++++++--- .../logging/log4j/scala/LoggerMacro.scala | 194 +++++++++++++----- .../apache/logging/log4j/scala/LoggerTest.scala | 165 +++++++++++----- .../org/apache/logging/log4j/scala/Logger.scala | 157 ++++++++++++--- .../logging/log4j/scala/LoggerMacro.scala | 198 ++++++++++++++----- .../apache/logging/log4j/scala/LoggerTest.scala | 165 +++++++++++----- 6 files changed, 798 insertions(+), 238 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/816c9288/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala index 0ce7765..a27c1fe 100644 --- a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala +++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala @@ -29,171 +29,262 @@ class Logger(val delegate: ExtendedLogger) { def fatal(marker: Marker, message: Message): Unit = macro LoggerMacro.fatalMarkerMsg - def fatal(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.fatalMarkerMsgThrowable - def fatal(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.fatalMarkerString + def fatal(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.fatalMarkerObject + + def fatal(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.fatalMarkerMsgThrowable + def fatal(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.fatalMarkerStringThrowable + def fatal(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.fatalMarkerObjectThrowable + def fatal(message: Message): Unit = macro LoggerMacro.fatalMsg def fatal(message: CharSequence): Unit = macro LoggerMacro.fatalString - + + def fatal(message: AnyRef): Unit = + macro LoggerMacro.fatalObject + def fatal(message: Message, cause: Throwable): Unit = macro LoggerMacro.fatalMsgThrowable def fatal(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.fatalStringThrowable + def fatal(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.fatalObjectThrowable + + def error(marker: Marker, message: Message): Unit = macro LoggerMacro.errorMarkerMsg - def error(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.errorMarkerMsgThrowable - def error(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.errorMarkerString + def error(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.errorMarkerObject + + def error(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.errorMarkerMsgThrowable + def error(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.errorMarkerStringThrowable + def error(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.errorMarkerObjectThrowable + def error(message: Message): Unit = macro LoggerMacro.errorMsg def error(message: CharSequence): Unit = macro LoggerMacro.errorString + def error(message: AnyRef): Unit = + macro LoggerMacro.errorObject + def error(message: Message, cause: Throwable): Unit = macro LoggerMacro.errorMsgThrowable def error(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.errorStringThrowable + def error(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.errorObjectThrowable + + def warn(marker: Marker, message: Message): Unit = macro LoggerMacro.warnMarkerMsg - def warn(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.warnMarkerMsgThrowable - def warn(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.warnMarkerString + def warn(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.warnMarkerObject + + def warn(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.warnMarkerMsgThrowable + def warn(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.warnMarkerStringThrowable + def warn(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.warnMarkerObjectThrowable + def warn(message: Message): Unit = macro LoggerMacro.warnMsg def warn(message: CharSequence): Unit = macro LoggerMacro.warnString + def warn(message: AnyRef): Unit = + macro LoggerMacro.warnObject + def warn(message: Message, cause: Throwable): Unit = macro LoggerMacro.warnMsgThrowable def warn(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.warnStringThrowable + def warn(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.warnObjectThrowable + + def info(marker: Marker, message: Message): Unit = macro LoggerMacro.infoMarkerMsg - def info(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.infoMarkerMsgThrowable - def info(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.infoMarkerString + def info(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.infoMarkerObject + + def info(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.infoMarkerMsgThrowable + def info(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.infoMarkerStringThrowable + def info(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.infoMarkerObjectThrowable + def info(message: Message): Unit = macro LoggerMacro.infoMsg def info(message: CharSequence): Unit = macro LoggerMacro.infoString + def info(message: AnyRef): Unit = + macro LoggerMacro.infoObject + def info(message: Message, cause: Throwable): Unit = macro LoggerMacro.infoMsgThrowable def info(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.infoStringThrowable + def info(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.infoObjectThrowable + + def debug(marker: Marker, message: Message): Unit = macro LoggerMacro.debugMarkerMsg - def debug(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.debugMarkerMsgThrowable - def debug(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.debugMarkerString + def debug(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.debugMarkerObject + + def debug(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.debugMarkerMsgThrowable + def debug(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.debugMarkerStringThrowable + def debug(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.debugMarkerObjectThrowable + def debug(message: Message): Unit = macro LoggerMacro.debugMsg def debug(message: CharSequence): Unit = macro LoggerMacro.debugString + def debug(message: AnyRef): Unit = + macro LoggerMacro.debugObject + def debug(message: Message, cause: Throwable): Unit = macro LoggerMacro.debugMsgThrowable def debug(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.debugStringThrowable + def debug(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.debugObjectThrowable + + def trace(marker: Marker, message: Message): Unit = macro LoggerMacro.traceMarkerMsg - def trace(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.traceMarkerMsgThrowable - def trace(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.traceMarkerString + def trace(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.traceMarkerObject + + def trace(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.traceMarkerMsgThrowable + def trace(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.traceMarkerStringThrowable + def trace(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.traceMarkerObjectThrowable + def trace(message: Message): Unit = macro LoggerMacro.traceMsg def trace(message: CharSequence): Unit = macro LoggerMacro.traceString + def trace(message: AnyRef): Unit = + macro LoggerMacro.traceObject + def trace(message: Message, cause: Throwable): Unit = macro LoggerMacro.traceMsgThrowable def trace(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.traceStringThrowable + def trace(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.traceObjectThrowable + + def log(level: Level, marker: Marker, message: Message): Unit = macro LoggerMacro.logMarkerMsg - def log(level: Level, marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.logMarkerMsgThrowable - def log(level: Level, marker: Marker, message: CharSequence): Unit = macro LoggerMacro.logMarkerString + def log(level: Level, marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.logMarkerObject + + def log(level: Level, marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.logMarkerMsgThrowable + def log(level: Level, marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.logMarkerStringThrowable - + + def log(level: Level, marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.logMarkerObjectThrowable + def log(level: Level, message: Message): Unit = macro LoggerMacro.logMsg def log(level: Level, message: CharSequence): Unit = macro LoggerMacro.logString + def log(level: Level, message: AnyRef): Unit = + macro LoggerMacro.logObject + def log(level: Level, message: Message, cause: Throwable): Unit = macro LoggerMacro.logMsgThrowable def log(level: Level, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.logStringThrowable + def log(level: Level, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.logObjectThrowable + + def isEnabled(level: Level): Boolean = delegate.isEnabled(level) def isEnabled(level: Level, marker: Marker): Boolean = delegate.isEnabled(level, marker) @@ -201,11 +292,11 @@ class Logger(val delegate: ExtendedLogger) { def entry(params: AnyRef*): Unit = delegate.entry(params) // TODO would be useful to have this as a macro to avoid varargs array creation - def entry(): Unit = delegate.entry() + def traceEntry(): Unit = delegate.traceEntry() - def exit[R](result: R): R = delegate.exit(result) + def traceExit[R](result: R): R = delegate.traceExit(result) - def exit(): Unit = delegate.exit() + def traceExit(): Unit = delegate.traceExit() def throwing[T <: Throwable](t: T): T = delegate.throwing(t) @@ -249,4 +340,18 @@ class Logger(val delegate: ExtendedLogger) { delegate.logMessage(FQCN, level, marker, delegate.getMessageFactory.newMessage(message), cause) } + /** Always logs a message at the specified level. It is the responsibility of the caller to ensure the specified + * level is enabled. + * + * Should normally not be used directly from application code, but needs to be public for access by macros. + * + * @param level log level + * @param marker marker or `null` + * @param message message + * @param cause cause or `null` + */ + def logMessage(level: Level, marker: Marker, message: AnyRef, cause: Throwable): Unit = { + delegate.logMessage(FQCN, level, marker, delegate.getMessageFactory.newMessage(message), cause) + } + } http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/816c9288/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala index e18679f..7775bfc 100644 --- a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala +++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala @@ -27,149 +27,227 @@ private object LoggerMacro { type LoggerContext = Context { type PrefixType = Logger } def fatalMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = - logMarkerMsg(c)(c.universe.reify(Level.WARN), marker, message) - - def fatalMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + logMarkerMsg(c)(c.universe.reify(Level.FATAL), marker, message) def fatalMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.FATAL), marker, message) + def fatalMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.FATAL), marker, message) + + def fatalMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + def fatalMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + def fatalMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + def fatalMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.FATAL), message) - def fatalMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.FATAL), message, cause) - def fatalString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.FATAL), message) + def fatalObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.FATAL), message) + + def fatalMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.FATAL), message, cause) + def fatalStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.FATAL), message, cause) + def fatalObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.FATAL), message, cause) + + def errorMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = logMarkerMsg(c)(c.universe.reify(Level.ERROR), marker, message) - def errorMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) - def errorMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.ERROR), marker, message) + def errorMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.ERROR), marker, message) + + def errorMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) + def errorMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) + def errorMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) + def errorMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.ERROR), message) - def errorMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.ERROR), message, cause) - def errorString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.ERROR), message) + def errorObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.ERROR), message) + + def errorMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.ERROR), message, cause) + def errorStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.ERROR), message, cause) + def errorObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.ERROR), message, cause) + + def warnMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = logMarkerMsg(c)(c.universe.reify(Level.WARN), marker, message) - def warnMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) - def warnMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.WARN), marker, message) + def warnMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.WARN), marker, message) + + def warnMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) + def warnMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) + def warnMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) + def warnMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.WARN), message) - def warnMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.WARN), message, cause) - def warnString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.WARN), message) + def warnObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.WARN), message) + + def warnMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.WARN), message, cause) + def warnStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.WARN), message, cause) + def warnObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.WARN), message, cause) + + def infoMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = logMarkerMsg(c)(c.universe.reify(Level.INFO), marker, message) - def infoMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) - def infoMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.INFO), marker, message) + def infoMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.INFO), marker, message) + + def infoMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) + def infoMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) + def infoMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) + def infoMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.INFO), message) - def infoMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.INFO), message, cause) - def infoString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.INFO), message) + def infoObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.INFO), message) + + def infoMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.INFO), message, cause) + def infoStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.INFO), message, cause) + def infoObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.INFO), message, cause) + + def debugMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = logMarkerMsg(c)(c.universe.reify(Level.DEBUG), marker, message) - def debugMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) - def debugMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.DEBUG), marker, message) + def debugMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.DEBUG), marker, message) + + def debugMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) + def debugMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) + def debugMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) + def debugMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.DEBUG), message) - def debugMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) - def debugString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.DEBUG), message) + def debugObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.DEBUG), message) + + def debugMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) + def debugStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) + def debugObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) + + def traceMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = logMarkerMsg(c)(c.universe.reify(Level.TRACE), marker, message) - def traceMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) - def traceMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.TRACE), marker, message) + def traceMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.TRACE), marker, message) + + def traceMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) + def traceMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) + def traceMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) + def traceMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.TRACE), message) - def traceMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.TRACE), message, cause) - def traceString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.TRACE), message) + def traceObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.TRACE), message) + + def traceMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.TRACE), message, cause) + def traceStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.TRACE), message, cause) + def traceObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.TRACE), message, cause) + + def logMarkerMsg(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[Message]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice, marker.splice)) { @@ -177,19 +255,26 @@ private object LoggerMacro { } ) - def logMarkerMsgThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + def logMarkerString(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[CharSequence]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice, marker.splice)) { - c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, cause.splice) + c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, null) } ) - def logMarkerString(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[CharSequence]) = + def logMarkerObject(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[AnyRef]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice, marker.splice)) { c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, null) } ) + + def logMarkerMsgThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice, marker.splice)) { + c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, cause.splice) + } + ) def logMarkerStringThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = c.universe.reify( @@ -198,6 +283,13 @@ private object LoggerMacro { } ) + def logMarkerObjectThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice, marker.splice)) { + c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, cause.splice) + } + ) + def logMsg(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[Message]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice)) { @@ -205,20 +297,27 @@ private object LoggerMacro { } ) - def logMsgThrowable(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[Message], cause: c.Expr[Throwable]) = + def logString(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[CharSequence]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice)) { - c.prefix.splice.logMessage(level.splice, null, message.splice, cause.splice) + c.prefix.splice.logMessage(level.splice, null, message.splice, null) } ) - def logString(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[CharSequence]) = + def logObject(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[AnyRef]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice)) { c.prefix.splice.logMessage(level.splice, null, message.splice, null) } ) - + + def logMsgThrowable(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[Message], cause: c.Expr[Throwable]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice)) { + c.prefix.splice.logMessage(level.splice, null, message.splice, cause.splice) + } + ) + def logStringThrowable(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice)) { @@ -226,4 +325,11 @@ private object LoggerMacro { } ) + def logObjectThrowable(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice)) { + c.prefix.splice.logMessage(level.splice, null, message.splice, cause.splice) + } + ) + } http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/816c9288/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala index 0979cf2..75d0a13 100644 --- a/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala +++ b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala @@ -26,11 +26,14 @@ import org.scalatest.junit.JUnitRunner import org.scalatest.mock.MockitoSugar import org.scalatest.{FunSuite, Matchers} +case class Custom(i: Int) + @RunWith(classOf[JUnitRunner]) class LoggerTest extends FunSuite with Matchers with MockitoSugar { - val stringMsg = "string msg" val msg = new ParameterizedMessage("msg {}", 17) + val stringMsg = "string msg" + val objectMsg = Custom(17) val cause = new RuntimeException("cause") val marker = MarkerManager.getMarker("marker") @@ -130,35 +133,100 @@ class LoggerTest extends FunSuite with Matchers with MockitoSugar { verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with String message") { + + test("log enabled with Message message and Marker") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, stringMsg) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) + logger.log(Level.INFO, marker, msg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null)) } - test("log disabled with String message") { + test("log disabled with Message message and Marker") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, stringMsg) + logger.log(Level.INFO, marker, msg) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with String message and cause") { + test("log enabled with String message and Marker") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, stringMsg, cause) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) + logger.log(Level.INFO, marker, stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) } - test("log disabled with String message and cause") { + test("log disabled with String message and Marker") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, stringMsg, cause) + logger.log(Level.INFO, marker, stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Object message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, objectMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) + } + + test("log disabled with Object message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, objectMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Message message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause)) + } + + test("log disabled with Message message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with String message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) + } + + test("log disabled with String message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Object message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, objectMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) + } + + test("log disabled with Object message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, objectMsg, cause) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } @@ -178,86 +246,87 @@ class LoggerTest extends FunSuite with Matchers with MockitoSugar { verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with Message message and cause") { + test("log enabled with String message") { val mockLogger = buildMockLogger when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, msg, cause) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause)) + logger.log(Level.INFO, stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) } - test("log disabled with Message message and cause") { + test("log disabled with String message") { val mockLogger = buildMockLogger when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, msg, cause) + logger.log(Level.INFO, stringMsg) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with String message and Marker") { + test("log enabled with Object message") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, stringMsg) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) + logger.log(Level.INFO, objectMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) } - test("log disabled with String message and Marker") { + test("log disabled with Object message") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, stringMsg) + logger.log(Level.INFO, objectMsg) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with String message and cause and Marker") { + test("log enabled with Message message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, stringMsg, cause) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) + logger.log(Level.INFO, msg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause)) } - test("log disabled with String message and cause and Marker") { + test("log disabled with Message message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, stringMsg, cause) + logger.log(Level.INFO, msg, cause) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with Message message and Marker") { + test("log enabled with String message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, msg) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null)) + logger.log(Level.INFO, stringMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) } - test("log disabled with Message message and Marker") { + test("log disabled with String message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, msg) + logger.log(Level.INFO, stringMsg, cause) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with Message message and cause and Marker") { + test("log enabled with Object message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, msg, cause) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause)) + logger.log(Level.INFO, objectMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) } - test("log disabled with Message message and cause and Marker") { + test("log disabled with Object message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, msg, cause) + logger.log(Level.INFO, objectMsg, cause) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } + def buildMockLogger: ExtendedLogger = { val mockLogger = mock[ExtendedLogger] when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory) http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/816c9288/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala index 0ce7765..a27c1fe 100644 --- a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala +++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala @@ -29,171 +29,262 @@ class Logger(val delegate: ExtendedLogger) { def fatal(marker: Marker, message: Message): Unit = macro LoggerMacro.fatalMarkerMsg - def fatal(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.fatalMarkerMsgThrowable - def fatal(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.fatalMarkerString + def fatal(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.fatalMarkerObject + + def fatal(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.fatalMarkerMsgThrowable + def fatal(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.fatalMarkerStringThrowable + def fatal(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.fatalMarkerObjectThrowable + def fatal(message: Message): Unit = macro LoggerMacro.fatalMsg def fatal(message: CharSequence): Unit = macro LoggerMacro.fatalString - + + def fatal(message: AnyRef): Unit = + macro LoggerMacro.fatalObject + def fatal(message: Message, cause: Throwable): Unit = macro LoggerMacro.fatalMsgThrowable def fatal(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.fatalStringThrowable + def fatal(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.fatalObjectThrowable + + def error(marker: Marker, message: Message): Unit = macro LoggerMacro.errorMarkerMsg - def error(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.errorMarkerMsgThrowable - def error(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.errorMarkerString + def error(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.errorMarkerObject + + def error(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.errorMarkerMsgThrowable + def error(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.errorMarkerStringThrowable + def error(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.errorMarkerObjectThrowable + def error(message: Message): Unit = macro LoggerMacro.errorMsg def error(message: CharSequence): Unit = macro LoggerMacro.errorString + def error(message: AnyRef): Unit = + macro LoggerMacro.errorObject + def error(message: Message, cause: Throwable): Unit = macro LoggerMacro.errorMsgThrowable def error(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.errorStringThrowable + def error(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.errorObjectThrowable + + def warn(marker: Marker, message: Message): Unit = macro LoggerMacro.warnMarkerMsg - def warn(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.warnMarkerMsgThrowable - def warn(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.warnMarkerString + def warn(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.warnMarkerObject + + def warn(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.warnMarkerMsgThrowable + def warn(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.warnMarkerStringThrowable + def warn(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.warnMarkerObjectThrowable + def warn(message: Message): Unit = macro LoggerMacro.warnMsg def warn(message: CharSequence): Unit = macro LoggerMacro.warnString + def warn(message: AnyRef): Unit = + macro LoggerMacro.warnObject + def warn(message: Message, cause: Throwable): Unit = macro LoggerMacro.warnMsgThrowable def warn(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.warnStringThrowable + def warn(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.warnObjectThrowable + + def info(marker: Marker, message: Message): Unit = macro LoggerMacro.infoMarkerMsg - def info(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.infoMarkerMsgThrowable - def info(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.infoMarkerString + def info(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.infoMarkerObject + + def info(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.infoMarkerMsgThrowable + def info(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.infoMarkerStringThrowable + def info(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.infoMarkerObjectThrowable + def info(message: Message): Unit = macro LoggerMacro.infoMsg def info(message: CharSequence): Unit = macro LoggerMacro.infoString + def info(message: AnyRef): Unit = + macro LoggerMacro.infoObject + def info(message: Message, cause: Throwable): Unit = macro LoggerMacro.infoMsgThrowable def info(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.infoStringThrowable + def info(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.infoObjectThrowable + + def debug(marker: Marker, message: Message): Unit = macro LoggerMacro.debugMarkerMsg - def debug(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.debugMarkerMsgThrowable - def debug(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.debugMarkerString + def debug(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.debugMarkerObject + + def debug(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.debugMarkerMsgThrowable + def debug(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.debugMarkerStringThrowable + def debug(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.debugMarkerObjectThrowable + def debug(message: Message): Unit = macro LoggerMacro.debugMsg def debug(message: CharSequence): Unit = macro LoggerMacro.debugString + def debug(message: AnyRef): Unit = + macro LoggerMacro.debugObject + def debug(message: Message, cause: Throwable): Unit = macro LoggerMacro.debugMsgThrowable def debug(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.debugStringThrowable + def debug(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.debugObjectThrowable + + def trace(marker: Marker, message: Message): Unit = macro LoggerMacro.traceMarkerMsg - def trace(marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.traceMarkerMsgThrowable - def trace(marker: Marker, message: CharSequence): Unit = macro LoggerMacro.traceMarkerString + def trace(marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.traceMarkerObject + + def trace(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.traceMarkerMsgThrowable + def trace(marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.traceMarkerStringThrowable + def trace(marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.traceMarkerObjectThrowable + def trace(message: Message): Unit = macro LoggerMacro.traceMsg def trace(message: CharSequence): Unit = macro LoggerMacro.traceString + def trace(message: AnyRef): Unit = + macro LoggerMacro.traceObject + def trace(message: Message, cause: Throwable): Unit = macro LoggerMacro.traceMsgThrowable def trace(message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.traceStringThrowable + def trace(message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.traceObjectThrowable + + def log(level: Level, marker: Marker, message: Message): Unit = macro LoggerMacro.logMarkerMsg - def log(level: Level, marker: Marker, message: Message, cause: Throwable): Unit = - macro LoggerMacro.logMarkerMsgThrowable - def log(level: Level, marker: Marker, message: CharSequence): Unit = macro LoggerMacro.logMarkerString + def log(level: Level, marker: Marker, message: AnyRef): Unit = + macro LoggerMacro.logMarkerObject + + def log(level: Level, marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.logMarkerMsgThrowable + def log(level: Level, marker: Marker, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.logMarkerStringThrowable - + + def log(level: Level, marker: Marker, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.logMarkerObjectThrowable + def log(level: Level, message: Message): Unit = macro LoggerMacro.logMsg def log(level: Level, message: CharSequence): Unit = macro LoggerMacro.logString + def log(level: Level, message: AnyRef): Unit = + macro LoggerMacro.logObject + def log(level: Level, message: Message, cause: Throwable): Unit = macro LoggerMacro.logMsgThrowable def log(level: Level, message: CharSequence, cause: Throwable): Unit = macro LoggerMacro.logStringThrowable + def log(level: Level, message: AnyRef, cause: Throwable): Unit = + macro LoggerMacro.logObjectThrowable + + def isEnabled(level: Level): Boolean = delegate.isEnabled(level) def isEnabled(level: Level, marker: Marker): Boolean = delegate.isEnabled(level, marker) @@ -201,11 +292,11 @@ class Logger(val delegate: ExtendedLogger) { def entry(params: AnyRef*): Unit = delegate.entry(params) // TODO would be useful to have this as a macro to avoid varargs array creation - def entry(): Unit = delegate.entry() + def traceEntry(): Unit = delegate.traceEntry() - def exit[R](result: R): R = delegate.exit(result) + def traceExit[R](result: R): R = delegate.traceExit(result) - def exit(): Unit = delegate.exit() + def traceExit(): Unit = delegate.traceExit() def throwing[T <: Throwable](t: T): T = delegate.throwing(t) @@ -249,4 +340,18 @@ class Logger(val delegate: ExtendedLogger) { delegate.logMessage(FQCN, level, marker, delegate.getMessageFactory.newMessage(message), cause) } + /** Always logs a message at the specified level. It is the responsibility of the caller to ensure the specified + * level is enabled. + * + * Should normally not be used directly from application code, but needs to be public for access by macros. + * + * @param level log level + * @param marker marker or `null` + * @param message message + * @param cause cause or `null` + */ + def logMessage(level: Level, marker: Marker, message: AnyRef, cause: Throwable): Unit = { + delegate.logMessage(FQCN, level, marker, delegate.getMessageFactory.newMessage(message), cause) + } + } http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/816c9288/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala index bdd782d..f84f464 100644 --- a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala +++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala @@ -20,156 +20,234 @@ import org.apache.logging.log4j.message.Message import org.apache.logging.log4j.{Level, Marker} import scala.language.experimental.macros -import scala.reflect.macros.blackbox.Context +import scala.reflect.macros.blackbox private object LoggerMacro { - type LoggerContext = Context { type PrefixType = Logger } + type LoggerContext = blackbox.Context { type PrefixType = Logger } def fatalMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = - logMarkerMsg(c)(c.universe.reify(Level.WARN), marker, message) - - def fatalMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + logMarkerMsg(c)(c.universe.reify(Level.FATAL), marker, message) def fatalMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.FATAL), marker, message) + def fatalMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.FATAL), marker, message) + + def fatalMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + def fatalMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + def fatalMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + def fatalMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.FATAL), message) - def fatalMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.FATAL), message, cause) - def fatalString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.FATAL), message) + def fatalObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.FATAL), message) + + def fatalMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.FATAL), message, cause) + def fatalStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.FATAL), message, cause) + def fatalObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.FATAL), message, cause) + + def errorMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = logMarkerMsg(c)(c.universe.reify(Level.ERROR), marker, message) - def errorMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) - def errorMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.ERROR), marker, message) + def errorMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.ERROR), marker, message) + + def errorMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) + def errorMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) + def errorMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) + def errorMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.ERROR), message) - def errorMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.ERROR), message, cause) - def errorString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.ERROR), message) + def errorObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.ERROR), message) + + def errorMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.ERROR), message, cause) + def errorStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.ERROR), message, cause) + def errorObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.ERROR), message, cause) + + def warnMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = logMarkerMsg(c)(c.universe.reify(Level.WARN), marker, message) - def warnMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) - def warnMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.WARN), marker, message) + def warnMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.WARN), marker, message) + + def warnMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) + def warnMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) + def warnMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) + def warnMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.WARN), message) - def warnMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.WARN), message, cause) - def warnString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.WARN), message) + def warnObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.WARN), message) + + def warnMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.WARN), message, cause) + def warnStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.WARN), message, cause) + def warnObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.WARN), message, cause) + + def infoMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = logMarkerMsg(c)(c.universe.reify(Level.INFO), marker, message) - def infoMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) - def infoMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.INFO), marker, message) + def infoMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.INFO), marker, message) + + def infoMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) + def infoMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) + def infoMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) + def infoMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.INFO), message) - def infoMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.INFO), message, cause) - def infoString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.INFO), message) + def infoObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.INFO), message) + + def infoMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.INFO), message, cause) + def infoStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.INFO), message, cause) + def infoObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.INFO), message, cause) + + def debugMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = logMarkerMsg(c)(c.universe.reify(Level.DEBUG), marker, message) - def debugMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) - def debugMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.DEBUG), marker, message) + def debugMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.DEBUG), marker, message) + + def debugMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) + def debugMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) + def debugMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) + def debugMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.DEBUG), message) - def debugMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) - def debugString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.DEBUG), message) + def debugObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.DEBUG), message) + + def debugMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) + def debugStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) + def debugObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) + + def traceMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = logMarkerMsg(c)(c.universe.reify(Level.TRACE), marker, message) - def traceMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMarkerMsgThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) - def traceMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) = logMarkerString(c)(c.universe.reify(Level.TRACE), marker, message) + def traceMarkerObject(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef]) = + logMarkerObject(c)(c.universe.reify(Level.TRACE), marker, message) + + def traceMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) + def traceMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logMarkerStringThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) + def traceMarkerObjectThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logMarkerObjectThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) + def traceMsg(c: LoggerContext)(message: c.Expr[Message]) = logMsg(c)(c.universe.reify(Level.TRACE), message) - def traceMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = - logMsgThrowable(c)(c.universe.reify(Level.TRACE), message, cause) - def traceString(c: LoggerContext)(message: c.Expr[CharSequence]) = logString(c)(c.universe.reify(Level.TRACE), message) + def traceObject(c: LoggerContext)(message: c.Expr[AnyRef]) = + logObject(c)(c.universe.reify(Level.TRACE), message) + + def traceMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.TRACE), message, cause) + def traceStringThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = logStringThrowable(c)(c.universe.reify(Level.TRACE), message, cause) + def traceObjectThrowable(c: LoggerContext)(message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + logObjectThrowable(c)(c.universe.reify(Level.TRACE), message, cause) + + def logMarkerMsg(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[Message]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice, marker.splice)) { @@ -177,19 +255,26 @@ private object LoggerMacro { } ) - def logMarkerMsgThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + def logMarkerString(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[CharSequence]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice, marker.splice)) { - c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, cause.splice) + c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, null) } ) - def logMarkerString(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[CharSequence]) = + def logMarkerObject(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[AnyRef]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice, marker.splice)) { c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, null) } ) + + def logMarkerMsgThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice, marker.splice)) { + c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, cause.splice) + } + ) def logMarkerStringThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = c.universe.reify( @@ -198,6 +283,13 @@ private object LoggerMacro { } ) + def logMarkerObjectThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice, marker.splice)) { + c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, cause.splice) + } + ) + def logMsg(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[Message]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice)) { @@ -205,20 +297,27 @@ private object LoggerMacro { } ) - def logMsgThrowable(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[Message], cause: c.Expr[Throwable]) = + def logString(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[CharSequence]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice)) { - c.prefix.splice.logMessage(level.splice, null, message.splice, cause.splice) + c.prefix.splice.logMessage(level.splice, null, message.splice, null) } ) - def logString(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[CharSequence]) = + def logObject(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[AnyRef]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice)) { c.prefix.splice.logMessage(level.splice, null, message.splice, null) } ) - + + def logMsgThrowable(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[Message], cause: c.Expr[Throwable]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice)) { + c.prefix.splice.logMessage(level.splice, null, message.splice, cause.splice) + } + ) + def logStringThrowable(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(level.splice)) { @@ -226,4 +325,11 @@ private object LoggerMacro { } ) + def logObjectThrowable(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[AnyRef], cause: c.Expr[Throwable]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice)) { + c.prefix.splice.logMessage(level.splice, null, message.splice, cause.splice) + } + ) + } http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/816c9288/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala index 0979cf2..75d0a13 100644 --- a/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala +++ b/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala @@ -26,11 +26,14 @@ import org.scalatest.junit.JUnitRunner import org.scalatest.mock.MockitoSugar import org.scalatest.{FunSuite, Matchers} +case class Custom(i: Int) + @RunWith(classOf[JUnitRunner]) class LoggerTest extends FunSuite with Matchers with MockitoSugar { - val stringMsg = "string msg" val msg = new ParameterizedMessage("msg {}", 17) + val stringMsg = "string msg" + val objectMsg = Custom(17) val cause = new RuntimeException("cause") val marker = MarkerManager.getMarker("marker") @@ -130,35 +133,100 @@ class LoggerTest extends FunSuite with Matchers with MockitoSugar { verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with String message") { + + test("log enabled with Message message and Marker") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, stringMsg) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) + logger.log(Level.INFO, marker, msg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null)) } - test("log disabled with String message") { + test("log disabled with Message message and Marker") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, stringMsg) + logger.log(Level.INFO, marker, msg) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with String message and cause") { + test("log enabled with String message and Marker") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, stringMsg, cause) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) + logger.log(Level.INFO, marker, stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) } - test("log disabled with String message and cause") { + test("log disabled with String message and Marker") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, stringMsg, cause) + logger.log(Level.INFO, marker, stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Object message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, objectMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) + } + + test("log disabled with Object message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, objectMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Message message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause)) + } + + test("log disabled with Message message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with String message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) + } + + test("log disabled with String message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Object message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, objectMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) + } + + test("log disabled with Object message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, objectMsg, cause) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } @@ -178,86 +246,87 @@ class LoggerTest extends FunSuite with Matchers with MockitoSugar { verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with Message message and cause") { + test("log enabled with String message") { val mockLogger = buildMockLogger when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, msg, cause) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause)) + logger.log(Level.INFO, stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) } - test("log disabled with Message message and cause") { + test("log disabled with String message") { val mockLogger = buildMockLogger when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, msg, cause) + logger.log(Level.INFO, stringMsg) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with String message and Marker") { + test("log enabled with Object message") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, stringMsg) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) + logger.log(Level.INFO, objectMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) } - test("log disabled with String message and Marker") { + test("log disabled with Object message") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, stringMsg) + logger.log(Level.INFO, objectMsg) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with String message and cause and Marker") { + test("log enabled with Message message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, stringMsg, cause) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) + logger.log(Level.INFO, msg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause)) } - test("log disabled with String message and cause and Marker") { + test("log disabled with Message message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, stringMsg, cause) + logger.log(Level.INFO, msg, cause) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with Message message and Marker") { + test("log enabled with String message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, msg) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null)) + logger.log(Level.INFO, stringMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) } - test("log disabled with Message message and Marker") { + test("log disabled with String message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, msg) + logger.log(Level.INFO, stringMsg, cause) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } - test("log enabled with Message message and cause and Marker") { + test("log enabled with Object message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, msg, cause) - verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause)) + logger.log(Level.INFO, objectMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) } - test("log disabled with Message message and cause and Marker") { + test("log disabled with Object message and cause") { val mockLogger = buildMockLogger - when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) val logger = new Logger(mockLogger) - logger.log(Level.INFO, marker, msg, cause) + logger.log(Level.INFO, objectMsg, cause) verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) } + def buildMockLogger: ExtendedLogger = { val mockLogger = mock[ExtendedLogger] when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory)
