You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by gg...@apache.org on 2017/11/11 22:26:04 UTC
logging-log4j-scala git commit: Add placeholder for Scala 2.13 but do
not enable the module.
Repository: logging-log4j-scala
Updated Branches:
refs/heads/master 5a71e5caa -> 184045cbc
Add placeholder for Scala 2.13 but do not enable the module.
Project: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/repo
Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/commit/184045cb
Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/tree/184045cb
Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/diff/184045cb
Branch: refs/heads/master
Commit: 184045cbc7a517faef2a709aa68e83d7a0053599
Parents: 5a71e5c
Author: Gary Gregory <gg...@apache.org>
Authored: Sat Nov 11 15:26:01 2017 -0700
Committer: Gary Gregory <gg...@apache.org>
Committed: Sat Nov 11 15:26:01 2017 -0700
----------------------------------------------------------------------
log4j-api-scala_2.13/pom.xml | 145 +++++
.../org/apache/logging/log4j/scala/Logger.scala | 592 +++++++++++++++++++
.../logging/log4j/scala/LoggerMacro.scala | 425 +++++++++++++
.../apache/logging/log4j/scala/Logging.scala | 30 +
.../logging/log4j/scala/LoggingContext.scala | 84 +++
log4j-api-scala_2.13/src/site/markdown/index.md | 74 +++
log4j-api-scala_2.13/src/site/site.xml | 30 +
.../apache/logging/log4j/scala/LoggerTest.scala | 552 +++++++++++++++++
.../log4j/scala/LoggingContextTest.scala | 115 ++++
pom.xml | 1 +
10 files changed, 2048 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/184045cb/log4j-api-scala_2.13/pom.xml
----------------------------------------------------------------------
diff --git a/log4j-api-scala_2.13/pom.xml b/log4j-api-scala_2.13/pom.xml
new file mode 100644
index 0000000..ea0f19c
--- /dev/null
+++ b/log4j-api-scala_2.13/pom.xml
@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-scala</artifactId>
+ <version>12.0-SNAPSHOT</version>
+ <relativePath>../</relativePath>
+ </parent>
+ <artifactId>log4j-api-scala_2.13</artifactId>
+ <packaging>jar</packaging>
+ <name>Scala 2.13 wrapper for Log4j API</name>
+ <description>Scala wrapper for Log4j API</description>
+ <properties>
+ <log4jParentDir>${basedir}/..</log4jParentDir>
+ <projectDir>/scala_2.13</projectDir>
+ <scala.version>2.13.0-M2</scala.version>
+ <scala.maven.plugin.version>3.3.1</scala.maven.plugin.version>
+ <maven.compiler.source>1.8</maven.compiler.source>
+ <maven.compiler.target>1.8</maven.compiler.target>
+ </properties>
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.scala-lang</groupId>
+ <artifactId>scala-library</artifactId>
+ <version>${scala.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.scala-lang</groupId>
+ <artifactId>scala-reflect</artifactId>
+ <version>${scala.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest_2.13.0-M2</artifactId>
+ <version>3.0.4</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <version>1.10.19</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+ <build>
+ <sourceDirectory>src/main/scala</sourceDirectory>
+ <testSourceDirectory>src/test/scala</testSourceDirectory>
+ <plugins>
+ <plugin>
+ <groupId>net.alchim31.maven</groupId>
+ <artifactId>scala-maven-plugin</artifactId>
+ <version>${scala.maven.plugin.version}</version>
+ <executions>
+ <execution>
+ <goals>
+ <goal>compile</goal>
+ <goal>testCompile</goal>
+ <goal>doc-jar</goal>
+ </goals>
+ </execution>
+ </executions>
+ <configuration>
+ <args>
+ <arg>-feature</arg>
+ <arg>-unchecked</arg>
+ <arg>-deprecation</arg>
+ </args>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+ <reporting>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-changes-plugin</artifactId>
+ <version>${changes.plugin.version}</version>
+ <reportSets>
+ <reportSet>
+ <reports>
+ <report>changes-report</report>
+ </reports>
+ </reportSet>
+ </reportSets>
+ <configuration>
+ <issueLinkTemplate>%URL%/show_bug.cgi?id=%ISSUE%</issueLinkTemplate>
+ <useJql>true</useJql>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-pmd-plugin</artifactId>
+ <version>${pmd.plugin.version}</version>
+ <configuration>
+ <targetJdk>${maven.compiler.target}</targetJdk>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>net.alchim31.maven</groupId>
+ <artifactId>scala-maven-plugin</artifactId>
+ <version>${scala.maven.plugin.version}</version>
+ </plugin>
+ </plugins>
+ </reporting>
+</project>
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
----------------------------------------------------------------------
diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
new file mode 100644
index 0000000..b42cd5a
--- /dev/null
+++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
@@ -0,0 +1,592 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.scala
+
+import org.apache.logging.log4j.message.{EntryMessage, Message, MessageFactory2}
+import org.apache.logging.log4j.spi.ExtendedLogger
+import org.apache.logging.log4j.{Level, LogManager, Marker}
+
+import scala.language.experimental.macros
+
+/**
+ * Factory for [[Logger]]s.
+ *
+ * The [[Logging]] trait provides a simple way to get a properly named logger into a class.
+ */
+object Logger {
+
+ final val FQCN = getClass.getName
+
+ /**
+ * Create a properly named [[Logger]] for a given class.
+ *
+ * @param clazz the class
+ */
+ def apply(clazz: Class[_]): Logger = Logger(LogManager.getContext(clazz.getClassLoader, false).getLogger(clazz.getName))
+
+ /**
+ * Create a [[Logger]] wrapping the given Log4j logger.
+ *
+ * @param delegate the Log4j logger to wrap
+ */
+ def apply(delegate: ExtendedLogger): Logger = new Logger(delegate)
+
+}
+
+/**
+ * Scala wrapper for the Log4j `Logger` interface.
+ *
+ * Frequently the purpose of logging is to provide information about what is happening in the system,
+ * which requires including information about the objects being manipulated. In Scala, you can use
+ * [[http://docs.scala-lang.org/overviews/core/string-interpolation.html string interpolation]]
+ * to achieve this:
+ *
+ * {{{
+ * logger.debug(s"Logging in user ${user.getName} with birthday ${user.calcBirthday}")
+ * }}}
+ *
+ * Since this wrapper is implemented with macros, the String construction and method invocations
+ * will only occur when debug logging is enabled.
+ */
+class Logger private(val delegate: ExtendedLogger) extends AnyVal {
+
+ def fatal(marker: Marker, message: Message): Unit =
+ macro LoggerMacro.fatalMarkerMsg
+
+ def fatal(marker: Marker, message: CharSequence): Unit =
+ macro LoggerMacro.fatalMarkerCseq
+
+ 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.fatalMarkerCseqThrowable
+
+ 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.fatalCseq
+
+ 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.fatalCseqThrowable
+
+ 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: CharSequence): Unit =
+ macro LoggerMacro.errorMarkerCseq
+
+ 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.errorMarkerCseqThrowable
+
+ 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.errorCseq
+
+ 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.errorCseqThrowable
+
+ 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: CharSequence): Unit =
+ macro LoggerMacro.warnMarkerCseq
+
+ 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.warnMarkerCseqThrowable
+
+ 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.warnCseq
+
+ 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.warnCseqThrowable
+
+ 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: CharSequence): Unit =
+ macro LoggerMacro.infoMarkerCseq
+
+ 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.infoMarkerCseqThrowable
+
+ 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.infoCseq
+
+ 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.infoCseqThrowable
+
+ 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: CharSequence): Unit =
+ macro LoggerMacro.debugMarkerCseq
+
+ 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.debugMarkerCseqThrowable
+
+ 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.debugCseq
+
+ 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.debugCseqThrowable
+
+ 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: CharSequence): Unit =
+ macro LoggerMacro.traceMarkerCseq
+
+ 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.traceMarkerCseqThrowable
+
+ 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.traceCseq
+
+ 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.traceCseqThrowable
+
+ def trace(message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.traceObjectThrowable
+
+
+ /**
+ * Logs a `Message` with the specific `Marker` at the given `Level`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ */
+ def apply(level: Level, marker: Marker, message: Message): Unit =
+ macro LoggerMacro.logMarkerMsg
+
+ /**
+ * Logs a string with the specific `Marker` at the given `Level`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ */
+ def apply(level: Level, marker: Marker, message: CharSequence): Unit =
+ macro LoggerMacro.logMarkerCseq
+
+ /**
+ * Logs an object with the specific `Marker` at the given `Level`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ */
+ def apply(level: Level, marker: Marker, message: AnyRef): Unit =
+ macro LoggerMacro.logMarkerObject
+
+ /**
+ * Logs a `Message` with the specific `Marker` at the given `Level` including the stack trace
+ * of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ * @param cause the cause
+ */
+ def apply(level: Level, marker: Marker, message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.logMarkerMsgThrowable
+
+ /**
+ * Logs a string with the specific `Marker` at the given `Level` including the stack trace
+ * of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ * @param cause the cause
+ */
+ def apply(level: Level, marker: Marker, message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.logMarkerCseqThrowable
+
+ /**
+ * Logs an object with the specific `Marker` at the given `Level` including the stack trace
+ * of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ * @param cause the cause
+ */
+ def apply(level: Level, marker: Marker, message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.logMarkerObjectThrowable
+
+ /**
+ * Logs a `Message` at the given `Level`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ */
+ def apply(level: Level, message: Message): Unit =
+ macro LoggerMacro.logMsg
+
+ /**
+ * Logs a string at the given `Level`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ */
+ def apply(level: Level, message: CharSequence): Unit =
+ macro LoggerMacro.logCseq
+
+ /**
+ * Logs an object at the given `Level`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ */
+ def apply(level: Level, message: AnyRef): Unit =
+ macro LoggerMacro.logObject
+
+ /**
+ * Logs a `Message` at the given `Level` including the stack trace of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ * @param cause a `Throwable`
+ */
+ def apply(level: Level, message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.logMsgThrowable
+
+ /**
+ * Logs a string at the given `Level` including the stack trace of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ * @param cause a `Throwable`
+ */
+ def apply(level: Level, message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.logCseqThrowable
+
+ /**
+ * Logs an object at the given `Level` including the stack trace of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ * @param cause a `Throwable`
+ */
+ def apply(level: Level, message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.logObjectThrowable
+
+
+ /**
+ * Logs entry to a method. Used when the method in question has no parameters or when the parameters should not be
+ * logged.
+ *
+ * @return The built `EntryMessage`
+ */
+ def traceEntry(): EntryMessage =
+ macro LoggerMacro.traceEntry
+
+ /**
+ * Logs entry to a method along with its parameters.
+ *
+ * {{{
+ * def doSomething(foo: String, bar: Int): Unit = {
+ * logger.traceEntry(foo, bar)
+ * // do something
+ * }
+ * }}}
+ *
+ * @param params the parameters to the method.
+ * @return The built `EntryMessage`
+ */
+ def traceEntry(params: AnyRef*): EntryMessage =
+ macro LoggerMacro.traceEntryParams
+
+ /**
+ * Logs entry to a method using a `Message` to describe the parameters.
+ *
+ * {{{
+ * def doSomething(foo: Request): Unit = {
+ * logger.traceEntry(JsonMessage(foo))
+ * // do something
+ * }
+ * }}}
+ *
+ * @param message the message
+ * @return The built `EntryMessage`
+ */
+ def traceEntry(message: Message): EntryMessage =
+ macro LoggerMacro.traceEntryMessage
+
+ /**
+ * Logs exit from a method with no result.
+ */
+ def traceExit(): Unit =
+ macro LoggerMacro.traceExit
+
+ /**
+ * Logs exiting from a method with result.
+ *
+ * @param result The result being returned from the method call
+ * @return `result`
+ */
+ def traceExit[R](result: R): R =
+ macro LoggerMacro.traceExitResult[R]
+
+ /**
+ * Logs exiting from a method with no result.
+ *
+ * @param entryMessage the `EntryMessage` returned from one of the `traceEntry` methods
+ */
+ def traceExit(entryMessage: EntryMessage): Unit =
+ macro LoggerMacro.traceExitEntryMessage
+
+ /**
+ * Logs exiting from a method with result.
+ *
+ * {{{
+ * def doSomething(foo: String, bar: Int): Int = {
+ * val entryMessage = logger.traceEntry(foo, bar)
+ * // do something
+ * traceExit(entryMessage, value)
+ * }
+ * }}}
+ *
+ * @param entryMessage the `EntryMessage` returned from one of the `traceEntry` methods
+ * @param result The result being returned from the method call
+ * @return `result`
+ */
+ def traceExit[R](entryMessage: EntryMessage, result: R): R =
+ macro LoggerMacro.traceExitEntryMessageResult[R]
+
+ /**
+ * Logs exiting from a method with result. Allows custom formatting of the result.
+ *
+ * @param message the Message containing the formatted result
+ * @param result The result being returned from the method call.
+ * @return `result`
+ */
+ def traceExit[R](message: Message, result: R): R =
+ macro LoggerMacro.traceExitMessageResult[R]
+
+ /**
+ * Logs an exception or error to be thrown.
+ *
+ * {{{
+ * throw logger.throwing(myException)
+ * }}}
+ *
+ * @param t the Throwable
+ * @return `t`
+ */
+ def throwing[T <: Throwable](t: T): T =
+ macro LoggerMacro.throwing[T]
+
+ /**
+ * Logs an exception or error to be thrown to a specific logging level.
+ *
+ * {{{
+ * throw logger.throwing(Level.DEBUG, myException)
+ * }}}
+ *
+ * @param level the logging Level.
+ * @param t the Throwable
+ * @return `t`
+ */
+ def throwing[T <: Throwable](level: Level, t: T): T =
+ macro LoggerMacro.throwingLevel[T]
+
+ /**
+ * Logs an exception or error that has been caught.
+ *
+ * @param t the Throwable.
+ */
+ def catching(t: Throwable): Unit =
+ macro LoggerMacro.catching
+
+ /**
+ * Logs an exception or error that has been caught to a specific logging level.
+ *
+ * @param level The logging Level.
+ * @param t The Throwable.
+ */
+ def catching(level: Level, t: Throwable): Unit =
+ macro LoggerMacro.catchingLevel
+
+
+ /** 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: Message, cause: Throwable): Unit = {
+ delegate.logMessage(Logger.FQCN, level, marker, 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: CharSequence, cause: Throwable): Unit = {
+ delegate.logMessage(Logger.FQCN, level, marker, delegate.getMessageFactory.asInstanceOf[MessageFactory2].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(Logger.FQCN, level, marker, delegate.getMessageFactory.asInstanceOf[MessageFactory2].newMessage(message), cause)
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
----------------------------------------------------------------------
diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
new file mode 100644
index 0000000..3b54db1
--- /dev/null
+++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
@@ -0,0 +1,425 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.scala
+
+import org.apache.logging.log4j.message.{EntryMessage, Message}
+import org.apache.logging.log4j.spi.AbstractLogger
+import org.apache.logging.log4j.{Level, Marker}
+
+import scala.language.experimental.macros
+import scala.reflect.macros.blackbox
+
+/**
+ * Inspired from [[https://github.com/typesafehub/scalalogging ScalaLogging]].
+ */
+private object LoggerMacro {
+
+ 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.FATAL), marker, message)
+
+ def fatalMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) =
+ logMarkerCseq(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 fatalMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logMarkerCseqThrowable(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 fatalCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
+ logCseq(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 fatalCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logCseqThrowable(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 errorMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) =
+ logMarkerCseq(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 errorMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logMarkerCseqThrowable(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 errorCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
+ logCseq(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 errorCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logCseqThrowable(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 warnMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) =
+ logMarkerCseq(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 warnMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logMarkerCseqThrowable(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 warnCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
+ logCseq(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 warnCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logCseqThrowable(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 infoMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) =
+ logMarkerCseq(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 infoMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logMarkerCseqThrowable(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 infoCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
+ logCseq(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 infoCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logCseqThrowable(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 debugMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) =
+ logMarkerCseq(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 debugMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logMarkerCseqThrowable(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 debugCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
+ logCseq(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 debugCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logCseqThrowable(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 traceMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence]) =
+ logMarkerCseq(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 traceMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logMarkerCseqThrowable(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 traceCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
+ logCseq(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 traceCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
+ logCseqThrowable(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)) {
+ c.prefix.splice.logMessage(level.splice, marker.splice, message.splice, null)
+ }
+ )
+
+ def logMarkerCseq(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, null)
+ }
+ )
+
+ 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 logMarkerCseqThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[CharSequence], 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 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)) {
+ c.prefix.splice.logMessage(level.splice, null, message.splice, null)
+ }
+ )
+
+ def logCseq(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, null)
+ }
+ )
+
+ 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 logCseqThrowable(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)) {
+ c.prefix.splice.logMessage(level.splice, null, message.splice, cause.splice)
+ }
+ )
+
+ 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)
+ }
+ )
+
+
+ def traceEntry(c: LoggerContext)(): c.Expr[EntryMessage] =
+ c.universe.reify(
+ c.prefix.splice.delegate.traceEntry()
+ )
+
+ def traceEntryParams(c: LoggerContext)(params: c.Expr[AnyRef]*): c.Expr[EntryMessage] = {
+ import c.universe._
+ val isEnabled = Apply(
+ Select(Select(c.prefix.tree, TermName("delegate")), TermName("isEnabled")),
+ List(
+ reify(Level.TRACE).tree,
+ reify(AbstractLogger.ENTRY_MARKER).tree,
+ reify(null: AnyRef).tree,
+ reify(null).tree
+ )
+ )
+
+ val log = Apply(
+ Select(Select(c.prefix.tree, TermName("delegate")), TermName("traceEntry")),
+ reify(null: String).tree :: (params map (_.tree)).toList
+ )
+ c.Expr[EntryMessage](If(isEnabled, log, reify(null).tree))
+ }
+
+
+ def traceEntryMessage(c: LoggerContext)(message: c.Expr[Message]): c.Expr[EntryMessage] =
+ c.universe.reify(
+ if (c.prefix.splice.delegate.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null: AnyRef, null)) {
+ c.prefix.splice.delegate.traceEntry(message.splice) // TODO should not do ifEnabled check
+ } else {
+ null
+ }
+ )
+
+ def traceExit(c: LoggerContext)(): c.Expr[Unit] =
+ c.universe.reify(
+ c.prefix.splice.delegate.traceExit()
+ )
+
+ def traceExitResult[R: c.WeakTypeTag](c: LoggerContext)(result: c.Expr[R]): c.Expr[R] =
+ c.universe.reify(
+ c.prefix.splice.delegate.traceExit(result.splice)
+ )
+
+ def traceExitEntryMessage(c: LoggerContext)(entryMessage: c.Expr[EntryMessage]): c.Expr[Unit] =
+ c.universe.reify(
+ c.prefix.splice.delegate.traceExit(entryMessage.splice)
+ )
+
+ def traceExitEntryMessageResult[R: c.WeakTypeTag](c: LoggerContext)(entryMessage: c.Expr[EntryMessage], result: c.Expr[R]): c.Expr[R] =
+ c.universe.reify(
+ c.prefix.splice.delegate.traceExit(entryMessage.splice, result.splice)
+ )
+
+ def traceExitMessageResult[R: c.WeakTypeTag](c: LoggerContext)(message: c.Expr[Message], result: c.Expr[R]): c.Expr[R] =
+ c.universe.reify(
+ {
+ if (message.splice != null && c.prefix.splice.delegate.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, message.splice, null)) {
+ c.prefix.splice.delegate.traceExit(message.splice, result.splice) // TODO should not do ifEnabled check
+ }
+ result.splice
+ }
+ )
+
+ def throwing[T <: Throwable: c.WeakTypeTag](c: LoggerContext)(t: c.Expr[T]): c.Expr[T] =
+ c.universe.reify(
+ c.prefix.splice.delegate.throwing(t.splice)
+ )
+
+ def throwingLevel[T <: Throwable: c.WeakTypeTag](c: LoggerContext)(level: c.Expr[Level], t: c.Expr[T]): c.Expr[T] =
+ c.universe.reify(
+ c.prefix.splice.delegate.throwing(level.splice, t.splice)
+ )
+
+ def catching(c: LoggerContext)(t: c.Expr[Throwable]): c.Expr[Unit] =
+ c.universe.reify(
+ c.prefix.splice.delegate.catching(t.splice)
+ )
+
+ def catchingLevel(c: LoggerContext)(level: c.Expr[Level], t: c.Expr[Throwable]): c.Expr[Unit] =
+ c.universe.reify(
+ c.prefix.splice.delegate.catching(level.splice, t.splice)
+ )
+
+}
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
----------------------------------------------------------------------
diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logging.scala b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
new file mode 100644
index 0000000..b017de7
--- /dev/null
+++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.scala
+
+/**
+ * Mix in this trait into classes from which you want to log,
+ * give you a `logger` value with a [[Logger]] named according to the class.
+ */
+trait Logging {
+
+ /**
+ * A [[Logger]] named according to the class.
+ */
+ protected val logger: Logger = Logger(getClass)
+
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
----------------------------------------------------------------------
diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
new file mode 100644
index 0000000..79efecc
--- /dev/null
+++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.scala
+
+import org.apache.logging.log4j.ThreadContext
+
+import scala.collection.JavaConverters._
+import scala.collection.{immutable, mutable}
+
+/** Manages the context data (context map, MDC) that is added to log events.
+ *
+ * A wrapper around `org.apache.logging.log4j.ThreadContext`.
+ */
+object LoggingContext extends mutable.Map[String, String] {
+
+ override def +=(kv: (String, String)): LoggingContext.this.type = {
+ ThreadContext.put(kv._1, kv._2)
+ this
+ }
+
+ override def +=(elem1: (String, String), elem2: (String, String), elems: (String, String)*): LoggingContext.this.type = {
+ val builder = immutable.Map.newBuilder[String,String]
+ builder += elem1
+ builder += elem2
+ builder ++= elems
+ ThreadContext.putAll(builder.result.asJava)
+ this
+ }
+
+ override def ++=(xs: TraversableOnce[(String, String)]): LoggingContext.this.type = {
+ ThreadContext.putAll(xs.toMap.asJava)
+ this
+ }
+
+ override def -=(key: String): LoggingContext.this.type = {
+ ThreadContext.remove(key)
+ this
+ }
+
+ override def -=(elem1: String, elem2: String, elems: String*): LoggingContext.this.type = {
+ val builder = immutable.Seq.newBuilder[String]
+ builder += elem1
+ builder += elem2
+ builder ++= elems
+ ThreadContext.removeAll(builder.result.asJava)
+ this
+ }
+
+ override def --=(xs: TraversableOnce[String]): LoggingContext.this.type = {
+ ThreadContext.removeAll(xs.toSeq.asJava)
+ this
+ }
+
+ override def clear(): Unit = {
+ ThreadContext.clearMap()
+ }
+
+ override def contains(key: String): Boolean = ThreadContext.containsKey(key)
+
+ override def get(key: String): Option[String] = Option(ThreadContext.get(key))
+
+ override def iterator: Iterator[(String, String)] = ThreadContext.getImmutableContext.asScala.iterator
+
+ override def foreach[U](f: ((String, String)) => U): Unit = ThreadContext.getImmutableContext.asScala.foreach(f)
+
+ override def size: Int = ThreadContext.getImmutableContext.size()
+
+ override def isEmpty: Boolean = ThreadContext.isEmpty
+
+}
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/184045cb/log4j-api-scala_2.13/src/site/markdown/index.md
----------------------------------------------------------------------
diff --git a/log4j-api-scala_2.13/src/site/markdown/index.md b/log4j-api-scala_2.13/src/site/markdown/index.md
new file mode 100644
index 0000000..7acf397
--- /dev/null
+++ b/log4j-api-scala_2.13/src/site/markdown/index.md
@@ -0,0 +1,74 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+# Log4j Scala 2.12 API
+
+## Requirements
+
+Log4j Scala API for Scala 2.12 requires Log4j API, Java 8, the Scala runtime
+library, and the Scala reflection library. To use Log4j as a logging implementation,
+then Log4j Core must also be included. Instructions on using these dependencies are
+in the [dependency information page][dependencies], and additional information is
+included in the [Log4j artifacts][artifacts] page.
+
+## Example Usage
+
+<pre class="prettyprint linenums">
+import org.apache.logging.log4j.scala.Logging
+import org.apache.logging.log4j.Level
+
+class MyClass extends BaseClass with Logging {
+ def doStuff(): Unit = {
+ logger.info("Doing stuff")
+ }
+ def doStuffWithLevel(level: Level): Unit = {
+ logger(level, "Doing stuff with arbitrary level")
+ }
+}
+</pre>
+
+## Configuration
+
+Log4j Scala 2.12 API uses the standard [Log4j configuration][configuration]
+plugins. This supports XML, properties files, and a configuration builder DSL by
+default, and it optionally supports JSON and YAML formats with some additional
+Jackson dependencies.
+
+## Substituting Parameters
+
+In the Java API, parameters to a log message are interpolated using various
+strategies. In the Scala API, [string interpolation][interpolation] is used
+instead. As all logger methods are implemented as macros, string construction and
+method invocations will only occur when logging is enabled for the given log
+level. For example:
+
+<pre class="prettyprint linenums">
+logger.debug(s"Logging in user ${user.getName} with birthday ${user.calcBirthday}")
+</pre>
+
+## Logger Names
+
+Most logging implementations use a hierarchical scheme for matching logger names
+with logging configuration. In this scheme the logger name hierarchy is
+represented by '.' characters in the logger name, in a fashion very similar to
+the hierarchy used for Java/Scala package names. The [`Logging` trait][logging]
+will automatically name the Logger accordingly to the class it is being used in.
+
+[dependencies]: dependency-info.html
+[artifacts]: ../maven-artifacts.html
+[configuration]: ../configuration.html
+[interpolation]: http://docs.scala-lang.org/overviews/core/string-interpolation.html
+[logging]: scaladocs/org/apache/logging/log4j/scala/Logging.html
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/184045cb/log4j-api-scala_2.13/src/site/site.xml
----------------------------------------------------------------------
diff --git a/log4j-api-scala_2.13/src/site/site.xml b/log4j-api-scala_2.13/src/site/site.xml
new file mode 100644
index 0000000..f46fa51
--- /dev/null
+++ b/log4j-api-scala_2.13/src/site/site.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Licensed to the Apache Software Foundation (ASF) under one or more
+ ~ contributor license agreements. See the NOTICE file distributed with
+ ~ this work for additional information regarding copyright ownership.
+ ~ The ASF licenses this file to You under the Apache license, Version 2.0
+ ~ (the "License"); you may not use this file except in compliance with
+ ~ the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the license for the specific language governing permissions and
+ ~ limitations under the license.
+ -->
+<project name="Log4j Scala API"
+ xmlns="http://maven.apache.org/DECORATION/1.7.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/DECORATION/1.7.0 http://maven.apache.org/xsd/decoration-1.7.0.xsd">
+ <body>
+ <links>
+ <item name="Apache" href="http://www.apache.org/"/>
+ <item name="Logging Services" href="http://logging.apache.org/"/>
+ <item name="Log4j" href="../index.html"/>
+ </links>
+ <menu ref="reports"/>
+ </body>
+</project>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/184045cb/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
----------------------------------------------------------------------
diff --git a/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
new file mode 100644
index 0000000..bd12742
--- /dev/null
+++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
@@ -0,0 +1,552 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.scala
+
+import org.apache.logging.log4j.message.{DefaultFlowMessageFactory, Message, ParameterizedMessage, ParameterizedMessageFactory}
+import org.apache.logging.log4j.spi.{AbstractLogger, ExtendedLogger}
+import org.apache.logging.log4j.{Level, Marker, MarkerManager}
+import org.junit.runner.RunWith
+import org.mockito.Matchers.{any, anyString, eq => eqv}
+import org.mockito.Mockito._
+import org.scalatest.junit.JUnitRunner
+import org.scalatest.mockito.MockitoSugar
+import org.scalatest.{FunSuite, Matchers}
+
+import scala.language.reflectiveCalls // needed for Mockito mocking
+
+case class Custom(i: Int)
+
+trait Manager {
+ def fetchValue(): Int
+}
+
+@RunWith(classOf[JUnitRunner])
+class LoggerTest extends FunSuite with Matchers with MockitoSugar {
+
+ val msg = new ParameterizedMessage("msg {}", 17)
+ val entryMsg = new DefaultFlowMessageFactory().newEntryMessage(msg)
+ val cseqMsg: CharSequence = new StringBuilder().append("cseq msg")
+ val objectMsg = Custom(17)
+ val cause = new RuntimeException("cause")
+ val marker = MarkerManager.getMarker("marker")
+ val result = "foo"
+
+ def fixture =
+ new {
+ val mockLogger = {
+ val mockLogger = mock[ExtendedLogger]
+ when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory)
+ mockLogger
+ }
+ val manager = {
+ val mockManager = mock[Manager]
+ when(mockManager.fetchValue()).thenReturn(4711)
+ mockManager
+ }
+ }
+
+ test("fatal enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.FATAL), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("fatal disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("error enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.error(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.ERROR), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("error disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.error(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("warn enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.WARN), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("warn disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("info enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.info(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("info disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.info(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("debug enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.DEBUG), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("debug disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("trace enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.TRACE), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("trace disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+
+ test("log enabled with Message message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, msg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null))
+ }
+
+ test("log disabled with Message message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, msg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with String message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("log disabled with String message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("log enabled with CharSequence message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, cseqMsg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ }
+
+ test("log disabled with CharSequence message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, cseqMsg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Object message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, objectMsg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ }
+
+ test("log disabled with Object message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, objectMsg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Message message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, msg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause))
+ }
+
+ test("log disabled with Message message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, msg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with String message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ verify(f.manager).fetchValue()
+ }
+
+ test("log disabled with String message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("log enabled with CharSequence message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, cseqMsg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ }
+
+ test("log disabled with CharSequence message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, cseqMsg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Object message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, objectMsg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ }
+
+ test("log disabled with Object message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, objectMsg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Message message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, msg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(null))
+ }
+
+ test("log disabled with Message message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, msg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("log disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("log enabled with CharSequence message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, cseqMsg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ }
+
+ test("log disabled with CharSequence message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, cseqMsg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Object message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, objectMsg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ }
+
+ test("log disabled with Object message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, objectMsg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Message message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, msg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause))
+ }
+
+ test("log disabled with Message message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, msg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with String message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ verify(f.manager).fetchValue()
+ }
+
+ test("log disabled with String message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("log enabled with CharSequence message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, cseqMsg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ }
+
+ test("log disabled with CharSequence message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, cseqMsg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Object message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, objectMsg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ }
+
+ test("log disabled with Object message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, objectMsg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+
+ test("traceEntry") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceEntry()
+ verify(f.mockLogger).traceEntry()
+ }
+
+ test("traceEntry enabled with params") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceEntry("foo", "bar")
+ verify(f.mockLogger).traceEntry(null: String, "foo", "bar")
+ }
+
+ test("traceEntry disabled with params") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.traceEntry("foo", "bar")
+ verify(f.mockLogger, never).traceEntry(anyString(), anyString(), anyString())
+ }
+
+ test("traceEntry enabled with message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceEntry(msg)
+ verify(f.mockLogger).traceEntry(eqv(msg))
+ }
+
+ test("traceEntry disabled with message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.traceEntry(msg)
+ verify(f.mockLogger, never).traceEntry(any[Message])
+ }
+
+ test("traceExit") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit()
+ verify(f.mockLogger).traceExit()
+ }
+
+ test("traceExit with result") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit(result)
+ verify(f.mockLogger).traceExit(result)
+ }
+
+ test("traceExit with entrymessage") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit(entryMsg)
+ verify(f.mockLogger).traceExit(entryMsg)
+ }
+
+ test("traceExit with entrymessage and result") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit(entryMsg, result)
+ verify(f.mockLogger).traceExit(entryMsg, result)
+ }
+
+ test("traceExit enabled with message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit(msg, result)
+ verify(f.mockLogger).traceExit(eqv(msg), eqv(result))
+ }
+
+ test("traceExit disabled with message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit(msg, result)
+ verify(f.mockLogger, never).traceExit(any[Message], any[AnyRef])
+ }
+
+ test("throwing") {
+ val f = fixture
+ val logger = Logger(f.mockLogger)
+ logger.throwing(cause)
+ verify(f.mockLogger).throwing(eqv(cause))
+ }
+
+ test("throwing with level") {
+ val f = fixture
+ val logger = Logger(f.mockLogger)
+ logger.throwing(Level.INFO, cause)
+ verify(f.mockLogger).throwing(eqv(Level.INFO), eqv(cause))
+ }
+
+ test("catching") {
+ val f = fixture
+ val logger = Logger(f.mockLogger)
+ logger.catching(cause)
+ verify(f.mockLogger).catching(eqv(cause))
+ }
+
+ test("catching with level") {
+ val f = fixture
+ val logger = Logger(f.mockLogger)
+ logger.catching(Level.INFO, cause)
+ verify(f.mockLogger).catching(eqv(Level.INFO), eqv(cause))
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/184045cb/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
----------------------------------------------------------------------
diff --git a/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
new file mode 100644
index 0000000..80ca940
--- /dev/null
+++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
@@ -0,0 +1,115 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.scala
+
+import org.junit.runner.RunWith
+import org.scalatest.junit.JUnitRunner
+import org.scalatest.{FunSuite, Matchers}
+
+import scala.collection.mutable
+
+@RunWith(classOf[JUnitRunner])
+class LoggingContextTest extends FunSuite with Matchers {
+
+ test("put single, contains, get") {
+ LoggingContext += "key" -> "value"
+
+ LoggingContext.contains("key") shouldBe true
+ LoggingContext.get("key") shouldBe Some("value")
+ LoggingContext.contains("bogus") shouldBe false
+ LoggingContext.get("bogus") shouldBe None
+ }
+
+ test("put multiple 1") {
+ LoggingContext += ("key1" -> "value1", "key2" -> "value2")
+
+ LoggingContext.get("key1") shouldBe Some("value1")
+ LoggingContext.get("key2") shouldBe Some("value2")
+ }
+
+ test("put multiple 2") {
+ LoggingContext ++= Seq("key1" -> "value1", "key2" -> "value2")
+
+ LoggingContext.get("key1") shouldBe Some("value1")
+ LoggingContext.get("key2") shouldBe Some("value2")
+ }
+
+ test("remove single") {
+ LoggingContext += ("key1" -> "value1")
+ LoggingContext += ("key2" -> "value2")
+ LoggingContext += ("key3" -> "value3")
+
+ LoggingContext -= "key1"
+
+ LoggingContext.get("key1") shouldBe None
+ LoggingContext.get("key2") shouldBe Some("value2")
+ LoggingContext.get("key3") shouldBe Some("value3")
+ }
+
+ test("remove multiple 1") {
+ LoggingContext += ("key1" -> "value1")
+ LoggingContext += ("key2" -> "value2")
+ LoggingContext += ("key3" -> "value3")
+
+ LoggingContext -= ("key1", "key2")
+
+ LoggingContext.get("key1") shouldBe None
+ LoggingContext.get("key2") shouldBe None
+ LoggingContext.get("key3") shouldBe Some("value3")
+ }
+
+ test("remove multiple 2") {
+ LoggingContext += ("key1" -> "value1")
+ LoggingContext += ("key2" -> "value2")
+ LoggingContext += ("key3" -> "value3")
+
+ LoggingContext --= Seq("key1", "key2")
+
+ LoggingContext.get("key1") shouldBe None
+ LoggingContext.get("key2") shouldBe None
+ LoggingContext.get("key3") shouldBe Some("value3")
+ }
+
+ test("clear, size, isEmpty") {
+ LoggingContext += ("key" -> "value")
+
+ LoggingContext.clear()
+
+ LoggingContext.contains("key") shouldBe false
+ LoggingContext.size shouldBe 0
+ LoggingContext.isEmpty shouldBe true
+ }
+
+ test("iterator") {
+ LoggingContext += ("key1" -> "value1")
+ LoggingContext += ("key2" -> "value2")
+
+ LoggingContext.iterator.toSet shouldBe Set("key1" -> "value1", "key2" -> "value2")
+ }
+
+ test("foreach") {
+ LoggingContext += ("key1" -> "value1")
+ LoggingContext += ("key2" -> "value2")
+
+ val result = mutable.Set.empty[(String, String)]
+
+ LoggingContext.foreach { result += _ }
+
+ result shouldBe Set("key1" -> "value1", "key2" -> "value2")
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/184045cb/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 1068ecb..c26cc7a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -106,6 +106,7 @@
<module>log4j-api-scala_2.10</module>
<module>log4j-api-scala_2.11</module>
<module>log4j-api-scala_2.12</module>
+<!--<module>log4j-api-scala_2.13</module> -->
<module>log4j-api-scala-sample</module>
</modules>
Re: logging-log4j-scala git commit: Add placeholder for Scala 2.13
but do not enable the module.
Posted by Matt Sicker <bo...@gmail.com>.
Come to think of it, this can be more easily accomplished via an SBT build
script. Cross compiling a library against multiple versions of Scala is
much easier there.
On 11 November 2017 at 18:16, Matt Sicker <bo...@gmail.com> wrote:
> The module name reflects the version of Scala (or Scala.js, Scala Native,
> SBT, etc.) it was compiled for. With at least Scala 2.10 and beyond,
> version-specific artifacts can be done for major versions. With a milestone
> release, I don't think there is guaranteed binary compatibility with the
> actual release.
>
> Perhaps just publishing it as a snapshot only would work? That way, users
> testing out Scala 2.13 can just pull in the snapshot.
>
> On 11 November 2017 at 17:49, Gary Gregory <ga...@gmail.com> wrote:
>
>> On Sat, Nov 11, 2017 at 3:51 PM, Matt Sicker <bo...@gmail.com> wrote:
>>
>> > I've seen on Maven Central before that a few Scala libraries have
>> published
>> > artifacts for 2.13.0 milestones. See for example: <
>> > https://search.maven.org/#artifactdetails%7Corg.
>> > scalatest%7Cscalatest_2.13.0-M2%7C3.0.4%7Cbundle>.
>> > It seems like if we published the module by naming it
>> > "log4j-api-scala_2.13.0-M2", we could have a version specific to that
>> > milestone at least.
>> >
>>
>> Hi Matt,
>>
>> The scalatest module has the milestone number in the name but not
>> scala-library for example.
>>
>> Why bother with changing the module name. If it came out today, our
>> version
>> 12.0 of log4j-api-scala_2.13 would be at the 2.13.0-M2 level. Then our
>> 13.0
>> can be at the next M level and so on.
>>
>> What am I missing?
>>
>> Gary
>>
>>
>> > On 11 November 2017 at 16:26, <gg...@apache.org> wrote:
>> >
>> > > Repository: logging-log4j-scala
>> > > Updated Branches:
>> > > refs/heads/master 5a71e5caa -> 184045cbc
>> > >
>> > >
>> > > Add placeholder for Scala 2.13 but do not enable the module.
>> > >
>> > > Project: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/r
>> epo
>> > > Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > commit/184045cb
>> > > Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > tree/184045cb
>> > > Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > diff/184045cb
>> > >
>> > > Branch: refs/heads/master
>> > > Commit: 184045cbc7a517faef2a709aa68e83d7a0053599
>> > > Parents: 5a71e5c
>> > > Author: Gary Gregory <gg...@apache.org>
>> > > Authored: Sat Nov 11 15:26:01 2017 -0700
>> > > Committer: Gary Gregory <gg...@apache.org>
>> > > Committed: Sat Nov 11 15:26:01 2017 -0700
>> > >
>> > > ------------------------------------------------------------
>> ----------
>> > > log4j-api-scala_2.13/pom.xml | 145 +++++
>> > > .../org/apache/logging/log4j/scala/Logger.scala | 592
>> > +++++++++++++++++++
>> > > .../logging/log4j/scala/LoggerMacro.scala | 425 +++++++++++++
>> > > .../apache/logging/log4j/scala/Logging.scala | 30 +
>> > > .../logging/log4j/scala/LoggingContext.scala | 84 +++
>> > > log4j-api-scala_2.13/src/site/markdown/index.md | 74 +++
>> > > log4j-api-scala_2.13/src/site/site.xml | 30 +
>> > > .../apache/logging/log4j/scala/LoggerTest.scala | 552
>> +++++++++++++++++
>> > > .../log4j/scala/LoggingContextTest.scala | 115 ++++
>> > > pom.xml | 1 +
>> > > 10 files changed, 2048 insertions(+)
>> > > ------------------------------------------------------------
>> ----------
>> > >
>> > >
>> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > blob/184045cb/log4j-api-scala_2.13/pom.xml
>> > > ------------------------------------------------------------
>> ----------
>> > > diff --git a/log4j-api-scala_2.13/pom.xml
>> b/log4j-api-scala_2.13/pom.xml
>> > > new file mode 100644
>> > > index 0000000..ea0f19c
>> > > --- /dev/null
>> > > +++ b/log4j-api-scala_2.13/pom.xml
>> > > @@ -0,0 +1,145 @@
>> > > +<?xml version="1.0" encoding="UTF-8"?>
>> > > +<!--
>> > > + Licensed to the Apache Software Foundation (ASF) under one or more
>> > > + contributor license agreements. See the NOTICE file distributed
>> with
>> > > + this work for additional information regarding copyright ownership.
>> > > + The ASF licenses this file to You under the Apache License, Version
>> 2.0
>> > > + (the "License"); you may not use this file except in compliance with
>> > > + the License. You may obtain a copy of the License at
>> > > +
>> > > + http://www.apache.org/licenses/LICENSE-2.0
>> > > +
>> > > + Unless required by applicable law or agreed to in writing, software
>> > > + distributed under the License is distributed on an "AS IS" BASIS,
>> > > + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> > implied.
>> > > + See the License for the specific language governing permissions and
>> > > + limitations under the License.
>> > > +-->
>> > > +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="
>> > > http://www.w3.org/2001/XMLSchema-instance"
>> xsi:schemaLocation="http://
>> > > maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/ma
>> ven-4.0.0.xsd">
>> > > + <modelVersion>4.0.0</modelVersion>
>> > > + <parent>
>> > > + <groupId>org.apache.logging.log4j</groupId>
>> > > + <artifactId>log4j-scala</artifactId>
>> > > + <version>12.0-SNAPSHOT</version>
>> > > + <relativePath>../</relativePath>
>> > > + </parent>
>> > > + <artifactId>log4j-api-scala_2.13</artifactId>
>> > > + <packaging>jar</packaging>
>> > > + <name>Scala 2.13 wrapper for Log4j API</name>
>> > > + <description>Scala wrapper for Log4j API</description>
>> > > + <properties>
>> > > + <log4jParentDir>${basedir}/..</log4jParentDir>
>> > > + <projectDir>/scala_2.13</projectDir>
>> > > + <scala.version>2.13.0-M2</scala.version>
>> > > + <scala.maven.plugin.version>3.3.1</scala.maven.plugin.version>
>> > > + <maven.compiler.source>1.8</maven.compiler.source>
>> > > + <maven.compiler.target>1.8</maven.compiler.target>
>> > > + </properties>
>> > > + <dependencies>
>> > > + <dependency>
>> > > + <groupId>org.apache.logging.log4j</groupId>
>> > > + <artifactId>log4j-api</artifactId>
>> > > + </dependency>
>> > > + <dependency>
>> > > + <groupId>org.scala-lang</groupId>
>> > > + <artifactId>scala-library</artifactId>
>> > > + <version>${scala.version}</version>
>> > > + </dependency>
>> > > + <dependency>
>> > > + <groupId>org.scala-lang</groupId>
>> > > + <artifactId>scala-reflect</artifactId>
>> > > + <version>${scala.version}</version>
>> > > + </dependency>
>> > > + <dependency>
>> > > + <groupId>org.apache.logging.log4j</groupId>
>> > > + <artifactId>log4j-api</artifactId>
>> > > + <type>test-jar</type>
>> > > + <scope>test</scope>
>> > > + </dependency>
>> > > + <dependency>
>> > > + <groupId>junit</groupId>
>> > > + <artifactId>junit</artifactId>
>> > > + <scope>test</scope>
>> > > + </dependency>
>> > > + <dependency>
>> > > + <groupId>org.scalatest</groupId>
>> > > + <artifactId>scalatest_2.13.0-M2</artifactId>
>> > > + <version>3.0.4</version>
>> > > + <scope>test</scope>
>> > > + </dependency>
>> > > + <dependency>
>> > > + <groupId>org.mockito</groupId>
>> > > + <artifactId>mockito-core</artifactId>
>> > > + <version>1.10.19</version>
>> > > + <scope>test</scope>
>> > > + </dependency>
>> > > + </dependencies>
>> > > + <build>
>> > > + <sourceDirectory>src/main/scala</sourceDirectory>
>> > > + <testSourceDirectory>src/test/scala</testSourceDirectory>
>> > > + <plugins>
>> > > + <plugin>
>> > > + <groupId>net.alchim31.maven</groupId>
>> > > + <artifactId>scala-maven-plugin</artifactId>
>> > > + <version>${scala.maven.plugin.version}</version>
>> > > + <executions>
>> > > + <execution>
>> > > + <goals>
>> > > + <goal>compile</goal>
>> > > + <goal>testCompile</goal>
>> > > + <goal>doc-jar</goal>
>> > > + </goals>
>> > > + </execution>
>> > > + </executions>
>> > > + <configuration>
>> > > + <args>
>> > > + <arg>-feature</arg>
>> > > + <arg>-unchecked</arg>
>> > > + <arg>-deprecation</arg>
>> > > + </args>
>> > > + </configuration>
>> > > + </plugin>
>> > > + <plugin>
>> > > + <groupId>org.apache.maven.plugins</groupId>
>> > > + <artifactId>maven-surefire-plugin</artifactId>
>> > > + </plugin>
>> > > + <plugin>
>> > > + <groupId>org.apache.felix</groupId>
>> > > + <artifactId>maven-bundle-plugin</artifactId>
>> > > + </plugin>
>> > > + </plugins>
>> > > + </build>
>> > > + <reporting>
>> > > + <plugins>
>> > > + <plugin>
>> > > + <groupId>org.apache.maven.plugins</groupId>
>> > > + <artifactId>maven-changes-plugin</artifactId>
>> > > + <version>${changes.plugin.version}</version>
>> > > + <reportSets>
>> > > + <reportSet>
>> > > + <reports>
>> > > + <report>changes-report</report>
>> > > + </reports>
>> > > + </reportSet>
>> > > + </reportSets>
>> > > + <configuration>
>> > > + <issueLinkTemplate>%URL%/show_bug.cgi?id=%ISSUE%</
>> > > issueLinkTemplate>
>> > > + <useJql>true</useJql>
>> > > + </configuration>
>> > > + </plugin>
>> > > + <plugin>
>> > > + <groupId>org.apache.maven.plugins</groupId>
>> > > + <artifactId>maven-pmd-plugin</artifactId>
>> > > + <version>${pmd.plugin.version}</version>
>> > > + <configuration>
>> > > + <targetJdk>${maven.compiler.target}</targetJdk>
>> > > + </configuration>
>> > > + </plugin>
>> > > + <plugin>
>> > > + <groupId>net.alchim31.maven</groupId>
>> > > + <artifactId>scala-maven-plugin</artifactId>
>> > > + <version>${scala.maven.plugin.version}</version>
>> > > + </plugin>
>> > > + </plugins>
>> > > + </reporting>
>> > > +</project>
>> > >
>> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
>> > > apache/logging/log4j/scala/Logger.scala
>> > > ------------------------------------------------------------
>> ----------
>> > > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > log4j/scala/Logger.scala
>> > > b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > > log4j/scala/Logger.scala
>> > > new file mode 100644
>> > > index 0000000..b42cd5a
>> > > --- /dev/null
>> > > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > > log4j/scala/Logger.scala
>> > > @@ -0,0 +1,592 @@
>> > > +/*
>> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
>> > > + * contributor license agreements. See the NOTICE file distributed
>> with
>> > > + * this work for additional information regarding copyright
>> ownership.
>> > > + * The ASF licenses this file to You under the Apache license,
>> Version
>> > 2.0
>> > > + * (the "License"); you may not use this file except in compliance
>> with
>> > > + * the License. You may obtain a copy of the License at
>> > > + *
>> > > + * http://www.apache.org/licenses/LICENSE-2.0
>> > > + *
>> > > + * Unless required by applicable law or agreed to in writing,
>> software
>> > > + * distributed under the License is distributed on an "AS IS" BASIS,
>> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> > > implied.
>> > > + * See the license for the specific language governing permissions
>> and
>> > > + * limitations under the license.
>> > > + */
>> > > +package org.apache.logging.log4j.scala
>> > > +
>> > > +import org.apache.logging.log4j.message.{EntryMessage, Message,
>> > > MessageFactory2}
>> > > +import org.apache.logging.log4j.spi.ExtendedLogger
>> > > +import org.apache.logging.log4j.{Level, LogManager, Marker}
>> > > +
>> > > +import scala.language.experimental.macros
>> > > +
>> > > +/**
>> > > + * Factory for [[Logger]]s.
>> > > + *
>> > > + * The [[Logging]] trait provides a simple way to get a properly
>> named
>> > > logger into a class.
>> > > + */
>> > > +object Logger {
>> > > +
>> > > + final val FQCN = getClass.getName
>> > > +
>> > > + /**
>> > > + * Create a properly named [[Logger]] for a given class.
>> > > + *
>> > > + * @param clazz the class
>> > > + */
>> > > + def apply(clazz: Class[_]): Logger = Logger(LogManager.getContext(
>> > clazz.getClassLoader,
>> > > false).getLogger(clazz.getName))
>> > > +
>> > > + /**
>> > > + * Create a [[Logger]] wrapping the given Log4j logger.
>> > > + *
>> > > + * @param delegate the Log4j logger to wrap
>> > > + */
>> > > + def apply(delegate: ExtendedLogger): Logger = new Logger(delegate)
>> > > +
>> > > +}
>> > > +
>> > > +/**
>> > > + * Scala wrapper for the Log4j `Logger` interface.
>> > > + *
>> > > + * Frequently the purpose of logging is to provide information about
>> > > what is happening in the system,
>> > > + * which requires including information about the objects being
>> > > manipulated. In Scala, you can use
>> > > + * [[http://docs.scala-lang.org/overviews/core/string-
>> > interpolation.html
>> > > string interpolation]]
>> > > + * to achieve this:
>> > > + *
>> > > + * {{{
>> > > + * logger.debug(s"Logging in user ${user.getName} with birthday
>> > > ${user.calcBirthday}")
>> > > + * }}}
>> > > + *
>> > > + * Since this wrapper is implemented with macros, the String
>> > > construction and method invocations
>> > > + * will only occur when debug logging is enabled.
>> > > + */
>> > > +class Logger private(val delegate: ExtendedLogger) extends AnyVal {
>> > > +
>> > > + def fatal(marker: Marker, message: Message): Unit =
>> > > + macro LoggerMacro.fatalMarkerMsg
>> > > +
>> > > + def fatal(marker: Marker, message: CharSequence): Unit =
>> > > + macro LoggerMacro.fatalMarkerCseq
>> > > +
>> > > + 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.fatalMarkerCseqThrowable
>> > > +
>> > > + 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.fatalCseq
>> > > +
>> > > + 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.fatalCseqThrowable
>> > > +
>> > > + 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: CharSequence): Unit =
>> > > + macro LoggerMacro.errorMarkerCseq
>> > > +
>> > > + 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.errorMarkerCseqThrowable
>> > > +
>> > > + 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.errorCseq
>> > > +
>> > > + 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.errorCseqThrowable
>> > > +
>> > > + 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: CharSequence): Unit =
>> > > + macro LoggerMacro.warnMarkerCseq
>> > > +
>> > > + 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.warnMarkerCseqThrowable
>> > > +
>> > > + 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.warnCseq
>> > > +
>> > > + 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.warnCseqThrowable
>> > > +
>> > > + 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: CharSequence): Unit =
>> > > + macro LoggerMacro.infoMarkerCseq
>> > > +
>> > > + 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.infoMarkerCseqThrowable
>> > > +
>> > > + 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.infoCseq
>> > > +
>> > > + 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.infoCseqThrowable
>> > > +
>> > > + 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: CharSequence): Unit =
>> > > + macro LoggerMacro.debugMarkerCseq
>> > > +
>> > > + 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.debugMarkerCseqThrowable
>> > > +
>> > > + 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.debugCseq
>> > > +
>> > > + 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.debugCseqThrowable
>> > > +
>> > > + 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: CharSequence): Unit =
>> > > + macro LoggerMacro.traceMarkerCseq
>> > > +
>> > > + 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.traceMarkerCseqThrowable
>> > > +
>> > > + 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.traceCseq
>> > > +
>> > > + 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.traceCseqThrowable
>> > > +
>> > > + def trace(message: AnyRef, cause: Throwable): Unit =
>> > > + macro LoggerMacro.traceObjectThrowable
>> > > +
>> > > +
>> > > + /**
>> > > + * Logs a `Message` with the specific `Marker` at the given
>> `Level`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param marker the marker data specific to this log statement
>> > > + * @param message the message to be logged
>> > > + */
>> > > + def apply(level: Level, marker: Marker, message: Message): Unit =
>> > > + macro LoggerMacro.logMarkerMsg
>> > > +
>> > > + /**
>> > > + * Logs a string with the specific `Marker` at the given `Level`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param marker the marker data specific to this log statement
>> > > + * @param message the message to be logged
>> > > + */
>> > > + def apply(level: Level, marker: Marker, message: CharSequence):
>> Unit =
>> > > + macro LoggerMacro.logMarkerCseq
>> > > +
>> > > + /**
>> > > + * Logs an object with the specific `Marker` at the given `Level`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param marker the marker data specific to this log statement
>> > > + * @param message the message to be logged
>> > > + */
>> > > + def apply(level: Level, marker: Marker, message: AnyRef): Unit =
>> > > + macro LoggerMacro.logMarkerObject
>> > > +
>> > > + /**
>> > > + * Logs a `Message` with the specific `Marker` at the given
>> `Level`
>> > > including the stack trace
>> > > + * of the given `Throwable`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param marker the marker data specific to this log statement
>> > > + * @param message the message to be logged
>> > > + * @param cause the cause
>> > > + */
>> > > + def apply(level: Level, marker: Marker, message: Message, cause:
>> > > Throwable): Unit =
>> > > + macro LoggerMacro.logMarkerMsgThrowable
>> > > +
>> > > + /**
>> > > + * Logs a string with the specific `Marker` at the given `Level`
>> > > including the stack trace
>> > > + * of the given `Throwable`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param marker the marker data specific to this log statement
>> > > + * @param message the message to be logged
>> > > + * @param cause the cause
>> > > + */
>> > > + def apply(level: Level, marker: Marker, message: CharSequence,
>> cause:
>> > > Throwable): Unit =
>> > > + macro LoggerMacro.logMarkerCseqThrowable
>> > > +
>> > > + /**
>> > > + * Logs an object with the specific `Marker` at the given `Level`
>> > > including the stack trace
>> > > + * of the given `Throwable`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param marker the marker data specific to this log statement
>> > > + * @param message the message to be logged
>> > > + * @param cause the cause
>> > > + */
>> > > + def apply(level: Level, marker: Marker, message: AnyRef, cause:
>> > > Throwable): Unit =
>> > > + macro LoggerMacro.logMarkerObjectThrowable
>> > > +
>> > > + /**
>> > > + * Logs a `Message` at the given `Level`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param message the message to be logged
>> > > + */
>> > > + def apply(level: Level, message: Message): Unit =
>> > > + macro LoggerMacro.logMsg
>> > > +
>> > > + /**
>> > > + * Logs a string at the given `Level`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param message the message to be logged
>> > > + */
>> > > + def apply(level: Level, message: CharSequence): Unit =
>> > > + macro LoggerMacro.logCseq
>> > > +
>> > > + /**
>> > > + * Logs an object at the given `Level`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param message the message to be logged
>> > > + */
>> > > + def apply(level: Level, message: AnyRef): Unit =
>> > > + macro LoggerMacro.logObject
>> > > +
>> > > + /**
>> > > + * Logs a `Message` at the given `Level` including the stack
>> trace of
>> > > the given `Throwable`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param message the message to be logged
>> > > + * @param cause a `Throwable`
>> > > + */
>> > > + def apply(level: Level, message: Message, cause: Throwable): Unit =
>> > > + macro LoggerMacro.logMsgThrowable
>> > > +
>> > > + /**
>> > > + * Logs a string at the given `Level` including the stack trace of
>> > the
>> > > given `Throwable`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param message the message to be logged
>> > > + * @param cause a `Throwable`
>> > > + */
>> > > + def apply(level: Level, message: CharSequence, cause: Throwable):
>> > Unit =
>> > > + macro LoggerMacro.logCseqThrowable
>> > > +
>> > > + /**
>> > > + * Logs an object at the given `Level` including the stack trace
>> of
>> > > the given `Throwable`.
>> > > + *
>> > > + * @param level the logging level
>> > > + * @param message the message to be logged
>> > > + * @param cause a `Throwable`
>> > > + */
>> > > + def apply(level: Level, message: AnyRef, cause: Throwable): Unit =
>> > > + macro LoggerMacro.logObjectThrowable
>> > > +
>> > > +
>> > > + /**
>> > > + * Logs entry to a method. Used when the method in question has no
>> > > parameters or when the parameters should not be
>> > > + * logged.
>> > > + *
>> > > + * @return The built `EntryMessage`
>> > > + */
>> > > + def traceEntry(): EntryMessage =
>> > > + macro LoggerMacro.traceEntry
>> > > +
>> > > + /**
>> > > + * Logs entry to a method along with its parameters.
>> > > + *
>> > > + * {{{
>> > > + * def doSomething(foo: String, bar: Int): Unit = {
>> > > + * logger.traceEntry(foo, bar)
>> > > + * // do something
>> > > + * }
>> > > + * }}}
>> > > + *
>> > > + * @param params the parameters to the method.
>> > > + * @return The built `EntryMessage`
>> > > + */
>> > > + def traceEntry(params: AnyRef*): EntryMessage =
>> > > + macro LoggerMacro.traceEntryParams
>> > > +
>> > > + /**
>> > > + * Logs entry to a method using a `Message` to describe the
>> > parameters.
>> > > + *
>> > > + * {{{
>> > > + * def doSomething(foo: Request): Unit = {
>> > > + * logger.traceEntry(JsonMessage(foo))
>> > > + * // do something
>> > > + * }
>> > > + * }}}
>> > > + *
>> > > + * @param message the message
>> > > + * @return The built `EntryMessage`
>> > > + */
>> > > + def traceEntry(message: Message): EntryMessage =
>> > > + macro LoggerMacro.traceEntryMessage
>> > > +
>> > > + /**
>> > > + * Logs exit from a method with no result.
>> > > + */
>> > > + def traceExit(): Unit =
>> > > + macro LoggerMacro.traceExit
>> > > +
>> > > + /**
>> > > + * Logs exiting from a method with result.
>> > > + *
>> > > + * @param result The result being returned from the method call
>> > > + * @return `result`
>> > > + */
>> > > + def traceExit[R](result: R): R =
>> > > + macro LoggerMacro.traceExitResult[R]
>> > > +
>> > > + /**
>> > > + * Logs exiting from a method with no result.
>> > > + *
>> > > + * @param entryMessage the `EntryMessage` returned from one of the
>> > > `traceEntry` methods
>> > > + */
>> > > + def traceExit(entryMessage: EntryMessage): Unit =
>> > > + macro LoggerMacro.traceExitEntryMessage
>> > > +
>> > > + /**
>> > > + * Logs exiting from a method with result.
>> > > + *
>> > > + * {{{
>> > > + * def doSomething(foo: String, bar: Int): Int = {
>> > > + * val entryMessage = logger.traceEntry(foo, bar)
>> > > + * // do something
>> > > + * traceExit(entryMessage, value)
>> > > + * }
>> > > + * }}}
>> > > + *
>> > > + * @param entryMessage the `EntryMessage` returned from one of the
>> > > `traceEntry` methods
>> > > + * @param result The result being returned from the method
>> call
>> > > + * @return `result`
>> > > + */
>> > > + def traceExit[R](entryMessage: EntryMessage, result: R): R =
>> > > + macro LoggerMacro.traceExitEntryMessageResult[R]
>> > > +
>> > > + /**
>> > > + * Logs exiting from a method with result. Allows custom
>> formatting
>> > of
>> > > the result.
>> > > + *
>> > > + * @param message the Message containing the formatted result
>> > > + * @param result The result being returned from the method call.
>> > > + * @return `result`
>> > > + */
>> > > + def traceExit[R](message: Message, result: R): R =
>> > > + macro LoggerMacro.traceExitMessageResult[R]
>> > > +
>> > > + /**
>> > > + * Logs an exception or error to be thrown.
>> > > + *
>> > > + * {{{
>> > > + * throw logger.throwing(myException)
>> > > + * }}}
>> > > + *
>> > > + * @param t the Throwable
>> > > + * @return `t`
>> > > + */
>> > > + def throwing[T <: Throwable](t: T): T =
>> > > + macro LoggerMacro.throwing[T]
>> > > +
>> > > + /**
>> > > + * Logs an exception or error to be thrown to a specific logging
>> > level.
>> > > + *
>> > > + * {{{
>> > > + * throw logger.throwing(Level.DEBUG, myException)
>> > > + * }}}
>> > > + *
>> > > + * @param level the logging Level.
>> > > + * @param t the Throwable
>> > > + * @return `t`
>> > > + */
>> > > + def throwing[T <: Throwable](level: Level, t: T): T =
>> > > + macro LoggerMacro.throwingLevel[T]
>> > > +
>> > > + /**
>> > > + * Logs an exception or error that has been caught.
>> > > + *
>> > > + * @param t the Throwable.
>> > > + */
>> > > + def catching(t: Throwable): Unit =
>> > > + macro LoggerMacro.catching
>> > > +
>> > > + /**
>> > > + * Logs an exception or error that has been caught to a specific
>> > > logging level.
>> > > + *
>> > > + * @param level The logging Level.
>> > > + * @param t The Throwable.
>> > > + */
>> > > + def catching(level: Level, t: Throwable): Unit =
>> > > + macro LoggerMacro.catchingLevel
>> > > +
>> > > +
>> > > + /** 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: Message,
>> cause:
>> > > Throwable): Unit = {
>> > > + delegate.logMessage(Logger.FQCN, level, marker, 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: CharSequence,
>> > > cause: Throwable): Unit = {
>> > > + delegate.logMessage(Logger.FQCN, level, marker,
>> > > delegate.getMessageFactory.asInstanceOf[MessageFactory2].
>> > 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(Logger.FQCN, level, marker,
>> > > delegate.getMessageFactory.asInstanceOf[MessageFactory2].
>> > newMessage(message),
>> > > cause)
>> > > + }
>> > > +
>> > > +}
>> > >
>> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
>> > > apache/logging/log4j/scala/LoggerMacro.scala
>> > > ------------------------------------------------------------
>> ----------
>> > > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > log4j/scala/LoggerMacro.scala
>> > > b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > > log4j/scala/LoggerMacro.scala
>> > > new file mode 100644
>> > > index 0000000..3b54db1
>> > > --- /dev/null
>> > > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > > log4j/scala/LoggerMacro.scala
>> > > @@ -0,0 +1,425 @@
>> > > +/*
>> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
>> > > + * contributor license agreements. See the NOTICE file distributed
>> with
>> > > + * this work for additional information regarding copyright
>> ownership.
>> > > + * The ASF licenses this file to You under the Apache license,
>> Version
>> > 2.0
>> > > + * (the "License"); you may not use this file except in compliance
>> with
>> > > + * the License. You may obtain a copy of the License at
>> > > + *
>> > > + * http://www.apache.org/licenses/LICENSE-2.0
>> > > + *
>> > > + * Unless required by applicable law or agreed to in writing,
>> software
>> > > + * distributed under the License is distributed on an "AS IS" BASIS,
>> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> > > implied.
>> > > + * See the license for the specific language governing permissions
>> and
>> > > + * limitations under the license.
>> > > + */
>> > > +package org.apache.logging.log4j.scala
>> > > +
>> > > +import org.apache.logging.log4j.message.{EntryMessage, Message}
>> > > +import org.apache.logging.log4j.spi.AbstractLogger
>> > > +import org.apache.logging.log4j.{Level, Marker}
>> > > +
>> > > +import scala.language.experimental.macros
>> > > +import scala.reflect.macros.blackbox
>> > > +
>> > > +/**
>> > > + * Inspired from [[https://github.com/typesafehub/scalalogging
>> > > ScalaLogging]].
>> > > + */
>> > > +private object LoggerMacro {
>> > > +
>> > > + 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.FATAL), marker, message)
>> > > +
>> > > + def fatalMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
>> message:
>> > > c.Expr[CharSequence]) =
>> > > + logMarkerCseq(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 fatalMarkerCseqThrowable(c: LoggerContext)(marker:
>> c.Expr[Marker],
>> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
>> > > + logMarkerCseqThrowable(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 fatalCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
>> > > + logCseq(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 fatalCseqThrowable(c: LoggerContext)(message:
>> > c.Expr[CharSequence],
>> > > cause: c.Expr[Throwable]) =
>> > > + logCseqThrowable(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 errorMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
>> message:
>> > > c.Expr[CharSequence]) =
>> > > + logMarkerCseq(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 errorMarkerCseqThrowable(c: LoggerContext)(marker:
>> c.Expr[Marker],
>> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
>> > > + logMarkerCseqThrowable(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 errorCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
>> > > + logCseq(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 errorCseqThrowable(c: LoggerContext)(message:
>> > c.Expr[CharSequence],
>> > > cause: c.Expr[Throwable]) =
>> > > + logCseqThrowable(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 warnMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
>> message:
>> > > c.Expr[CharSequence]) =
>> > > + logMarkerCseq(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 warnMarkerCseqThrowable(c: LoggerContext)(marker:
>> c.Expr[Marker],
>> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
>> > > + logMarkerCseqThrowable(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 warnCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
>> > > + logCseq(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 warnCseqThrowable(c: LoggerContext)(message:
>> c.Expr[CharSequence],
>> > > cause: c.Expr[Throwable]) =
>> > > + logCseqThrowable(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 infoMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
>> message:
>> > > c.Expr[CharSequence]) =
>> > > + logMarkerCseq(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 infoMarkerCseqThrowable(c: LoggerContext)(marker:
>> c.Expr[Marker],
>> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
>> > > + logMarkerCseqThrowable(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 infoCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
>> > > + logCseq(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 infoCseqThrowable(c: LoggerContext)(message:
>> c.Expr[CharSequence],
>> > > cause: c.Expr[Throwable]) =
>> > > + logCseqThrowable(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 debugMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
>> message:
>> > > c.Expr[CharSequence]) =
>> > > + logMarkerCseq(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 debugMarkerCseqThrowable(c: LoggerContext)(marker:
>> c.Expr[Marker],
>> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
>> > > + logMarkerCseqThrowable(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 debugCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
>> > > + logCseq(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 debugCseqThrowable(c: LoggerContext)(message:
>> > c.Expr[CharSequence],
>> > > cause: c.Expr[Throwable]) =
>> > > + logCseqThrowable(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 traceMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
>> message:
>> > > c.Expr[CharSequence]) =
>> > > + logMarkerCseq(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 traceMarkerCseqThrowable(c: LoggerContext)(marker:
>> c.Expr[Marker],
>> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
>> > > + logMarkerCseqThrowable(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 traceCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
>> > > + logCseq(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 traceCseqThrowable(c: LoggerContext)(message:
>> > c.Expr[CharSequence],
>> > > cause: c.Expr[Throwable]) =
>> > > + logCseqThrowable(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)) {
>> > > + c.prefix.splice.logMessage(level.splice, marker.splice,
>> > > message.splice, null)
>> > > + }
>> > > + )
>> > > +
>> > > + def logMarkerCseq(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, null)
>> > > + }
>> > > + )
>> > > +
>> > > + 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 logMarkerCseqThrowable(c: LoggerContext)(level: c.Expr[Level],
>> > > marker: c.Expr[Marker], message: c.Expr[CharSequence], 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 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)) {
>> > > + c.prefix.splice.logMessage(level.splice, null,
>> message.splice,
>> > > null)
>> > > + }
>> > > + )
>> > > +
>> > > + def logCseq(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,
>> > > null)
>> > > + }
>> > > + )
>> > > +
>> > > + 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 logCseqThrowable(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)) {
>> > > + c.prefix.splice.logMessage(level.splice, null,
>> message.splice,
>> > > cause.splice)
>> > > + }
>> > > + )
>> > > +
>> > > + 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)
>> > > + }
>> > > + )
>> > > +
>> > > +
>> > > + def traceEntry(c: LoggerContext)(): c.Expr[EntryMessage] =
>> > > + c.universe.reify(
>> > > + c.prefix.splice.delegate.traceEntry()
>> > > + )
>> > > +
>> > > + def traceEntryParams(c: LoggerContext)(params: c.Expr[AnyRef]*):
>> > > c.Expr[EntryMessage] = {
>> > > + import c.universe._
>> > > + val isEnabled = Apply(
>> > > + Select(Select(c.prefix.tree, TermName("delegate")),
>> > > TermName("isEnabled")),
>> > > + List(
>> > > + reify(Level.TRACE).tree,
>> > > + reify(AbstractLogger.ENTRY_MARKER).tree,
>> > > + reify(null: AnyRef).tree,
>> > > + reify(null).tree
>> > > + )
>> > > + )
>> > > +
>> > > + val log = Apply(
>> > > + Select(Select(c.prefix.tree, TermName("delegate")),
>> > > TermName("traceEntry")),
>> > > + reify(null: String).tree :: (params map (_.tree)).toList
>> > > + )
>> > > + c.Expr[EntryMessage](If(isEnabled, log, reify(null).tree))
>> > > + }
>> > > +
>> > > +
>> > > + def traceEntryMessage(c: LoggerContext)(message: c.Expr[Message]):
>> > > c.Expr[EntryMessage] =
>> > > + c.universe.reify(
>> > > + if (c.prefix.splice.delegate.isEnabled(Level.TRACE,
>> > > AbstractLogger.ENTRY_MARKER, null: AnyRef, null)) {
>> > > + c.prefix.splice.delegate.traceEntry(message.splice) // TODO
>> > > should not do ifEnabled check
>> > > + } else {
>> > > + null
>> > > + }
>> > > + )
>> > > +
>> > > + def traceExit(c: LoggerContext)(): c.Expr[Unit] =
>> > > + c.universe.reify(
>> > > + c.prefix.splice.delegate.traceExit()
>> > > + )
>> > > +
>> > > + def traceExitResult[R: c.WeakTypeTag](c: LoggerContext)(result:
>> > > c.Expr[R]): c.Expr[R] =
>> > > + c.universe.reify(
>> > > + c.prefix.splice.delegate.traceExit(result.splice)
>> > > + )
>> > > +
>> > > + def traceExitEntryMessage(c: LoggerContext)(entryMessage:
>> > > c.Expr[EntryMessage]): c.Expr[Unit] =
>> > > + c.universe.reify(
>> > > + c.prefix.splice.delegate.traceExit(entryMessage.splice)
>> > > + )
>> > > +
>> > > + def traceExitEntryMessageResult[R: c.WeakTypeTag](c:
>> > > LoggerContext)(entryMessage: c.Expr[EntryMessage], result: c.Expr[R]):
>> > > c.Expr[R] =
>> > > + c.universe.reify(
>> > > + c.prefix.splice.delegate.traceExit(entryMessage.splice,
>> > > result.splice)
>> > > + )
>> > > +
>> > > + def traceExitMessageResult[R: c.WeakTypeTag](c:
>> > LoggerContext)(message:
>> > > c.Expr[Message], result: c.Expr[R]): c.Expr[R] =
>> > > + c.universe.reify(
>> > > + {
>> > > + if (message.splice != null && c.prefix.splice.delegate.
>> > isEnabled(Level.TRACE,
>> > > AbstractLogger.EXIT_MARKER, message.splice, null)) {
>> > > + c.prefix.splice.delegate.traceExit(message.splice,
>> > > result.splice) // TODO should not do ifEnabled check
>> > > + }
>> > > + result.splice
>> > > + }
>> > > + )
>> > > +
>> > > + def throwing[T <: Throwable: c.WeakTypeTag](c: LoggerContext)(t:
>> > > c.Expr[T]): c.Expr[T] =
>> > > + c.universe.reify(
>> > > + c.prefix.splice.delegate.throwing(t.splice)
>> > > + )
>> > > +
>> > > + def throwingLevel[T <: Throwable: c.WeakTypeTag](c:
>> > > LoggerContext)(level: c.Expr[Level], t: c.Expr[T]): c.Expr[T] =
>> > > + c.universe.reify(
>> > > + c.prefix.splice.delegate.throwing(level.splice, t.splice)
>> > > + )
>> > > +
>> > > + def catching(c: LoggerContext)(t: c.Expr[Throwable]): c.Expr[Unit]
>> =
>> > > + c.universe.reify(
>> > > + c.prefix.splice.delegate.catching(t.splice)
>> > > + )
>> > > +
>> > > + def catchingLevel(c: LoggerContext)(level: c.Expr[Level], t:
>> > > c.Expr[Throwable]): c.Expr[Unit] =
>> > > + c.universe.reify(
>> > > + c.prefix.splice.delegate.catching(level.splice, t.splice)
>> > > + )
>> > > +
>> > > +}
>> > >
>> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
>> > > apache/logging/log4j/scala/Logging.scala
>> > > ------------------------------------------------------------
>> ----------
>> > > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > log4j/scala/Logging.scala
>> > > b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > > log4j/scala/Logging.scala
>> > > new file mode 100644
>> > > index 0000000..b017de7
>> > > --- /dev/null
>> > > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > > log4j/scala/Logging.scala
>> > > @@ -0,0 +1,30 @@
>> > > +/*
>> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
>> > > + * contributor license agreements. See the NOTICE file distributed
>> with
>> > > + * this work for additional information regarding copyright
>> ownership.
>> > > + * The ASF licenses this file to You under the Apache license,
>> Version
>> > 2.0
>> > > + * (the "License"); you may not use this file except in compliance
>> with
>> > > + * the License. You may obtain a copy of the License at
>> > > + *
>> > > + * http://www.apache.org/licenses/LICENSE-2.0
>> > > + *
>> > > + * Unless required by applicable law or agreed to in writing,
>> software
>> > > + * distributed under the License is distributed on an "AS IS" BASIS,
>> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> > > implied.
>> > > + * See the license for the specific language governing permissions
>> and
>> > > + * limitations under the license.
>> > > + */
>> > > +package org.apache.logging.log4j.scala
>> > > +
>> > > +/**
>> > > + * Mix in this trait into classes from which you want to log,
>> > > + * give you a `logger` value with a [[Logger]] named according to
>> the
>> > > class.
>> > > + */
>> > > +trait Logging {
>> > > +
>> > > + /**
>> > > + * A [[Logger]] named according to the class.
>> > > + */
>> > > + protected val logger: Logger = Logger(getClass)
>> > > +
>> > > +}
>> > > \ No newline at end of file
>> > >
>> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
>> > > apache/logging/log4j/scala/LoggingContext.scala
>> > > ------------------------------------------------------------
>> ----------
>> > > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > > log4j/scala/LoggingContext.scala b/log4j-api-scala_2.13/src/
>> > > main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
>> > > new file mode 100644
>> > > index 0000000..79efecc
>> > > --- /dev/null
>> > > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
>> > > log4j/scala/LoggingContext.scala
>> > > @@ -0,0 +1,84 @@
>> > > +/*
>> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
>> > > + * contributor license agreements. See the NOTICE file distributed
>> with
>> > > + * this work for additional information regarding copyright
>> ownership.
>> > > + * The ASF licenses this file to You under the Apache license,
>> Version
>> > 2.0
>> > > + * (the "License"); you may not use this file except in compliance
>> with
>> > > + * the License. You may obtain a copy of the License at
>> > > + *
>> > > + * http://www.apache.org/licenses/LICENSE-2.0
>> > > + *
>> > > + * Unless required by applicable law or agreed to in writing,
>> software
>> > > + * distributed under the License is distributed on an "AS IS" BASIS,
>> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> > > implied.
>> > > + * See the license for the specific language governing permissions
>> and
>> > > + * limitations under the license.
>> > > + */
>> > > +package org.apache.logging.log4j.scala
>> > > +
>> > > +import org.apache.logging.log4j.ThreadContext
>> > > +
>> > > +import scala.collection.JavaConverters._
>> > > +import scala.collection.{immutable, mutable}
>> > > +
>> > > +/** Manages the context data (context map, MDC) that is added to log
>> > > events.
>> > > + *
>> > > + * A wrapper around `org.apache.logging.log4j.ThreadContext`.
>> > > + */
>> > > +object LoggingContext extends mutable.Map[String, String] {
>> > > +
>> > > + override def +=(kv: (String, String)): LoggingContext.this.type = {
>> > > + ThreadContext.put(kv._1, kv._2)
>> > > + this
>> > > + }
>> > > +
>> > > + override def +=(elem1: (String, String), elem2: (String, String),
>> > > elems: (String, String)*): LoggingContext.this.type = {
>> > > + val builder = immutable.Map.newBuilder[String,String]
>> > > + builder += elem1
>> > > + builder += elem2
>> > > + builder ++= elems
>> > > + ThreadContext.putAll(builder.result.asJava)
>> > > + this
>> > > + }
>> > > +
>> > > + override def ++=(xs: TraversableOnce[(String, String)]):
>> > > LoggingContext.this.type = {
>> > > + ThreadContext.putAll(xs.toMap.asJava)
>> > > + this
>> > > + }
>> > > +
>> > > + override def -=(key: String): LoggingContext.this.type = {
>> > > + ThreadContext.remove(key)
>> > > + this
>> > > + }
>> > > +
>> > > + override def -=(elem1: String, elem2: String, elems: String*):
>> > > LoggingContext.this.type = {
>> > > + val builder = immutable.Seq.newBuilder[String]
>> > > + builder += elem1
>> > > + builder += elem2
>> > > + builder ++= elems
>> > > + ThreadContext.removeAll(builder.result.asJava)
>> > > + this
>> > > + }
>> > > +
>> > > + override def --=(xs: TraversableOnce[String]):
>> > LoggingContext.this.type
>> > > = {
>> > > + ThreadContext.removeAll(xs.toSeq.asJava)
>> > > + this
>> > > + }
>> > > +
>> > > + override def clear(): Unit = {
>> > > + ThreadContext.clearMap()
>> > > + }
>> > > +
>> > > + override def contains(key: String): Boolean =
>> > > ThreadContext.containsKey(key)
>> > > +
>> > > + override def get(key: String): Option[String] =
>> > > Option(ThreadContext.get(key))
>> > > +
>> > > + override def iterator: Iterator[(String, String)] = ThreadContext.
>> > > getImmutableContext.asScala.iterator
>> > > +
>> > > + override def foreach[U](f: ((String, String)) => U): Unit =
>> > > ThreadContext.getImmutableContext.asScala.foreach(f)
>> > > +
>> > > + override def size: Int = ThreadContext.getImmutableContext.size()
>> > > +
>> > > + override def isEmpty: Boolean = ThreadContext.isEmpty
>> > > +
>> > > +}
>> > >
>> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > blob/184045cb/log4j-api-scala_2.13/src/site/markdown/index.md
>> > > ------------------------------------------------------------
>> ----------
>> > > diff --git a/log4j-api-scala_2.13/src/site/markdown/index.md
>> > > b/log4j-api-scala_2.13/src/site/markdown/index.md
>> > > new file mode 100644
>> > > index 0000000..7acf397
>> > > --- /dev/null
>> > > +++ b/log4j-api-scala_2.13/src/site/markdown/index.md
>> > > @@ -0,0 +1,74 @@
>> > > +<!--
>> > > + Licensed to the Apache Software Foundation (ASF) under one or
>> more
>> > > + contributor license agreements. See the NOTICE file distributed
>> > with
>> > > + this work for additional information regarding copyright
>> ownership.
>> > > + The ASF licenses this file to You under the Apache License,
>> Version
>> > > 2.0
>> > > + (the "License"); you may not use this file except in compliance
>> with
>> > > + the License. You may obtain a copy of the License at
>> > > +
>> > > + http://www.apache.org/licenses/LICENSE-2.0
>> > > +
>> > > + Unless required by applicable law or agreed to in writing,
>> software
>> > > + distributed under the License is distributed on an "AS IS" BASIS,
>> > > + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> > > implied.
>> > > + See the License for the specific language governing permissions
>> and
>> > > + limitations under the License.
>> > > +-->
>> > > +# Log4j Scala 2.12 API
>> > > +
>> > > +## Requirements
>> > > +
>> > > +Log4j Scala API for Scala 2.12 requires Log4j API, Java 8, the Scala
>> > > runtime
>> > > +library, and the Scala reflection library. To use Log4j as a logging
>> > > implementation,
>> > > +then Log4j Core must also be included. Instructions on using these
>> > > dependencies are
>> > > +in the [dependency information page][dependencies], and additional
>> > > information is
>> > > +included in the [Log4j artifacts][artifacts] page.
>> > > +
>> > > +## Example Usage
>> > > +
>> > > +<pre class="prettyprint linenums">
>> > > +import org.apache.logging.log4j.scala.Logging
>> > > +import org.apache.logging.log4j.Level
>> > > +
>> > > +class MyClass extends BaseClass with Logging {
>> > > + def doStuff(): Unit = {
>> > > + logger.info("Doing stuff")
>> > > + }
>> > > + def doStuffWithLevel(level: Level): Unit = {
>> > > + logger(level, "Doing stuff with arbitrary level")
>> > > + }
>> > > +}
>> > > +</pre>
>> > > +
>> > > +## Configuration
>> > > +
>> > > +Log4j Scala 2.12 API uses the standard [Log4j
>> > > configuration][configuration]
>> > > +plugins. This supports XML, properties files, and a configuration
>> > builder
>> > > DSL by
>> > > +default, and it optionally supports JSON and YAML formats with some
>> > > additional
>> > > +Jackson dependencies.
>> > > +
>> > > +## Substituting Parameters
>> > > +
>> > > +In the Java API, parameters to a log message are interpolated using
>> > > various
>> > > +strategies. In the Scala API, [string interpolation][interpolation]
>> is
>> > > used
>> > > +instead. As all logger methods are implemented as macros, string
>> > > construction and
>> > > +method invocations will only occur when logging is enabled for the
>> given
>> > > log
>> > > +level. For example:
>> > > +
>> > > +<pre class="prettyprint linenums">
>> > > +logger.debug(s"Logging in user ${user.getName} with birthday
>> > > ${user.calcBirthday}")
>> > > +</pre>
>> > > +
>> > > +## Logger Names
>> > > +
>> > > +Most logging implementations use a hierarchical scheme for matching
>> > > logger names
>> > > +with logging configuration. In this scheme the logger name hierarchy
>> is
>> > > +represented by '.' characters in the logger name, in a fashion very
>> > > similar to
>> > > +the hierarchy used for Java/Scala package names. The [`Logging`
>> > > trait][logging]
>> > > +will automatically name the Logger accordingly to the class it is
>> being
>> > > used in.
>> > > +
>> > > +[dependencies]: dependency-info.html
>> > > +[artifacts]: ../maven-artifacts.html
>> > > +[configuration]: ../configuration.html
>> > > +[interpolation]: http://docs.scala-lang.org/overviews/core/string-
>> > > interpolation.html
>> > > +[logging]: scaladocs/org/apache/logging/log4j/scala/Logging.html
>> > > \ No newline at end of file
>> > >
>> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > blob/184045cb/log4j-api-scala_2.13/src/site/site.xml
>> > > ------------------------------------------------------------
>> ----------
>> > > diff --git a/log4j-api-scala_2.13/src/site/site.xml
>> > > b/log4j-api-scala_2.13/src/site/site.xml
>> > > new file mode 100644
>> > > index 0000000..f46fa51
>> > > --- /dev/null
>> > > +++ b/log4j-api-scala_2.13/src/site/site.xml
>> > > @@ -0,0 +1,30 @@
>> > > +<?xml version="1.0" encoding="utf-8"?>
>> > > +<!--
>> > > + ~ Licensed to the Apache Software Foundation (ASF) under one or
>> more
>> > > + ~ contributor license agreements. See the NOTICE file distributed
>> with
>> > > + ~ this work for additional information regarding copyright
>> ownership.
>> > > + ~ The ASF licenses this file to You under the Apache license,
>> Version
>> > > 2.0
>> > > + ~ (the "License"); you may not use this file except in compliance
>> with
>> > > + ~ the License. You may obtain a copy of the License at
>> > > + ~
>> > > + ~ http://www.apache.org/licenses/LICENSE-2.0
>> > > + ~
>> > > + ~ Unless required by applicable law or agreed to in writing,
>> software
>> > > + ~ distributed under the License is distributed on an "AS IS" BASIS,
>> > > + ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> > > implied.
>> > > + ~ See the license for the specific language governing permissions
>> and
>> > > + ~ limitations under the license.
>> > > + -->
>> > > +<project name="Log4j Scala API"
>> > > + xmlns="http://maven.apache.org/DECORATION/1.7.0"
>> > > + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
>> > > + xsi:schemaLocation="http://maven.apache.org/DECORATION/1.7.
>> 0
>> > > http://maven.apache.org/xsd/decoration-1.7.0.xsd">
>> > > + <body>
>> > > + <links>
>> > > + <item name="Apache" href="http://www.apache.org/"/>
>> > > + <item name="Logging Services" href="
>> http://logging.apache.
>> > > org/"/>
>> > > + <item name="Log4j" href="../index.html"/>
>> > > + </links>
>> > > + <menu ref="reports"/>
>> > > + </body>
>> > > +</project>
>> > > \ No newline at end of file
>> > >
>> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > blob/184045cb/log4j-api-scala_2.13/src/test/scala/org/
>> > > apache/logging/log4j/scala/LoggerTest.scala
>> > > ------------------------------------------------------------
>> ----------
>> > > diff --git a/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
>> > log4j/scala/LoggerTest.scala
>> > > b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
>> > > log4j/scala/LoggerTest.scala
>> > > new file mode 100644
>> > > index 0000000..bd12742
>> > > --- /dev/null
>> > > +++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
>> > > log4j/scala/LoggerTest.scala
>> > > @@ -0,0 +1,552 @@
>> > > +/*
>> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
>> > > + * contributor license agreements. See the NOTICE file distributed
>> with
>> > > + * this work for additional information regarding copyright
>> ownership.
>> > > + * The ASF licenses this file to You under the Apache license,
>> Version
>> > 2.0
>> > > + * (the "License"); you may not use this file except in compliance
>> with
>> > > + * the License. You may obtain a copy of the License at
>> > > + *
>> > > + * http://www.apache.org/licenses/LICENSE-2.0
>> > > + *
>> > > + * Unless required by applicable law or agreed to in writing,
>> software
>> > > + * distributed under the License is distributed on an "AS IS" BASIS,
>> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> > > implied.
>> > > + * See the license for the specific language governing permissions
>> and
>> > > + * limitations under the license.
>> > > + */
>> > > +package org.apache.logging.log4j.scala
>> > > +
>> > > +import org.apache.logging.log4j.message.{DefaultFlowMessageFactory,
>> > > Message, ParameterizedMessage, ParameterizedMessageFactory}
>> > > +import org.apache.logging.log4j.spi.{AbstractLogger, ExtendedLogger}
>> > > +import org.apache.logging.log4j.{Level, Marker, MarkerManager}
>> > > +import org.junit.runner.RunWith
>> > > +import org.mockito.Matchers.{any, anyString, eq => eqv}
>> > > +import org.mockito.Mockito._
>> > > +import org.scalatest.junit.JUnitRunner
>> > > +import org.scalatest.mockito.MockitoSugar
>> > > +import org.scalatest.{FunSuite, Matchers}
>> > > +
>> > > +import scala.language.reflectiveCalls // needed for Mockito mocking
>> > > +
>> > > +case class Custom(i: Int)
>> > > +
>> > > +trait Manager {
>> > > + def fetchValue(): Int
>> > > +}
>> > > +
>> > > +@RunWith(classOf[JUnitRunner])
>> > > +class LoggerTest extends FunSuite with Matchers with MockitoSugar {
>> > > +
>> > > + val msg = new ParameterizedMessage("msg {}", 17)
>> > > + val entryMsg = new DefaultFlowMessageFactory().ne
>> wEntryMessage(msg)
>> > > + val cseqMsg: CharSequence = new StringBuilder().append("cseq msg")
>> > > + val objectMsg = Custom(17)
>> > > + val cause = new RuntimeException("cause")
>> > > + val marker = MarkerManager.getMarker("marker")
>> > > + val result = "foo"
>> > > +
>> > > + def fixture =
>> > > + new {
>> > > + val mockLogger = {
>> > > + val mockLogger = mock[ExtendedLogger]
>> > > + when(mockLogger.getMessageFactory).thenReturn(new
>> > > ParameterizedMessageFactory)
>> > > + mockLogger
>> > > + }
>> > > + val manager = {
>> > > + val mockManager = mock[Manager]
>> > > + when(mockManager.fetchValue()).thenReturn(4711)
>> > > + mockManager
>> > > + }
>> > > + }
>> > > +
>> > > + test("fatal enabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.FATAL),
>> > > eqv(null), any[Message], eqv(null))
>> > > + verify(f.manager).fetchValue()
>> > > + }
>> > > +
>> > > + test("fatal disabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + verify(f.manager, never).fetchValue()
>> > > + }
>> > > +
>> > > + test("error enabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.error(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.ERROR),
>> > > eqv(null), any[Message], eqv(null))
>> > > + verify(f.manager).fetchValue()
>> > > + }
>> > > +
>> > > + test("error disabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.error(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + verify(f.manager, never).fetchValue()
>> > > + }
>> > > +
>> > > + test("warn enabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.WARN),
>> > > eqv(null), any[Message], eqv(null))
>> > > + verify(f.manager).fetchValue()
>> > > + }
>> > > +
>> > > + test("warn disabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + verify(f.manager, never).fetchValue()
>> > > + }
>> > > +
>> > > + test("info enabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.info(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(null), any[Message], eqv(null))
>> > > + verify(f.manager).fetchValue()
>> > > + }
>> > > +
>> > > + test("info disabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.info(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + verify(f.manager, never).fetchValue()
>> > > + }
>> > > +
>> > > + test("debug enabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.DEBUG),
>> > > eqv(null), any[Message], eqv(null))
>> > > + verify(f.manager).fetchValue()
>> > > + }
>> > > +
>> > > + test("debug disabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + verify(f.manager, never).fetchValue()
>> > > + }
>> > > +
>> > > + test("trace enabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.TRACE),
>> > > eqv(null), any[Message], eqv(null))
>> > > + verify(f.manager).fetchValue()
>> > > + }
>> > > +
>> > > + test("trace disabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + verify(f.manager, never).fetchValue()
>> > > + }
>> > > +
>> > > +
>> > > + test("log enabled with Message message and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, msg)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(marker), eqv(msg), eqv(null))
>> > > + }
>> > > +
>> > > + test("log disabled with Message message and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, msg)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with String message and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, s"string msg with value:
>> > > ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(marker), any[Message], eqv(null))
>> > > + verify(f.manager).fetchValue()
>> > > + }
>> > > +
>> > > + test("log disabled with String message and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, s"string msg with value:
>> > > ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + verify(f.manager, never).fetchValue()
>> > > + }
>> > > +
>> > > + test("log enabled with CharSequence message and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, cseqMsg)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(marker), any[Message], eqv(null))
>> > > + }
>> > > +
>> > > + test("log disabled with CharSequence message and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, cseqMsg)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with Object message and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, objectMsg)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(marker), any[Message], eqv(null))
>> > > + }
>> > > +
>> > > + test("log disabled with Object message and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, objectMsg)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with Message message and cause and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, msg, cause)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(marker), eqv(msg), eqv(cause))
>> > > + }
>> > > +
>> > > + test("log disabled with Message message and cause and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, msg, cause)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with String message and cause and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, s"string msg with value:
>> > > ${f.manager.fetchValue()}", cause)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(marker), any[Message], eqv(cause))
>> > > + verify(f.manager).fetchValue()
>> > > + }
>> > > +
>> > > + test("log disabled with String message and cause and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, s"string msg with value:
>> > > ${f.manager.fetchValue()}", cause)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + verify(f.manager, never).fetchValue()
>> > > + }
>> > > +
>> > > + test("log enabled with CharSequence message and cause and Marker")
>> {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, cseqMsg, cause)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(marker), any[Message], eqv(cause))
>> > > + }
>> > > +
>> > > + test("log disabled with CharSequence message and cause and
>> Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, cseqMsg, cause)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with Object message and cause and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, objectMsg, cause)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(marker), any[Message], eqv(cause))
>> > > + }
>> > > +
>> > > + test("log disabled with Object message and cause and Marker") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO,
>> marker)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, marker, objectMsg, cause)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with Message message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, msg)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(null), eqv(msg), eqv(null))
>> > > + }
>> > > +
>> > > + test("log disabled with Message message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, msg)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, s"string msg with value:
>> > > ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(null), any[Message], eqv(null))
>> > > + verify(f.manager).fetchValue()
>> > > + }
>> > > +
>> > > + test("log disabled with String message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, s"string msg with value:
>> > > ${f.manager.fetchValue()}")
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + verify(f.manager, never).fetchValue()
>> > > + }
>> > > +
>> > > + test("log enabled with CharSequence message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, cseqMsg)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(null), any[Message], eqv(null))
>> > > + }
>> > > +
>> > > + test("log disabled with CharSequence message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, cseqMsg)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with Object message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, objectMsg)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(null), any[Message], eqv(null))
>> > > + }
>> > > +
>> > > + test("log disabled with Object message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, objectMsg)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with Message message and cause") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, msg, cause)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(null), eqv(msg), eqv(cause))
>> > > + }
>> > > +
>> > > + test("log disabled with Message message and cause") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, msg, cause)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with String message and cause") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, s"string msg with value:
>> > > ${f.manager.fetchValue()}", cause)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(null), any[Message], eqv(cause))
>> > > + verify(f.manager).fetchValue()
>> > > + }
>> > > +
>> > > + test("log disabled with String message and cause") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, s"string msg with value:
>> > > ${f.manager.fetchValue()}", cause)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + verify(f.manager, never).fetchValue()
>> > > + }
>> > > +
>> > > + test("log enabled with CharSequence message and cause") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, cseqMsg, cause)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(null), any[Message], eqv(cause))
>> > > + }
>> > > +
>> > > + test("log disabled with CharSequence message and cause") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, cseqMsg, cause)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > + test("log enabled with Object message and cause") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, objectMsg, cause)
>> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
>> > > eqv(null), any[Message], eqv(cause))
>> > > + }
>> > > +
>> > > + test("log disabled with Object message and cause") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger(Level.INFO, objectMsg, cause)
>> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
>> > > any[Marker], any[Message], any[Throwable])
>> > > + }
>> > > +
>> > > +
>> > > + test("traceEntry") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
>> > > null)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceEntry()
>> > > + verify(f.mockLogger).traceEntry()
>> > > + }
>> > > +
>> > > + test("traceEntry enabled with params") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
>> > > null)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceEntry("foo", "bar")
>> > > + verify(f.mockLogger).traceEntry(null: String, "foo", "bar")
>> > > + }
>> > > +
>> > > + test("traceEntry disabled with params") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
>> > > null)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceEntry("foo", "bar")
>> > > + verify(f.mockLogger, never).traceEntry(anyString(), anyString(),
>> > > anyString())
>> > > + }
>> > > +
>> > > + test("traceEntry enabled with message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
>> > > null)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceEntry(msg)
>> > > + verify(f.mockLogger).traceEntry(eqv(msg))
>> > > + }
>> > > +
>> > > + test("traceEntry disabled with message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
>> > > null)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceEntry(msg)
>> > > + verify(f.mockLogger, never).traceEntry(any[Message])
>> > > + }
>> > > +
>> > > + test("traceExit") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > AbstractLogger.EXIT_MARKER,
>> > > msg, null)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceExit()
>> > > + verify(f.mockLogger).traceExit()
>> > > + }
>> > > +
>> > > + test("traceExit with result") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > AbstractLogger.EXIT_MARKER,
>> > > msg, null)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceExit(result)
>> > > + verify(f.mockLogger).traceExit(result)
>> > > + }
>> > > +
>> > > + test("traceExit with entrymessage") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > AbstractLogger.EXIT_MARKER,
>> > > msg, null)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceExit(entryMsg)
>> > > + verify(f.mockLogger).traceExit(entryMsg)
>> > > + }
>> > > +
>> > > + test("traceExit with entrymessage and result") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > AbstractLogger.EXIT_MARKER,
>> > > msg, null)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceExit(entryMsg, result)
>> > > + verify(f.mockLogger).traceExit(entryMsg, result)
>> > > + }
>> > > +
>> > > + test("traceExit enabled with message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > AbstractLogger.EXIT_MARKER,
>> > > msg, null)).thenReturn(true)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceExit(msg, result)
>> > > + verify(f.mockLogger).traceExit(eqv(msg), eqv(result))
>> > > + }
>> > > +
>> > > + test("traceExit disabled with message") {
>> > > + val f = fixture
>> > > + when(f.mockLogger.isEnabled(Level.TRACE,
>> > AbstractLogger.EXIT_MARKER,
>> > > msg, null)).thenReturn(false)
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.traceExit(msg, result)
>> > > + verify(f.mockLogger, never).traceExit(any[Message], any[AnyRef])
>> > > + }
>> > > +
>> > > + test("throwing") {
>> > > + val f = fixture
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.throwing(cause)
>> > > + verify(f.mockLogger).throwing(eqv(cause))
>> > > + }
>> > > +
>> > > + test("throwing with level") {
>> > > + val f = fixture
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.throwing(Level.INFO, cause)
>> > > + verify(f.mockLogger).throwing(eqv(Level.INFO), eqv(cause))
>> > > + }
>> > > +
>> > > + test("catching") {
>> > > + val f = fixture
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.catching(cause)
>> > > + verify(f.mockLogger).catching(eqv(cause))
>> > > + }
>> > > +
>> > > + test("catching with level") {
>> > > + val f = fixture
>> > > + val logger = Logger(f.mockLogger)
>> > > + logger.catching(Level.INFO, cause)
>> > > + verify(f.mockLogger).catching(eqv(Level.INFO), eqv(cause))
>> > > + }
>> > > +
>> > > +}
>> > >
>> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > blob/184045cb/log4j-api-scala_2.13/src/test/scala/org/
>> > > apache/logging/log4j/scala/LoggingContextTest.scala
>> > > ------------------------------------------------------------
>> ----------
>> > > diff --git a/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
>> > > log4j/scala/LoggingContextTest.scala b/log4j-api-scala_2.13/src/
>> > > test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
>> > > new file mode 100644
>> > > index 0000000..80ca940
>> > > --- /dev/null
>> > > +++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
>> > log4j/scala/
>> > > LoggingContextTest.scala
>> > > @@ -0,0 +1,115 @@
>> > > +/*
>> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
>> > > + * contributor license agreements. See the NOTICE file distributed
>> with
>> > > + * this work for additional information regarding copyright
>> ownership.
>> > > + * The ASF licenses this file to You under the Apache license,
>> Version
>> > 2.0
>> > > + * (the "License"); you may not use this file except in compliance
>> with
>> > > + * the License. You may obtain a copy of the License at
>> > > + *
>> > > + * http://www.apache.org/licenses/LICENSE-2.0
>> > > + *
>> > > + * Unless required by applicable law or agreed to in writing,
>> software
>> > > + * distributed under the License is distributed on an "AS IS" BASIS,
>> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
>> > > implied.
>> > > + * See the license for the specific language governing permissions
>> and
>> > > + * limitations under the license.
>> > > + */
>> > > +package org.apache.logging.log4j.scala
>> > > +
>> > > +import org.junit.runner.RunWith
>> > > +import org.scalatest.junit.JUnitRunner
>> > > +import org.scalatest.{FunSuite, Matchers}
>> > > +
>> > > +import scala.collection.mutable
>> > > +
>> > > +@RunWith(classOf[JUnitRunner])
>> > > +class LoggingContextTest extends FunSuite with Matchers {
>> > > +
>> > > + test("put single, contains, get") {
>> > > + LoggingContext += "key" -> "value"
>> > > +
>> > > + LoggingContext.contains("key") shouldBe true
>> > > + LoggingContext.get("key") shouldBe Some("value")
>> > > + LoggingContext.contains("bogus") shouldBe false
>> > > + LoggingContext.get("bogus") shouldBe None
>> > > + }
>> > > +
>> > > + test("put multiple 1") {
>> > > + LoggingContext += ("key1" -> "value1", "key2" -> "value2")
>> > > +
>> > > + LoggingContext.get("key1") shouldBe Some("value1")
>> > > + LoggingContext.get("key2") shouldBe Some("value2")
>> > > + }
>> > > +
>> > > + test("put multiple 2") {
>> > > + LoggingContext ++= Seq("key1" -> "value1", "key2" -> "value2")
>> > > +
>> > > + LoggingContext.get("key1") shouldBe Some("value1")
>> > > + LoggingContext.get("key2") shouldBe Some("value2")
>> > > + }
>> > > +
>> > > + test("remove single") {
>> > > + LoggingContext += ("key1" -> "value1")
>> > > + LoggingContext += ("key2" -> "value2")
>> > > + LoggingContext += ("key3" -> "value3")
>> > > +
>> > > + LoggingContext -= "key1"
>> > > +
>> > > + LoggingContext.get("key1") shouldBe None
>> > > + LoggingContext.get("key2") shouldBe Some("value2")
>> > > + LoggingContext.get("key3") shouldBe Some("value3")
>> > > + }
>> > > +
>> > > + test("remove multiple 1") {
>> > > + LoggingContext += ("key1" -> "value1")
>> > > + LoggingContext += ("key2" -> "value2")
>> > > + LoggingContext += ("key3" -> "value3")
>> > > +
>> > > + LoggingContext -= ("key1", "key2")
>> > > +
>> > > + LoggingContext.get("key1") shouldBe None
>> > > + LoggingContext.get("key2") shouldBe None
>> > > + LoggingContext.get("key3") shouldBe Some("value3")
>> > > + }
>> > > +
>> > > + test("remove multiple 2") {
>> > > + LoggingContext += ("key1" -> "value1")
>> > > + LoggingContext += ("key2" -> "value2")
>> > > + LoggingContext += ("key3" -> "value3")
>> > > +
>> > > + LoggingContext --= Seq("key1", "key2")
>> > > +
>> > > + LoggingContext.get("key1") shouldBe None
>> > > + LoggingContext.get("key2") shouldBe None
>> > > + LoggingContext.get("key3") shouldBe Some("value3")
>> > > + }
>> > > +
>> > > + test("clear, size, isEmpty") {
>> > > + LoggingContext += ("key" -> "value")
>> > > +
>> > > + LoggingContext.clear()
>> > > +
>> > > + LoggingContext.contains("key") shouldBe false
>> > > + LoggingContext.size shouldBe 0
>> > > + LoggingContext.isEmpty shouldBe true
>> > > + }
>> > > +
>> > > + test("iterator") {
>> > > + LoggingContext += ("key1" -> "value1")
>> > > + LoggingContext += ("key2" -> "value2")
>> > > +
>> > > + LoggingContext.iterator.toSet shouldBe Set("key1" -> "value1",
>> > "key2"
>> > > -> "value2")
>> > > + }
>> > > +
>> > > + test("foreach") {
>> > > + LoggingContext += ("key1" -> "value1")
>> > > + LoggingContext += ("key2" -> "value2")
>> > > +
>> > > + val result = mutable.Set.empty[(String, String)]
>> > > +
>> > > + LoggingContext.foreach { result += _ }
>> > > +
>> > > + result shouldBe Set("key1" -> "value1", "key2" -> "value2")
>> > > + }
>> > > +
>> > > +}
>> > >
>> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
>> > > blob/184045cb/pom.xml
>> > > ------------------------------------------------------------
>> ----------
>> > > diff --git a/pom.xml b/pom.xml
>> > > index 1068ecb..c26cc7a 100644
>> > > --- a/pom.xml
>> > > +++ b/pom.xml
>> > > @@ -106,6 +106,7 @@
>> > > <module>log4j-api-scala_2.10</module>
>> > > <module>log4j-api-scala_2.11</module>
>> > > <module>log4j-api-scala_2.12</module>
>> > > +<!--<module>log4j-api-scala_2.13</module> -->
>> > > <module>log4j-api-scala-sample</module>
>> > > </modules>
>> > >
>> > >
>> > >
>> >
>> >
>> > --
>> > Matt Sicker <bo...@gmail.com>
>> >
>>
>
>
>
> --
> Matt Sicker <bo...@gmail.com>
>
--
Matt Sicker <bo...@gmail.com>
Re: logging-log4j-scala git commit: Add placeholder for Scala 2.13
but do not enable the module.
Posted by Matt Sicker <bo...@gmail.com>.
The module name reflects the version of Scala (or Scala.js, Scala Native,
SBT, etc.) it was compiled for. With at least Scala 2.10 and beyond,
version-specific artifacts can be done for major versions. With a milestone
release, I don't think there is guaranteed binary compatibility with the
actual release.
Perhaps just publishing it as a snapshot only would work? That way, users
testing out Scala 2.13 can just pull in the snapshot.
On 11 November 2017 at 17:49, Gary Gregory <ga...@gmail.com> wrote:
> On Sat, Nov 11, 2017 at 3:51 PM, Matt Sicker <bo...@gmail.com> wrote:
>
> > I've seen on Maven Central before that a few Scala libraries have
> published
> > artifacts for 2.13.0 milestones. See for example: <
> > https://search.maven.org/#artifactdetails%7Corg.
> > scalatest%7Cscalatest_2.13.0-M2%7C3.0.4%7Cbundle>.
> > It seems like if we published the module by naming it
> > "log4j-api-scala_2.13.0-M2", we could have a version specific to that
> > milestone at least.
> >
>
> Hi Matt,
>
> The scalatest module has the milestone number in the name but not
> scala-library for example.
>
> Why bother with changing the module name. If it came out today, our version
> 12.0 of log4j-api-scala_2.13 would be at the 2.13.0-M2 level. Then our 13.0
> can be at the next M level and so on.
>
> What am I missing?
>
> Gary
>
>
> > On 11 November 2017 at 16:26, <gg...@apache.org> wrote:
> >
> > > Repository: logging-log4j-scala
> > > Updated Branches:
> > > refs/heads/master 5a71e5caa -> 184045cbc
> > >
> > >
> > > Add placeholder for Scala 2.13 but do not enable the module.
> > >
> > > Project: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> repo
> > > Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > commit/184045cb
> > > Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > tree/184045cb
> > > Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > diff/184045cb
> > >
> > > Branch: refs/heads/master
> > > Commit: 184045cbc7a517faef2a709aa68e83d7a0053599
> > > Parents: 5a71e5c
> > > Author: Gary Gregory <gg...@apache.org>
> > > Authored: Sat Nov 11 15:26:01 2017 -0700
> > > Committer: Gary Gregory <gg...@apache.org>
> > > Committed: Sat Nov 11 15:26:01 2017 -0700
> > >
> > > ----------------------------------------------------------------------
> > > log4j-api-scala_2.13/pom.xml | 145 +++++
> > > .../org/apache/logging/log4j/scala/Logger.scala | 592
> > +++++++++++++++++++
> > > .../logging/log4j/scala/LoggerMacro.scala | 425 +++++++++++++
> > > .../apache/logging/log4j/scala/Logging.scala | 30 +
> > > .../logging/log4j/scala/LoggingContext.scala | 84 +++
> > > log4j-api-scala_2.13/src/site/markdown/index.md | 74 +++
> > > log4j-api-scala_2.13/src/site/site.xml | 30 +
> > > .../apache/logging/log4j/scala/LoggerTest.scala | 552
> +++++++++++++++++
> > > .../log4j/scala/LoggingContextTest.scala | 115 ++++
> > > pom.xml | 1 +
> > > 10 files changed, 2048 insertions(+)
> > > ----------------------------------------------------------------------
> > >
> > >
> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > blob/184045cb/log4j-api-scala_2.13/pom.xml
> > > ----------------------------------------------------------------------
> > > diff --git a/log4j-api-scala_2.13/pom.xml
> b/log4j-api-scala_2.13/pom.xml
> > > new file mode 100644
> > > index 0000000..ea0f19c
> > > --- /dev/null
> > > +++ b/log4j-api-scala_2.13/pom.xml
> > > @@ -0,0 +1,145 @@
> > > +<?xml version="1.0" encoding="UTF-8"?>
> > > +<!--
> > > + Licensed to the Apache Software Foundation (ASF) under one or more
> > > + contributor license agreements. See the NOTICE file distributed with
> > > + this work for additional information regarding copyright ownership.
> > > + The ASF licenses this file to You under the Apache License, Version
> 2.0
> > > + (the "License"); you may not use this file except in compliance with
> > > + the License. You may obtain a copy of the License at
> > > +
> > > + http://www.apache.org/licenses/LICENSE-2.0
> > > +
> > > + Unless required by applicable law or agreed to in writing, software
> > > + distributed under the License is distributed on an "AS IS" BASIS,
> > > + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > > + See the License for the specific language governing permissions and
> > > + limitations under the License.
> > > +-->
> > > +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="
> > > http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://
> > > maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd
> ">
> > > + <modelVersion>4.0.0</modelVersion>
> > > + <parent>
> > > + <groupId>org.apache.logging.log4j</groupId>
> > > + <artifactId>log4j-scala</artifactId>
> > > + <version>12.0-SNAPSHOT</version>
> > > + <relativePath>../</relativePath>
> > > + </parent>
> > > + <artifactId>log4j-api-scala_2.13</artifactId>
> > > + <packaging>jar</packaging>
> > > + <name>Scala 2.13 wrapper for Log4j API</name>
> > > + <description>Scala wrapper for Log4j API</description>
> > > + <properties>
> > > + <log4jParentDir>${basedir}/..</log4jParentDir>
> > > + <projectDir>/scala_2.13</projectDir>
> > > + <scala.version>2.13.0-M2</scala.version>
> > > + <scala.maven.plugin.version>3.3.1</scala.maven.plugin.version>
> > > + <maven.compiler.source>1.8</maven.compiler.source>
> > > + <maven.compiler.target>1.8</maven.compiler.target>
> > > + </properties>
> > > + <dependencies>
> > > + <dependency>
> > > + <groupId>org.apache.logging.log4j</groupId>
> > > + <artifactId>log4j-api</artifactId>
> > > + </dependency>
> > > + <dependency>
> > > + <groupId>org.scala-lang</groupId>
> > > + <artifactId>scala-library</artifactId>
> > > + <version>${scala.version}</version>
> > > + </dependency>
> > > + <dependency>
> > > + <groupId>org.scala-lang</groupId>
> > > + <artifactId>scala-reflect</artifactId>
> > > + <version>${scala.version}</version>
> > > + </dependency>
> > > + <dependency>
> > > + <groupId>org.apache.logging.log4j</groupId>
> > > + <artifactId>log4j-api</artifactId>
> > > + <type>test-jar</type>
> > > + <scope>test</scope>
> > > + </dependency>
> > > + <dependency>
> > > + <groupId>junit</groupId>
> > > + <artifactId>junit</artifactId>
> > > + <scope>test</scope>
> > > + </dependency>
> > > + <dependency>
> > > + <groupId>org.scalatest</groupId>
> > > + <artifactId>scalatest_2.13.0-M2</artifactId>
> > > + <version>3.0.4</version>
> > > + <scope>test</scope>
> > > + </dependency>
> > > + <dependency>
> > > + <groupId>org.mockito</groupId>
> > > + <artifactId>mockito-core</artifactId>
> > > + <version>1.10.19</version>
> > > + <scope>test</scope>
> > > + </dependency>
> > > + </dependencies>
> > > + <build>
> > > + <sourceDirectory>src/main/scala</sourceDirectory>
> > > + <testSourceDirectory>src/test/scala</testSourceDirectory>
> > > + <plugins>
> > > + <plugin>
> > > + <groupId>net.alchim31.maven</groupId>
> > > + <artifactId>scala-maven-plugin</artifactId>
> > > + <version>${scala.maven.plugin.version}</version>
> > > + <executions>
> > > + <execution>
> > > + <goals>
> > > + <goal>compile</goal>
> > > + <goal>testCompile</goal>
> > > + <goal>doc-jar</goal>
> > > + </goals>
> > > + </execution>
> > > + </executions>
> > > + <configuration>
> > > + <args>
> > > + <arg>-feature</arg>
> > > + <arg>-unchecked</arg>
> > > + <arg>-deprecation</arg>
> > > + </args>
> > > + </configuration>
> > > + </plugin>
> > > + <plugin>
> > > + <groupId>org.apache.maven.plugins</groupId>
> > > + <artifactId>maven-surefire-plugin</artifactId>
> > > + </plugin>
> > > + <plugin>
> > > + <groupId>org.apache.felix</groupId>
> > > + <artifactId>maven-bundle-plugin</artifactId>
> > > + </plugin>
> > > + </plugins>
> > > + </build>
> > > + <reporting>
> > > + <plugins>
> > > + <plugin>
> > > + <groupId>org.apache.maven.plugins</groupId>
> > > + <artifactId>maven-changes-plugin</artifactId>
> > > + <version>${changes.plugin.version}</version>
> > > + <reportSets>
> > > + <reportSet>
> > > + <reports>
> > > + <report>changes-report</report>
> > > + </reports>
> > > + </reportSet>
> > > + </reportSets>
> > > + <configuration>
> > > + <issueLinkTemplate>%URL%/show_bug.cgi?id=%ISSUE%</
> > > issueLinkTemplate>
> > > + <useJql>true</useJql>
> > > + </configuration>
> > > + </plugin>
> > > + <plugin>
> > > + <groupId>org.apache.maven.plugins</groupId>
> > > + <artifactId>maven-pmd-plugin</artifactId>
> > > + <version>${pmd.plugin.version}</version>
> > > + <configuration>
> > > + <targetJdk>${maven.compiler.target}</targetJdk>
> > > + </configuration>
> > > + </plugin>
> > > + <plugin>
> > > + <groupId>net.alchim31.maven</groupId>
> > > + <artifactId>scala-maven-plugin</artifactId>
> > > + <version>${scala.maven.plugin.version}</version>
> > > + </plugin>
> > > + </plugins>
> > > + </reporting>
> > > +</project>
> > >
> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> > > apache/logging/log4j/scala/Logger.scala
> > > ----------------------------------------------------------------------
> > > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/Logger.scala
> > > b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > > log4j/scala/Logger.scala
> > > new file mode 100644
> > > index 0000000..b42cd5a
> > > --- /dev/null
> > > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > > log4j/scala/Logger.scala
> > > @@ -0,0 +1,592 @@
> > > +/*
> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > > + * contributor license agreements. See the NOTICE file distributed
> with
> > > + * this work for additional information regarding copyright ownership.
> > > + * The ASF licenses this file to You under the Apache license, Version
> > 2.0
> > > + * (the "License"); you may not use this file except in compliance
> with
> > > + * the License. You may obtain a copy of the License at
> > > + *
> > > + * http://www.apache.org/licenses/LICENSE-2.0
> > > + *
> > > + * Unless required by applicable law or agreed to in writing, software
> > > + * distributed under the License is distributed on an "AS IS" BASIS,
> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > > implied.
> > > + * See the license for the specific language governing permissions and
> > > + * limitations under the license.
> > > + */
> > > +package org.apache.logging.log4j.scala
> > > +
> > > +import org.apache.logging.log4j.message.{EntryMessage, Message,
> > > MessageFactory2}
> > > +import org.apache.logging.log4j.spi.ExtendedLogger
> > > +import org.apache.logging.log4j.{Level, LogManager, Marker}
> > > +
> > > +import scala.language.experimental.macros
> > > +
> > > +/**
> > > + * Factory for [[Logger]]s.
> > > + *
> > > + * The [[Logging]] trait provides a simple way to get a properly
> named
> > > logger into a class.
> > > + */
> > > +object Logger {
> > > +
> > > + final val FQCN = getClass.getName
> > > +
> > > + /**
> > > + * Create a properly named [[Logger]] for a given class.
> > > + *
> > > + * @param clazz the class
> > > + */
> > > + def apply(clazz: Class[_]): Logger = Logger(LogManager.getContext(
> > clazz.getClassLoader,
> > > false).getLogger(clazz.getName))
> > > +
> > > + /**
> > > + * Create a [[Logger]] wrapping the given Log4j logger.
> > > + *
> > > + * @param delegate the Log4j logger to wrap
> > > + */
> > > + def apply(delegate: ExtendedLogger): Logger = new Logger(delegate)
> > > +
> > > +}
> > > +
> > > +/**
> > > + * Scala wrapper for the Log4j `Logger` interface.
> > > + *
> > > + * Frequently the purpose of logging is to provide information about
> > > what is happening in the system,
> > > + * which requires including information about the objects being
> > > manipulated. In Scala, you can use
> > > + * [[http://docs.scala-lang.org/overviews/core/string-
> > interpolation.html
> > > string interpolation]]
> > > + * to achieve this:
> > > + *
> > > + * {{{
> > > + * logger.debug(s"Logging in user ${user.getName} with birthday
> > > ${user.calcBirthday}")
> > > + * }}}
> > > + *
> > > + * Since this wrapper is implemented with macros, the String
> > > construction and method invocations
> > > + * will only occur when debug logging is enabled.
> > > + */
> > > +class Logger private(val delegate: ExtendedLogger) extends AnyVal {
> > > +
> > > + def fatal(marker: Marker, message: Message): Unit =
> > > + macro LoggerMacro.fatalMarkerMsg
> > > +
> > > + def fatal(marker: Marker, message: CharSequence): Unit =
> > > + macro LoggerMacro.fatalMarkerCseq
> > > +
> > > + 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.fatalMarkerCseqThrowable
> > > +
> > > + 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.fatalCseq
> > > +
> > > + 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.fatalCseqThrowable
> > > +
> > > + 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: CharSequence): Unit =
> > > + macro LoggerMacro.errorMarkerCseq
> > > +
> > > + 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.errorMarkerCseqThrowable
> > > +
> > > + 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.errorCseq
> > > +
> > > + 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.errorCseqThrowable
> > > +
> > > + 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: CharSequence): Unit =
> > > + macro LoggerMacro.warnMarkerCseq
> > > +
> > > + 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.warnMarkerCseqThrowable
> > > +
> > > + 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.warnCseq
> > > +
> > > + 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.warnCseqThrowable
> > > +
> > > + 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: CharSequence): Unit =
> > > + macro LoggerMacro.infoMarkerCseq
> > > +
> > > + 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.infoMarkerCseqThrowable
> > > +
> > > + 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.infoCseq
> > > +
> > > + 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.infoCseqThrowable
> > > +
> > > + 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: CharSequence): Unit =
> > > + macro LoggerMacro.debugMarkerCseq
> > > +
> > > + 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.debugMarkerCseqThrowable
> > > +
> > > + 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.debugCseq
> > > +
> > > + 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.debugCseqThrowable
> > > +
> > > + 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: CharSequence): Unit =
> > > + macro LoggerMacro.traceMarkerCseq
> > > +
> > > + 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.traceMarkerCseqThrowable
> > > +
> > > + 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.traceCseq
> > > +
> > > + 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.traceCseqThrowable
> > > +
> > > + def trace(message: AnyRef, cause: Throwable): Unit =
> > > + macro LoggerMacro.traceObjectThrowable
> > > +
> > > +
> > > + /**
> > > + * Logs a `Message` with the specific `Marker` at the given
> `Level`.
> > > + *
> > > + * @param level the logging level
> > > + * @param marker the marker data specific to this log statement
> > > + * @param message the message to be logged
> > > + */
> > > + def apply(level: Level, marker: Marker, message: Message): Unit =
> > > + macro LoggerMacro.logMarkerMsg
> > > +
> > > + /**
> > > + * Logs a string with the specific `Marker` at the given `Level`.
> > > + *
> > > + * @param level the logging level
> > > + * @param marker the marker data specific to this log statement
> > > + * @param message the message to be logged
> > > + */
> > > + def apply(level: Level, marker: Marker, message: CharSequence):
> Unit =
> > > + macro LoggerMacro.logMarkerCseq
> > > +
> > > + /**
> > > + * Logs an object with the specific `Marker` at the given `Level`.
> > > + *
> > > + * @param level the logging level
> > > + * @param marker the marker data specific to this log statement
> > > + * @param message the message to be logged
> > > + */
> > > + def apply(level: Level, marker: Marker, message: AnyRef): Unit =
> > > + macro LoggerMacro.logMarkerObject
> > > +
> > > + /**
> > > + * Logs a `Message` with the specific `Marker` at the given `Level`
> > > including the stack trace
> > > + * of the given `Throwable`.
> > > + *
> > > + * @param level the logging level
> > > + * @param marker the marker data specific to this log statement
> > > + * @param message the message to be logged
> > > + * @param cause the cause
> > > + */
> > > + def apply(level: Level, marker: Marker, message: Message, cause:
> > > Throwable): Unit =
> > > + macro LoggerMacro.logMarkerMsgThrowable
> > > +
> > > + /**
> > > + * Logs a string with the specific `Marker` at the given `Level`
> > > including the stack trace
> > > + * of the given `Throwable`.
> > > + *
> > > + * @param level the logging level
> > > + * @param marker the marker data specific to this log statement
> > > + * @param message the message to be logged
> > > + * @param cause the cause
> > > + */
> > > + def apply(level: Level, marker: Marker, message: CharSequence,
> cause:
> > > Throwable): Unit =
> > > + macro LoggerMacro.logMarkerCseqThrowable
> > > +
> > > + /**
> > > + * Logs an object with the specific `Marker` at the given `Level`
> > > including the stack trace
> > > + * of the given `Throwable`.
> > > + *
> > > + * @param level the logging level
> > > + * @param marker the marker data specific to this log statement
> > > + * @param message the message to be logged
> > > + * @param cause the cause
> > > + */
> > > + def apply(level: Level, marker: Marker, message: AnyRef, cause:
> > > Throwable): Unit =
> > > + macro LoggerMacro.logMarkerObjectThrowable
> > > +
> > > + /**
> > > + * Logs a `Message` at the given `Level`.
> > > + *
> > > + * @param level the logging level
> > > + * @param message the message to be logged
> > > + */
> > > + def apply(level: Level, message: Message): Unit =
> > > + macro LoggerMacro.logMsg
> > > +
> > > + /**
> > > + * Logs a string at the given `Level`.
> > > + *
> > > + * @param level the logging level
> > > + * @param message the message to be logged
> > > + */
> > > + def apply(level: Level, message: CharSequence): Unit =
> > > + macro LoggerMacro.logCseq
> > > +
> > > + /**
> > > + * Logs an object at the given `Level`.
> > > + *
> > > + * @param level the logging level
> > > + * @param message the message to be logged
> > > + */
> > > + def apply(level: Level, message: AnyRef): Unit =
> > > + macro LoggerMacro.logObject
> > > +
> > > + /**
> > > + * Logs a `Message` at the given `Level` including the stack trace
> of
> > > the given `Throwable`.
> > > + *
> > > + * @param level the logging level
> > > + * @param message the message to be logged
> > > + * @param cause a `Throwable`
> > > + */
> > > + def apply(level: Level, message: Message, cause: Throwable): Unit =
> > > + macro LoggerMacro.logMsgThrowable
> > > +
> > > + /**
> > > + * Logs a string at the given `Level` including the stack trace of
> > the
> > > given `Throwable`.
> > > + *
> > > + * @param level the logging level
> > > + * @param message the message to be logged
> > > + * @param cause a `Throwable`
> > > + */
> > > + def apply(level: Level, message: CharSequence, cause: Throwable):
> > Unit =
> > > + macro LoggerMacro.logCseqThrowable
> > > +
> > > + /**
> > > + * Logs an object at the given `Level` including the stack trace of
> > > the given `Throwable`.
> > > + *
> > > + * @param level the logging level
> > > + * @param message the message to be logged
> > > + * @param cause a `Throwable`
> > > + */
> > > + def apply(level: Level, message: AnyRef, cause: Throwable): Unit =
> > > + macro LoggerMacro.logObjectThrowable
> > > +
> > > +
> > > + /**
> > > + * Logs entry to a method. Used when the method in question has no
> > > parameters or when the parameters should not be
> > > + * logged.
> > > + *
> > > + * @return The built `EntryMessage`
> > > + */
> > > + def traceEntry(): EntryMessage =
> > > + macro LoggerMacro.traceEntry
> > > +
> > > + /**
> > > + * Logs entry to a method along with its parameters.
> > > + *
> > > + * {{{
> > > + * def doSomething(foo: String, bar: Int): Unit = {
> > > + * logger.traceEntry(foo, bar)
> > > + * // do something
> > > + * }
> > > + * }}}
> > > + *
> > > + * @param params the parameters to the method.
> > > + * @return The built `EntryMessage`
> > > + */
> > > + def traceEntry(params: AnyRef*): EntryMessage =
> > > + macro LoggerMacro.traceEntryParams
> > > +
> > > + /**
> > > + * Logs entry to a method using a `Message` to describe the
> > parameters.
> > > + *
> > > + * {{{
> > > + * def doSomething(foo: Request): Unit = {
> > > + * logger.traceEntry(JsonMessage(foo))
> > > + * // do something
> > > + * }
> > > + * }}}
> > > + *
> > > + * @param message the message
> > > + * @return The built `EntryMessage`
> > > + */
> > > + def traceEntry(message: Message): EntryMessage =
> > > + macro LoggerMacro.traceEntryMessage
> > > +
> > > + /**
> > > + * Logs exit from a method with no result.
> > > + */
> > > + def traceExit(): Unit =
> > > + macro LoggerMacro.traceExit
> > > +
> > > + /**
> > > + * Logs exiting from a method with result.
> > > + *
> > > + * @param result The result being returned from the method call
> > > + * @return `result`
> > > + */
> > > + def traceExit[R](result: R): R =
> > > + macro LoggerMacro.traceExitResult[R]
> > > +
> > > + /**
> > > + * Logs exiting from a method with no result.
> > > + *
> > > + * @param entryMessage the `EntryMessage` returned from one of the
> > > `traceEntry` methods
> > > + */
> > > + def traceExit(entryMessage: EntryMessage): Unit =
> > > + macro LoggerMacro.traceExitEntryMessage
> > > +
> > > + /**
> > > + * Logs exiting from a method with result.
> > > + *
> > > + * {{{
> > > + * def doSomething(foo: String, bar: Int): Int = {
> > > + * val entryMessage = logger.traceEntry(foo, bar)
> > > + * // do something
> > > + * traceExit(entryMessage, value)
> > > + * }
> > > + * }}}
> > > + *
> > > + * @param entryMessage the `EntryMessage` returned from one of the
> > > `traceEntry` methods
> > > + * @param result The result being returned from the method
> call
> > > + * @return `result`
> > > + */
> > > + def traceExit[R](entryMessage: EntryMessage, result: R): R =
> > > + macro LoggerMacro.traceExitEntryMessageResult[R]
> > > +
> > > + /**
> > > + * Logs exiting from a method with result. Allows custom formatting
> > of
> > > the result.
> > > + *
> > > + * @param message the Message containing the formatted result
> > > + * @param result The result being returned from the method call.
> > > + * @return `result`
> > > + */
> > > + def traceExit[R](message: Message, result: R): R =
> > > + macro LoggerMacro.traceExitMessageResult[R]
> > > +
> > > + /**
> > > + * Logs an exception or error to be thrown.
> > > + *
> > > + * {{{
> > > + * throw logger.throwing(myException)
> > > + * }}}
> > > + *
> > > + * @param t the Throwable
> > > + * @return `t`
> > > + */
> > > + def throwing[T <: Throwable](t: T): T =
> > > + macro LoggerMacro.throwing[T]
> > > +
> > > + /**
> > > + * Logs an exception or error to be thrown to a specific logging
> > level.
> > > + *
> > > + * {{{
> > > + * throw logger.throwing(Level.DEBUG, myException)
> > > + * }}}
> > > + *
> > > + * @param level the logging Level.
> > > + * @param t the Throwable
> > > + * @return `t`
> > > + */
> > > + def throwing[T <: Throwable](level: Level, t: T): T =
> > > + macro LoggerMacro.throwingLevel[T]
> > > +
> > > + /**
> > > + * Logs an exception or error that has been caught.
> > > + *
> > > + * @param t the Throwable.
> > > + */
> > > + def catching(t: Throwable): Unit =
> > > + macro LoggerMacro.catching
> > > +
> > > + /**
> > > + * Logs an exception or error that has been caught to a specific
> > > logging level.
> > > + *
> > > + * @param level The logging Level.
> > > + * @param t The Throwable.
> > > + */
> > > + def catching(level: Level, t: Throwable): Unit =
> > > + macro LoggerMacro.catchingLevel
> > > +
> > > +
> > > + /** 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: Message,
> cause:
> > > Throwable): Unit = {
> > > + delegate.logMessage(Logger.FQCN, level, marker, 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: CharSequence,
> > > cause: Throwable): Unit = {
> > > + delegate.logMessage(Logger.FQCN, level, marker,
> > > delegate.getMessageFactory.asInstanceOf[MessageFactory2].
> > 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(Logger.FQCN, level, marker,
> > > delegate.getMessageFactory.asInstanceOf[MessageFactory2].
> > newMessage(message),
> > > cause)
> > > + }
> > > +
> > > +}
> > >
> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> > > apache/logging/log4j/scala/LoggerMacro.scala
> > > ----------------------------------------------------------------------
> > > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/LoggerMacro.scala
> > > b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > > log4j/scala/LoggerMacro.scala
> > > new file mode 100644
> > > index 0000000..3b54db1
> > > --- /dev/null
> > > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > > log4j/scala/LoggerMacro.scala
> > > @@ -0,0 +1,425 @@
> > > +/*
> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > > + * contributor license agreements. See the NOTICE file distributed
> with
> > > + * this work for additional information regarding copyright ownership.
> > > + * The ASF licenses this file to You under the Apache license, Version
> > 2.0
> > > + * (the "License"); you may not use this file except in compliance
> with
> > > + * the License. You may obtain a copy of the License at
> > > + *
> > > + * http://www.apache.org/licenses/LICENSE-2.0
> > > + *
> > > + * Unless required by applicable law or agreed to in writing, software
> > > + * distributed under the License is distributed on an "AS IS" BASIS,
> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > > implied.
> > > + * See the license for the specific language governing permissions and
> > > + * limitations under the license.
> > > + */
> > > +package org.apache.logging.log4j.scala
> > > +
> > > +import org.apache.logging.log4j.message.{EntryMessage, Message}
> > > +import org.apache.logging.log4j.spi.AbstractLogger
> > > +import org.apache.logging.log4j.{Level, Marker}
> > > +
> > > +import scala.language.experimental.macros
> > > +import scala.reflect.macros.blackbox
> > > +
> > > +/**
> > > + * Inspired from [[https://github.com/typesafehub/scalalogging
> > > ScalaLogging]].
> > > + */
> > > +private object LoggerMacro {
> > > +
> > > + 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.FATAL), marker, message)
> > > +
> > > + def fatalMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
> message:
> > > c.Expr[CharSequence]) =
> > > + logMarkerCseq(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 fatalMarkerCseqThrowable(c: LoggerContext)(marker:
> c.Expr[Marker],
> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > > + logMarkerCseqThrowable(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 fatalCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > > + logCseq(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 fatalCseqThrowable(c: LoggerContext)(message:
> > c.Expr[CharSequence],
> > > cause: c.Expr[Throwable]) =
> > > + logCseqThrowable(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 errorMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
> message:
> > > c.Expr[CharSequence]) =
> > > + logMarkerCseq(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 errorMarkerCseqThrowable(c: LoggerContext)(marker:
> c.Expr[Marker],
> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > > + logMarkerCseqThrowable(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 errorCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > > + logCseq(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 errorCseqThrowable(c: LoggerContext)(message:
> > c.Expr[CharSequence],
> > > cause: c.Expr[Throwable]) =
> > > + logCseqThrowable(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 warnMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
> message:
> > > c.Expr[CharSequence]) =
> > > + logMarkerCseq(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 warnMarkerCseqThrowable(c: LoggerContext)(marker:
> c.Expr[Marker],
> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > > + logMarkerCseqThrowable(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 warnCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > > + logCseq(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 warnCseqThrowable(c: LoggerContext)(message:
> c.Expr[CharSequence],
> > > cause: c.Expr[Throwable]) =
> > > + logCseqThrowable(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 infoMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
> message:
> > > c.Expr[CharSequence]) =
> > > + logMarkerCseq(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 infoMarkerCseqThrowable(c: LoggerContext)(marker:
> c.Expr[Marker],
> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > > + logMarkerCseqThrowable(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 infoCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > > + logCseq(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 infoCseqThrowable(c: LoggerContext)(message:
> c.Expr[CharSequence],
> > > cause: c.Expr[Throwable]) =
> > > + logCseqThrowable(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 debugMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
> message:
> > > c.Expr[CharSequence]) =
> > > + logMarkerCseq(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 debugMarkerCseqThrowable(c: LoggerContext)(marker:
> c.Expr[Marker],
> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > > + logMarkerCseqThrowable(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 debugCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > > + logCseq(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 debugCseqThrowable(c: LoggerContext)(message:
> > c.Expr[CharSequence],
> > > cause: c.Expr[Throwable]) =
> > > + logCseqThrowable(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 traceMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker],
> message:
> > > c.Expr[CharSequence]) =
> > > + logMarkerCseq(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 traceMarkerCseqThrowable(c: LoggerContext)(marker:
> c.Expr[Marker],
> > > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > > + logMarkerCseqThrowable(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 traceCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > > + logCseq(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 traceCseqThrowable(c: LoggerContext)(message:
> > c.Expr[CharSequence],
> > > cause: c.Expr[Throwable]) =
> > > + logCseqThrowable(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)) {
> > > + c.prefix.splice.logMessage(level.splice, marker.splice,
> > > message.splice, null)
> > > + }
> > > + )
> > > +
> > > + def logMarkerCseq(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, null)
> > > + }
> > > + )
> > > +
> > > + 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 logMarkerCseqThrowable(c: LoggerContext)(level: c.Expr[Level],
> > > marker: c.Expr[Marker], message: c.Expr[CharSequence], 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 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)) {
> > > + c.prefix.splice.logMessage(level.splice, null,
> message.splice,
> > > null)
> > > + }
> > > + )
> > > +
> > > + def logCseq(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,
> > > null)
> > > + }
> > > + )
> > > +
> > > + 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 logCseqThrowable(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)) {
> > > + c.prefix.splice.logMessage(level.splice, null,
> message.splice,
> > > cause.splice)
> > > + }
> > > + )
> > > +
> > > + 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)
> > > + }
> > > + )
> > > +
> > > +
> > > + def traceEntry(c: LoggerContext)(): c.Expr[EntryMessage] =
> > > + c.universe.reify(
> > > + c.prefix.splice.delegate.traceEntry()
> > > + )
> > > +
> > > + def traceEntryParams(c: LoggerContext)(params: c.Expr[AnyRef]*):
> > > c.Expr[EntryMessage] = {
> > > + import c.universe._
> > > + val isEnabled = Apply(
> > > + Select(Select(c.prefix.tree, TermName("delegate")),
> > > TermName("isEnabled")),
> > > + List(
> > > + reify(Level.TRACE).tree,
> > > + reify(AbstractLogger.ENTRY_MARKER).tree,
> > > + reify(null: AnyRef).tree,
> > > + reify(null).tree
> > > + )
> > > + )
> > > +
> > > + val log = Apply(
> > > + Select(Select(c.prefix.tree, TermName("delegate")),
> > > TermName("traceEntry")),
> > > + reify(null: String).tree :: (params map (_.tree)).toList
> > > + )
> > > + c.Expr[EntryMessage](If(isEnabled, log, reify(null).tree))
> > > + }
> > > +
> > > +
> > > + def traceEntryMessage(c: LoggerContext)(message: c.Expr[Message]):
> > > c.Expr[EntryMessage] =
> > > + c.universe.reify(
> > > + if (c.prefix.splice.delegate.isEnabled(Level.TRACE,
> > > AbstractLogger.ENTRY_MARKER, null: AnyRef, null)) {
> > > + c.prefix.splice.delegate.traceEntry(message.splice) // TODO
> > > should not do ifEnabled check
> > > + } else {
> > > + null
> > > + }
> > > + )
> > > +
> > > + def traceExit(c: LoggerContext)(): c.Expr[Unit] =
> > > + c.universe.reify(
> > > + c.prefix.splice.delegate.traceExit()
> > > + )
> > > +
> > > + def traceExitResult[R: c.WeakTypeTag](c: LoggerContext)(result:
> > > c.Expr[R]): c.Expr[R] =
> > > + c.universe.reify(
> > > + c.prefix.splice.delegate.traceExit(result.splice)
> > > + )
> > > +
> > > + def traceExitEntryMessage(c: LoggerContext)(entryMessage:
> > > c.Expr[EntryMessage]): c.Expr[Unit] =
> > > + c.universe.reify(
> > > + c.prefix.splice.delegate.traceExit(entryMessage.splice)
> > > + )
> > > +
> > > + def traceExitEntryMessageResult[R: c.WeakTypeTag](c:
> > > LoggerContext)(entryMessage: c.Expr[EntryMessage], result: c.Expr[R]):
> > > c.Expr[R] =
> > > + c.universe.reify(
> > > + c.prefix.splice.delegate.traceExit(entryMessage.splice,
> > > result.splice)
> > > + )
> > > +
> > > + def traceExitMessageResult[R: c.WeakTypeTag](c:
> > LoggerContext)(message:
> > > c.Expr[Message], result: c.Expr[R]): c.Expr[R] =
> > > + c.universe.reify(
> > > + {
> > > + if (message.splice != null && c.prefix.splice.delegate.
> > isEnabled(Level.TRACE,
> > > AbstractLogger.EXIT_MARKER, message.splice, null)) {
> > > + c.prefix.splice.delegate.traceExit(message.splice,
> > > result.splice) // TODO should not do ifEnabled check
> > > + }
> > > + result.splice
> > > + }
> > > + )
> > > +
> > > + def throwing[T <: Throwable: c.WeakTypeTag](c: LoggerContext)(t:
> > > c.Expr[T]): c.Expr[T] =
> > > + c.universe.reify(
> > > + c.prefix.splice.delegate.throwing(t.splice)
> > > + )
> > > +
> > > + def throwingLevel[T <: Throwable: c.WeakTypeTag](c:
> > > LoggerContext)(level: c.Expr[Level], t: c.Expr[T]): c.Expr[T] =
> > > + c.universe.reify(
> > > + c.prefix.splice.delegate.throwing(level.splice, t.splice)
> > > + )
> > > +
> > > + def catching(c: LoggerContext)(t: c.Expr[Throwable]): c.Expr[Unit] =
> > > + c.universe.reify(
> > > + c.prefix.splice.delegate.catching(t.splice)
> > > + )
> > > +
> > > + def catchingLevel(c: LoggerContext)(level: c.Expr[Level], t:
> > > c.Expr[Throwable]): c.Expr[Unit] =
> > > + c.universe.reify(
> > > + c.prefix.splice.delegate.catching(level.splice, t.splice)
> > > + )
> > > +
> > > +}
> > >
> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> > > apache/logging/log4j/scala/Logging.scala
> > > ----------------------------------------------------------------------
> > > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/Logging.scala
> > > b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > > log4j/scala/Logging.scala
> > > new file mode 100644
> > > index 0000000..b017de7
> > > --- /dev/null
> > > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > > log4j/scala/Logging.scala
> > > @@ -0,0 +1,30 @@
> > > +/*
> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > > + * contributor license agreements. See the NOTICE file distributed
> with
> > > + * this work for additional information regarding copyright ownership.
> > > + * The ASF licenses this file to You under the Apache license, Version
> > 2.0
> > > + * (the "License"); you may not use this file except in compliance
> with
> > > + * the License. You may obtain a copy of the License at
> > > + *
> > > + * http://www.apache.org/licenses/LICENSE-2.0
> > > + *
> > > + * Unless required by applicable law or agreed to in writing, software
> > > + * distributed under the License is distributed on an "AS IS" BASIS,
> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > > implied.
> > > + * See the license for the specific language governing permissions and
> > > + * limitations under the license.
> > > + */
> > > +package org.apache.logging.log4j.scala
> > > +
> > > +/**
> > > + * Mix in this trait into classes from which you want to log,
> > > + * give you a `logger` value with a [[Logger]] named according to the
> > > class.
> > > + */
> > > +trait Logging {
> > > +
> > > + /**
> > > + * A [[Logger]] named according to the class.
> > > + */
> > > + protected val logger: Logger = Logger(getClass)
> > > +
> > > +}
> > > \ No newline at end of file
> > >
> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> > > apache/logging/log4j/scala/LoggingContext.scala
> > > ----------------------------------------------------------------------
> > > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > > log4j/scala/LoggingContext.scala b/log4j-api-scala_2.13/src/
> > > main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
> > > new file mode 100644
> > > index 0000000..79efecc
> > > --- /dev/null
> > > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > > log4j/scala/LoggingContext.scala
> > > @@ -0,0 +1,84 @@
> > > +/*
> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > > + * contributor license agreements. See the NOTICE file distributed
> with
> > > + * this work for additional information regarding copyright ownership.
> > > + * The ASF licenses this file to You under the Apache license, Version
> > 2.0
> > > + * (the "License"); you may not use this file except in compliance
> with
> > > + * the License. You may obtain a copy of the License at
> > > + *
> > > + * http://www.apache.org/licenses/LICENSE-2.0
> > > + *
> > > + * Unless required by applicable law or agreed to in writing, software
> > > + * distributed under the License is distributed on an "AS IS" BASIS,
> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > > implied.
> > > + * See the license for the specific language governing permissions and
> > > + * limitations under the license.
> > > + */
> > > +package org.apache.logging.log4j.scala
> > > +
> > > +import org.apache.logging.log4j.ThreadContext
> > > +
> > > +import scala.collection.JavaConverters._
> > > +import scala.collection.{immutable, mutable}
> > > +
> > > +/** Manages the context data (context map, MDC) that is added to log
> > > events.
> > > + *
> > > + * A wrapper around `org.apache.logging.log4j.ThreadContext`.
> > > + */
> > > +object LoggingContext extends mutable.Map[String, String] {
> > > +
> > > + override def +=(kv: (String, String)): LoggingContext.this.type = {
> > > + ThreadContext.put(kv._1, kv._2)
> > > + this
> > > + }
> > > +
> > > + override def +=(elem1: (String, String), elem2: (String, String),
> > > elems: (String, String)*): LoggingContext.this.type = {
> > > + val builder = immutable.Map.newBuilder[String,String]
> > > + builder += elem1
> > > + builder += elem2
> > > + builder ++= elems
> > > + ThreadContext.putAll(builder.result.asJava)
> > > + this
> > > + }
> > > +
> > > + override def ++=(xs: TraversableOnce[(String, String)]):
> > > LoggingContext.this.type = {
> > > + ThreadContext.putAll(xs.toMap.asJava)
> > > + this
> > > + }
> > > +
> > > + override def -=(key: String): LoggingContext.this.type = {
> > > + ThreadContext.remove(key)
> > > + this
> > > + }
> > > +
> > > + override def -=(elem1: String, elem2: String, elems: String*):
> > > LoggingContext.this.type = {
> > > + val builder = immutable.Seq.newBuilder[String]
> > > + builder += elem1
> > > + builder += elem2
> > > + builder ++= elems
> > > + ThreadContext.removeAll(builder.result.asJava)
> > > + this
> > > + }
> > > +
> > > + override def --=(xs: TraversableOnce[String]):
> > LoggingContext.this.type
> > > = {
> > > + ThreadContext.removeAll(xs.toSeq.asJava)
> > > + this
> > > + }
> > > +
> > > + override def clear(): Unit = {
> > > + ThreadContext.clearMap()
> > > + }
> > > +
> > > + override def contains(key: String): Boolean =
> > > ThreadContext.containsKey(key)
> > > +
> > > + override def get(key: String): Option[String] =
> > > Option(ThreadContext.get(key))
> > > +
> > > + override def iterator: Iterator[(String, String)] = ThreadContext.
> > > getImmutableContext.asScala.iterator
> > > +
> > > + override def foreach[U](f: ((String, String)) => U): Unit =
> > > ThreadContext.getImmutableContext.asScala.foreach(f)
> > > +
> > > + override def size: Int = ThreadContext.getImmutableContext.size()
> > > +
> > > + override def isEmpty: Boolean = ThreadContext.isEmpty
> > > +
> > > +}
> > >
> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > blob/184045cb/log4j-api-scala_2.13/src/site/markdown/index.md
> > > ----------------------------------------------------------------------
> > > diff --git a/log4j-api-scala_2.13/src/site/markdown/index.md
> > > b/log4j-api-scala_2.13/src/site/markdown/index.md
> > > new file mode 100644
> > > index 0000000..7acf397
> > > --- /dev/null
> > > +++ b/log4j-api-scala_2.13/src/site/markdown/index.md
> > > @@ -0,0 +1,74 @@
> > > +<!--
> > > + Licensed to the Apache Software Foundation (ASF) under one or more
> > > + contributor license agreements. See the NOTICE file distributed
> > with
> > > + this work for additional information regarding copyright
> ownership.
> > > + The ASF licenses this file to You under the Apache License,
> Version
> > > 2.0
> > > + (the "License"); you may not use this file except in compliance
> with
> > > + the License. You may obtain a copy of the License at
> > > +
> > > + http://www.apache.org/licenses/LICENSE-2.0
> > > +
> > > + Unless required by applicable law or agreed to in writing,
> software
> > > + distributed under the License is distributed on an "AS IS" BASIS,
> > > + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > > implied.
> > > + See the License for the specific language governing permissions
> and
> > > + limitations under the License.
> > > +-->
> > > +# Log4j Scala 2.12 API
> > > +
> > > +## Requirements
> > > +
> > > +Log4j Scala API for Scala 2.12 requires Log4j API, Java 8, the Scala
> > > runtime
> > > +library, and the Scala reflection library. To use Log4j as a logging
> > > implementation,
> > > +then Log4j Core must also be included. Instructions on using these
> > > dependencies are
> > > +in the [dependency information page][dependencies], and additional
> > > information is
> > > +included in the [Log4j artifacts][artifacts] page.
> > > +
> > > +## Example Usage
> > > +
> > > +<pre class="prettyprint linenums">
> > > +import org.apache.logging.log4j.scala.Logging
> > > +import org.apache.logging.log4j.Level
> > > +
> > > +class MyClass extends BaseClass with Logging {
> > > + def doStuff(): Unit = {
> > > + logger.info("Doing stuff")
> > > + }
> > > + def doStuffWithLevel(level: Level): Unit = {
> > > + logger(level, "Doing stuff with arbitrary level")
> > > + }
> > > +}
> > > +</pre>
> > > +
> > > +## Configuration
> > > +
> > > +Log4j Scala 2.12 API uses the standard [Log4j
> > > configuration][configuration]
> > > +plugins. This supports XML, properties files, and a configuration
> > builder
> > > DSL by
> > > +default, and it optionally supports JSON and YAML formats with some
> > > additional
> > > +Jackson dependencies.
> > > +
> > > +## Substituting Parameters
> > > +
> > > +In the Java API, parameters to a log message are interpolated using
> > > various
> > > +strategies. In the Scala API, [string interpolation][interpolation] is
> > > used
> > > +instead. As all logger methods are implemented as macros, string
> > > construction and
> > > +method invocations will only occur when logging is enabled for the
> given
> > > log
> > > +level. For example:
> > > +
> > > +<pre class="prettyprint linenums">
> > > +logger.debug(s"Logging in user ${user.getName} with birthday
> > > ${user.calcBirthday}")
> > > +</pre>
> > > +
> > > +## Logger Names
> > > +
> > > +Most logging implementations use a hierarchical scheme for matching
> > > logger names
> > > +with logging configuration. In this scheme the logger name hierarchy
> is
> > > +represented by '.' characters in the logger name, in a fashion very
> > > similar to
> > > +the hierarchy used for Java/Scala package names. The [`Logging`
> > > trait][logging]
> > > +will automatically name the Logger accordingly to the class it is
> being
> > > used in.
> > > +
> > > +[dependencies]: dependency-info.html
> > > +[artifacts]: ../maven-artifacts.html
> > > +[configuration]: ../configuration.html
> > > +[interpolation]: http://docs.scala-lang.org/overviews/core/string-
> > > interpolation.html
> > > +[logging]: scaladocs/org/apache/logging/log4j/scala/Logging.html
> > > \ No newline at end of file
> > >
> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > blob/184045cb/log4j-api-scala_2.13/src/site/site.xml
> > > ----------------------------------------------------------------------
> > > diff --git a/log4j-api-scala_2.13/src/site/site.xml
> > > b/log4j-api-scala_2.13/src/site/site.xml
> > > new file mode 100644
> > > index 0000000..f46fa51
> > > --- /dev/null
> > > +++ b/log4j-api-scala_2.13/src/site/site.xml
> > > @@ -0,0 +1,30 @@
> > > +<?xml version="1.0" encoding="utf-8"?>
> > > +<!--
> > > + ~ Licensed to the Apache Software Foundation (ASF) under one or more
> > > + ~ contributor license agreements. See the NOTICE file distributed
> with
> > > + ~ this work for additional information regarding copyright
> ownership.
> > > + ~ The ASF licenses this file to You under the Apache license,
> Version
> > > 2.0
> > > + ~ (the "License"); you may not use this file except in compliance
> with
> > > + ~ the License. You may obtain a copy of the License at
> > > + ~
> > > + ~ http://www.apache.org/licenses/LICENSE-2.0
> > > + ~
> > > + ~ Unless required by applicable law or agreed to in writing,
> software
> > > + ~ distributed under the License is distributed on an "AS IS" BASIS,
> > > + ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > > implied.
> > > + ~ See the license for the specific language governing permissions
> and
> > > + ~ limitations under the license.
> > > + -->
> > > +<project name="Log4j Scala API"
> > > + xmlns="http://maven.apache.org/DECORATION/1.7.0"
> > > + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
> > > + xsi:schemaLocation="http://maven.apache.org/DECORATION/1.7.0
> > > http://maven.apache.org/xsd/decoration-1.7.0.xsd">
> > > + <body>
> > > + <links>
> > > + <item name="Apache" href="http://www.apache.org/"/>
> > > + <item name="Logging Services" href="http://logging.apache
> .
> > > org/"/>
> > > + <item name="Log4j" href="../index.html"/>
> > > + </links>
> > > + <menu ref="reports"/>
> > > + </body>
> > > +</project>
> > > \ No newline at end of file
> > >
> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > blob/184045cb/log4j-api-scala_2.13/src/test/scala/org/
> > > apache/logging/log4j/scala/LoggerTest.scala
> > > ----------------------------------------------------------------------
> > > diff --git a/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> > log4j/scala/LoggerTest.scala
> > > b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> > > log4j/scala/LoggerTest.scala
> > > new file mode 100644
> > > index 0000000..bd12742
> > > --- /dev/null
> > > +++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> > > log4j/scala/LoggerTest.scala
> > > @@ -0,0 +1,552 @@
> > > +/*
> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > > + * contributor license agreements. See the NOTICE file distributed
> with
> > > + * this work for additional information regarding copyright ownership.
> > > + * The ASF licenses this file to You under the Apache license, Version
> > 2.0
> > > + * (the "License"); you may not use this file except in compliance
> with
> > > + * the License. You may obtain a copy of the License at
> > > + *
> > > + * http://www.apache.org/licenses/LICENSE-2.0
> > > + *
> > > + * Unless required by applicable law or agreed to in writing, software
> > > + * distributed under the License is distributed on an "AS IS" BASIS,
> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > > implied.
> > > + * See the license for the specific language governing permissions and
> > > + * limitations under the license.
> > > + */
> > > +package org.apache.logging.log4j.scala
> > > +
> > > +import org.apache.logging.log4j.message.{DefaultFlowMessageFactory,
> > > Message, ParameterizedMessage, ParameterizedMessageFactory}
> > > +import org.apache.logging.log4j.spi.{AbstractLogger, ExtendedLogger}
> > > +import org.apache.logging.log4j.{Level, Marker, MarkerManager}
> > > +import org.junit.runner.RunWith
> > > +import org.mockito.Matchers.{any, anyString, eq => eqv}
> > > +import org.mockito.Mockito._
> > > +import org.scalatest.junit.JUnitRunner
> > > +import org.scalatest.mockito.MockitoSugar
> > > +import org.scalatest.{FunSuite, Matchers}
> > > +
> > > +import scala.language.reflectiveCalls // needed for Mockito mocking
> > > +
> > > +case class Custom(i: Int)
> > > +
> > > +trait Manager {
> > > + def fetchValue(): Int
> > > +}
> > > +
> > > +@RunWith(classOf[JUnitRunner])
> > > +class LoggerTest extends FunSuite with Matchers with MockitoSugar {
> > > +
> > > + val msg = new ParameterizedMessage("msg {}", 17)
> > > + val entryMsg = new DefaultFlowMessageFactory().newEntryMessage(msg)
> > > + val cseqMsg: CharSequence = new StringBuilder().append("cseq msg")
> > > + val objectMsg = Custom(17)
> > > + val cause = new RuntimeException("cause")
> > > + val marker = MarkerManager.getMarker("marker")
> > > + val result = "foo"
> > > +
> > > + def fixture =
> > > + new {
> > > + val mockLogger = {
> > > + val mockLogger = mock[ExtendedLogger]
> > > + when(mockLogger.getMessageFactory).thenReturn(new
> > > ParameterizedMessageFactory)
> > > + mockLogger
> > > + }
> > > + val manager = {
> > > + val mockManager = mock[Manager]
> > > + when(mockManager.fetchValue()).thenReturn(4711)
> > > + mockManager
> > > + }
> > > + }
> > > +
> > > + test("fatal enabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.FATAL),
> > > eqv(null), any[Message], eqv(null))
> > > + verify(f.manager).fetchValue()
> > > + }
> > > +
> > > + test("fatal disabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + verify(f.manager, never).fetchValue()
> > > + }
> > > +
> > > + test("error enabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.error(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.ERROR),
> > > eqv(null), any[Message], eqv(null))
> > > + verify(f.manager).fetchValue()
> > > + }
> > > +
> > > + test("error disabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.error(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + verify(f.manager, never).fetchValue()
> > > + }
> > > +
> > > + test("warn enabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.WARN),
> > > eqv(null), any[Message], eqv(null))
> > > + verify(f.manager).fetchValue()
> > > + }
> > > +
> > > + test("warn disabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + verify(f.manager, never).fetchValue()
> > > + }
> > > +
> > > + test("info enabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.info(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(null), any[Message], eqv(null))
> > > + verify(f.manager).fetchValue()
> > > + }
> > > +
> > > + test("info disabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.info(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + verify(f.manager, never).fetchValue()
> > > + }
> > > +
> > > + test("debug enabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.DEBUG),
> > > eqv(null), any[Message], eqv(null))
> > > + verify(f.manager).fetchValue()
> > > + }
> > > +
> > > + test("debug disabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + verify(f.manager, never).fetchValue()
> > > + }
> > > +
> > > + test("trace enabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.TRACE),
> > > eqv(null), any[Message], eqv(null))
> > > + verify(f.manager).fetchValue()
> > > + }
> > > +
> > > + test("trace disabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + verify(f.manager, never).fetchValue()
> > > + }
> > > +
> > > +
> > > + test("log enabled with Message message and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, msg)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(marker), eqv(msg), eqv(null))
> > > + }
> > > +
> > > + test("log disabled with Message message and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO,
> marker)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, msg)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with String message and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, s"string msg with value:
> > > ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(marker), any[Message], eqv(null))
> > > + verify(f.manager).fetchValue()
> > > + }
> > > +
> > > + test("log disabled with String message and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO,
> marker)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, s"string msg with value:
> > > ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + verify(f.manager, never).fetchValue()
> > > + }
> > > +
> > > + test("log enabled with CharSequence message and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, cseqMsg)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(marker), any[Message], eqv(null))
> > > + }
> > > +
> > > + test("log disabled with CharSequence message and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO,
> marker)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, cseqMsg)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with Object message and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, objectMsg)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(marker), any[Message], eqv(null))
> > > + }
> > > +
> > > + test("log disabled with Object message and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO,
> marker)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, objectMsg)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with Message message and cause and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, msg, cause)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(marker), eqv(msg), eqv(cause))
> > > + }
> > > +
> > > + test("log disabled with Message message and cause and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO,
> marker)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, msg, cause)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with String message and cause and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, s"string msg with value:
> > > ${f.manager.fetchValue()}", cause)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(marker), any[Message], eqv(cause))
> > > + verify(f.manager).fetchValue()
> > > + }
> > > +
> > > + test("log disabled with String message and cause and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO,
> marker)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, s"string msg with value:
> > > ${f.manager.fetchValue()}", cause)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + verify(f.manager, never).fetchValue()
> > > + }
> > > +
> > > + test("log enabled with CharSequence message and cause and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, cseqMsg, cause)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(marker), any[Message], eqv(cause))
> > > + }
> > > +
> > > + test("log disabled with CharSequence message and cause and Marker")
> {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO,
> marker)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, cseqMsg, cause)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with Object message and cause and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, objectMsg, cause)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(marker), any[Message], eqv(cause))
> > > + }
> > > +
> > > + test("log disabled with Object message and cause and Marker") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO,
> marker)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, marker, objectMsg, cause)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with Message message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, msg)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(null), eqv(msg), eqv(null))
> > > + }
> > > +
> > > + test("log disabled with Message message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, msg)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, s"string msg with value:
> > > ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(null), any[Message], eqv(null))
> > > + verify(f.manager).fetchValue()
> > > + }
> > > +
> > > + test("log disabled with String message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, s"string msg with value:
> > > ${f.manager.fetchValue()}")
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + verify(f.manager, never).fetchValue()
> > > + }
> > > +
> > > + test("log enabled with CharSequence message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, cseqMsg)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(null), any[Message], eqv(null))
> > > + }
> > > +
> > > + test("log disabled with CharSequence message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, cseqMsg)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with Object message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, objectMsg)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(null), any[Message], eqv(null))
> > > + }
> > > +
> > > + test("log disabled with Object message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, objectMsg)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with Message message and cause") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, msg, cause)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(null), eqv(msg), eqv(cause))
> > > + }
> > > +
> > > + test("log disabled with Message message and cause") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, msg, cause)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with String message and cause") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, s"string msg with value:
> > > ${f.manager.fetchValue()}", cause)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(null), any[Message], eqv(cause))
> > > + verify(f.manager).fetchValue()
> > > + }
> > > +
> > > + test("log disabled with String message and cause") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, s"string msg with value:
> > > ${f.manager.fetchValue()}", cause)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + verify(f.manager, never).fetchValue()
> > > + }
> > > +
> > > + test("log enabled with CharSequence message and cause") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, cseqMsg, cause)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(null), any[Message], eqv(cause))
> > > + }
> > > +
> > > + test("log disabled with CharSequence message and cause") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, cseqMsg, cause)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > + test("log enabled with Object message and cause") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, objectMsg, cause)
> > > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > > eqv(null), any[Message], eqv(cause))
> > > + }
> > > +
> > > + test("log disabled with Object message and cause") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger(Level.INFO, objectMsg, cause)
> > > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > > any[Marker], any[Message], any[Throwable])
> > > + }
> > > +
> > > +
> > > + test("traceEntry") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> > > null)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceEntry()
> > > + verify(f.mockLogger).traceEntry()
> > > + }
> > > +
> > > + test("traceEntry enabled with params") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> > > null)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceEntry("foo", "bar")
> > > + verify(f.mockLogger).traceEntry(null: String, "foo", "bar")
> > > + }
> > > +
> > > + test("traceEntry disabled with params") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> > > null)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceEntry("foo", "bar")
> > > + verify(f.mockLogger, never).traceEntry(anyString(), anyString(),
> > > anyString())
> > > + }
> > > +
> > > + test("traceEntry enabled with message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> > > null)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceEntry(msg)
> > > + verify(f.mockLogger).traceEntry(eqv(msg))
> > > + }
> > > +
> > > + test("traceEntry disabled with message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> > > null)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceEntry(msg)
> > > + verify(f.mockLogger, never).traceEntry(any[Message])
> > > + }
> > > +
> > > + test("traceExit") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.EXIT_MARKER,
> > > msg, null)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceExit()
> > > + verify(f.mockLogger).traceExit()
> > > + }
> > > +
> > > + test("traceExit with result") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.EXIT_MARKER,
> > > msg, null)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceExit(result)
> > > + verify(f.mockLogger).traceExit(result)
> > > + }
> > > +
> > > + test("traceExit with entrymessage") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.EXIT_MARKER,
> > > msg, null)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceExit(entryMsg)
> > > + verify(f.mockLogger).traceExit(entryMsg)
> > > + }
> > > +
> > > + test("traceExit with entrymessage and result") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.EXIT_MARKER,
> > > msg, null)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceExit(entryMsg, result)
> > > + verify(f.mockLogger).traceExit(entryMsg, result)
> > > + }
> > > +
> > > + test("traceExit enabled with message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.EXIT_MARKER,
> > > msg, null)).thenReturn(true)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceExit(msg, result)
> > > + verify(f.mockLogger).traceExit(eqv(msg), eqv(result))
> > > + }
> > > +
> > > + test("traceExit disabled with message") {
> > > + val f = fixture
> > > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.EXIT_MARKER,
> > > msg, null)).thenReturn(false)
> > > + val logger = Logger(f.mockLogger)
> > > + logger.traceExit(msg, result)
> > > + verify(f.mockLogger, never).traceExit(any[Message], any[AnyRef])
> > > + }
> > > +
> > > + test("throwing") {
> > > + val f = fixture
> > > + val logger = Logger(f.mockLogger)
> > > + logger.throwing(cause)
> > > + verify(f.mockLogger).throwing(eqv(cause))
> > > + }
> > > +
> > > + test("throwing with level") {
> > > + val f = fixture
> > > + val logger = Logger(f.mockLogger)
> > > + logger.throwing(Level.INFO, cause)
> > > + verify(f.mockLogger).throwing(eqv(Level.INFO), eqv(cause))
> > > + }
> > > +
> > > + test("catching") {
> > > + val f = fixture
> > > + val logger = Logger(f.mockLogger)
> > > + logger.catching(cause)
> > > + verify(f.mockLogger).catching(eqv(cause))
> > > + }
> > > +
> > > + test("catching with level") {
> > > + val f = fixture
> > > + val logger = Logger(f.mockLogger)
> > > + logger.catching(Level.INFO, cause)
> > > + verify(f.mockLogger).catching(eqv(Level.INFO), eqv(cause))
> > > + }
> > > +
> > > +}
> > >
> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > blob/184045cb/log4j-api-scala_2.13/src/test/scala/org/
> > > apache/logging/log4j/scala/LoggingContextTest.scala
> > > ----------------------------------------------------------------------
> > > diff --git a/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> > > log4j/scala/LoggingContextTest.scala b/log4j-api-scala_2.13/src/
> > > test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
> > > new file mode 100644
> > > index 0000000..80ca940
> > > --- /dev/null
> > > +++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> > log4j/scala/
> > > LoggingContextTest.scala
> > > @@ -0,0 +1,115 @@
> > > +/*
> > > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > > + * contributor license agreements. See the NOTICE file distributed
> with
> > > + * this work for additional information regarding copyright ownership.
> > > + * The ASF licenses this file to You under the Apache license, Version
> > 2.0
> > > + * (the "License"); you may not use this file except in compliance
> with
> > > + * the License. You may obtain a copy of the License at
> > > + *
> > > + * http://www.apache.org/licenses/LICENSE-2.0
> > > + *
> > > + * Unless required by applicable law or agreed to in writing, software
> > > + * distributed under the License is distributed on an "AS IS" BASIS,
> > > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > > implied.
> > > + * See the license for the specific language governing permissions and
> > > + * limitations under the license.
> > > + */
> > > +package org.apache.logging.log4j.scala
> > > +
> > > +import org.junit.runner.RunWith
> > > +import org.scalatest.junit.JUnitRunner
> > > +import org.scalatest.{FunSuite, Matchers}
> > > +
> > > +import scala.collection.mutable
> > > +
> > > +@RunWith(classOf[JUnitRunner])
> > > +class LoggingContextTest extends FunSuite with Matchers {
> > > +
> > > + test("put single, contains, get") {
> > > + LoggingContext += "key" -> "value"
> > > +
> > > + LoggingContext.contains("key") shouldBe true
> > > + LoggingContext.get("key") shouldBe Some("value")
> > > + LoggingContext.contains("bogus") shouldBe false
> > > + LoggingContext.get("bogus") shouldBe None
> > > + }
> > > +
> > > + test("put multiple 1") {
> > > + LoggingContext += ("key1" -> "value1", "key2" -> "value2")
> > > +
> > > + LoggingContext.get("key1") shouldBe Some("value1")
> > > + LoggingContext.get("key2") shouldBe Some("value2")
> > > + }
> > > +
> > > + test("put multiple 2") {
> > > + LoggingContext ++= Seq("key1" -> "value1", "key2" -> "value2")
> > > +
> > > + LoggingContext.get("key1") shouldBe Some("value1")
> > > + LoggingContext.get("key2") shouldBe Some("value2")
> > > + }
> > > +
> > > + test("remove single") {
> > > + LoggingContext += ("key1" -> "value1")
> > > + LoggingContext += ("key2" -> "value2")
> > > + LoggingContext += ("key3" -> "value3")
> > > +
> > > + LoggingContext -= "key1"
> > > +
> > > + LoggingContext.get("key1") shouldBe None
> > > + LoggingContext.get("key2") shouldBe Some("value2")
> > > + LoggingContext.get("key3") shouldBe Some("value3")
> > > + }
> > > +
> > > + test("remove multiple 1") {
> > > + LoggingContext += ("key1" -> "value1")
> > > + LoggingContext += ("key2" -> "value2")
> > > + LoggingContext += ("key3" -> "value3")
> > > +
> > > + LoggingContext -= ("key1", "key2")
> > > +
> > > + LoggingContext.get("key1") shouldBe None
> > > + LoggingContext.get("key2") shouldBe None
> > > + LoggingContext.get("key3") shouldBe Some("value3")
> > > + }
> > > +
> > > + test("remove multiple 2") {
> > > + LoggingContext += ("key1" -> "value1")
> > > + LoggingContext += ("key2" -> "value2")
> > > + LoggingContext += ("key3" -> "value3")
> > > +
> > > + LoggingContext --= Seq("key1", "key2")
> > > +
> > > + LoggingContext.get("key1") shouldBe None
> > > + LoggingContext.get("key2") shouldBe None
> > > + LoggingContext.get("key3") shouldBe Some("value3")
> > > + }
> > > +
> > > + test("clear, size, isEmpty") {
> > > + LoggingContext += ("key" -> "value")
> > > +
> > > + LoggingContext.clear()
> > > +
> > > + LoggingContext.contains("key") shouldBe false
> > > + LoggingContext.size shouldBe 0
> > > + LoggingContext.isEmpty shouldBe true
> > > + }
> > > +
> > > + test("iterator") {
> > > + LoggingContext += ("key1" -> "value1")
> > > + LoggingContext += ("key2" -> "value2")
> > > +
> > > + LoggingContext.iterator.toSet shouldBe Set("key1" -> "value1",
> > "key2"
> > > -> "value2")
> > > + }
> > > +
> > > + test("foreach") {
> > > + LoggingContext += ("key1" -> "value1")
> > > + LoggingContext += ("key2" -> "value2")
> > > +
> > > + val result = mutable.Set.empty[(String, String)]
> > > +
> > > + LoggingContext.foreach { result += _ }
> > > +
> > > + result shouldBe Set("key1" -> "value1", "key2" -> "value2")
> > > + }
> > > +
> > > +}
> > >
> > > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > > blob/184045cb/pom.xml
> > > ----------------------------------------------------------------------
> > > diff --git a/pom.xml b/pom.xml
> > > index 1068ecb..c26cc7a 100644
> > > --- a/pom.xml
> > > +++ b/pom.xml
> > > @@ -106,6 +106,7 @@
> > > <module>log4j-api-scala_2.10</module>
> > > <module>log4j-api-scala_2.11</module>
> > > <module>log4j-api-scala_2.12</module>
> > > +<!--<module>log4j-api-scala_2.13</module> -->
> > > <module>log4j-api-scala-sample</module>
> > > </modules>
> > >
> > >
> > >
> >
> >
> > --
> > Matt Sicker <bo...@gmail.com>
> >
>
--
Matt Sicker <bo...@gmail.com>
Re: logging-log4j-scala git commit: Add placeholder for Scala 2.13
but do not enable the module.
Posted by Gary Gregory <ga...@gmail.com>.
On Sat, Nov 11, 2017 at 3:51 PM, Matt Sicker <bo...@gmail.com> wrote:
> I've seen on Maven Central before that a few Scala libraries have published
> artifacts for 2.13.0 milestones. See for example: <
> https://search.maven.org/#artifactdetails%7Corg.
> scalatest%7Cscalatest_2.13.0-M2%7C3.0.4%7Cbundle>.
> It seems like if we published the module by naming it
> "log4j-api-scala_2.13.0-M2", we could have a version specific to that
> milestone at least.
>
Hi Matt,
The scalatest module has the milestone number in the name but not
scala-library for example.
Why bother with changing the module name. If it came out today, our version
12.0 of log4j-api-scala_2.13 would be at the 2.13.0-M2 level. Then our 13.0
can be at the next M level and so on.
What am I missing?
Gary
> On 11 November 2017 at 16:26, <gg...@apache.org> wrote:
>
> > Repository: logging-log4j-scala
> > Updated Branches:
> > refs/heads/master 5a71e5caa -> 184045cbc
> >
> >
> > Add placeholder for Scala 2.13 but do not enable the module.
> >
> > Project: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/repo
> > Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > commit/184045cb
> > Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > tree/184045cb
> > Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > diff/184045cb
> >
> > Branch: refs/heads/master
> > Commit: 184045cbc7a517faef2a709aa68e83d7a0053599
> > Parents: 5a71e5c
> > Author: Gary Gregory <gg...@apache.org>
> > Authored: Sat Nov 11 15:26:01 2017 -0700
> > Committer: Gary Gregory <gg...@apache.org>
> > Committed: Sat Nov 11 15:26:01 2017 -0700
> >
> > ----------------------------------------------------------------------
> > log4j-api-scala_2.13/pom.xml | 145 +++++
> > .../org/apache/logging/log4j/scala/Logger.scala | 592
> +++++++++++++++++++
> > .../logging/log4j/scala/LoggerMacro.scala | 425 +++++++++++++
> > .../apache/logging/log4j/scala/Logging.scala | 30 +
> > .../logging/log4j/scala/LoggingContext.scala | 84 +++
> > log4j-api-scala_2.13/src/site/markdown/index.md | 74 +++
> > log4j-api-scala_2.13/src/site/site.xml | 30 +
> > .../apache/logging/log4j/scala/LoggerTest.scala | 552 +++++++++++++++++
> > .../log4j/scala/LoggingContextTest.scala | 115 ++++
> > pom.xml | 1 +
> > 10 files changed, 2048 insertions(+)
> > ----------------------------------------------------------------------
> >
> >
> > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > blob/184045cb/log4j-api-scala_2.13/pom.xml
> > ----------------------------------------------------------------------
> > diff --git a/log4j-api-scala_2.13/pom.xml b/log4j-api-scala_2.13/pom.xml
> > new file mode 100644
> > index 0000000..ea0f19c
> > --- /dev/null
> > +++ b/log4j-api-scala_2.13/pom.xml
> > @@ -0,0 +1,145 @@
> > +<?xml version="1.0" encoding="UTF-8"?>
> > +<!--
> > + Licensed to the Apache Software Foundation (ASF) under one or more
> > + contributor license agreements. See the NOTICE file distributed with
> > + this work for additional information regarding copyright ownership.
> > + The ASF licenses this file to You under the Apache License, Version 2.0
> > + (the "License"); you may not use this file except in compliance with
> > + the License. You may obtain a copy of the License at
> > +
> > + http://www.apache.org/licenses/LICENSE-2.0
> > +
> > + Unless required by applicable law or agreed to in writing, software
> > + distributed under the License is distributed on an "AS IS" BASIS,
> > + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> > + See the License for the specific language governing permissions and
> > + limitations under the License.
> > +-->
> > +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="
> > http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://
> > maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
> > + <modelVersion>4.0.0</modelVersion>
> > + <parent>
> > + <groupId>org.apache.logging.log4j</groupId>
> > + <artifactId>log4j-scala</artifactId>
> > + <version>12.0-SNAPSHOT</version>
> > + <relativePath>../</relativePath>
> > + </parent>
> > + <artifactId>log4j-api-scala_2.13</artifactId>
> > + <packaging>jar</packaging>
> > + <name>Scala 2.13 wrapper for Log4j API</name>
> > + <description>Scala wrapper for Log4j API</description>
> > + <properties>
> > + <log4jParentDir>${basedir}/..</log4jParentDir>
> > + <projectDir>/scala_2.13</projectDir>
> > + <scala.version>2.13.0-M2</scala.version>
> > + <scala.maven.plugin.version>3.3.1</scala.maven.plugin.version>
> > + <maven.compiler.source>1.8</maven.compiler.source>
> > + <maven.compiler.target>1.8</maven.compiler.target>
> > + </properties>
> > + <dependencies>
> > + <dependency>
> > + <groupId>org.apache.logging.log4j</groupId>
> > + <artifactId>log4j-api</artifactId>
> > + </dependency>
> > + <dependency>
> > + <groupId>org.scala-lang</groupId>
> > + <artifactId>scala-library</artifactId>
> > + <version>${scala.version}</version>
> > + </dependency>
> > + <dependency>
> > + <groupId>org.scala-lang</groupId>
> > + <artifactId>scala-reflect</artifactId>
> > + <version>${scala.version}</version>
> > + </dependency>
> > + <dependency>
> > + <groupId>org.apache.logging.log4j</groupId>
> > + <artifactId>log4j-api</artifactId>
> > + <type>test-jar</type>
> > + <scope>test</scope>
> > + </dependency>
> > + <dependency>
> > + <groupId>junit</groupId>
> > + <artifactId>junit</artifactId>
> > + <scope>test</scope>
> > + </dependency>
> > + <dependency>
> > + <groupId>org.scalatest</groupId>
> > + <artifactId>scalatest_2.13.0-M2</artifactId>
> > + <version>3.0.4</version>
> > + <scope>test</scope>
> > + </dependency>
> > + <dependency>
> > + <groupId>org.mockito</groupId>
> > + <artifactId>mockito-core</artifactId>
> > + <version>1.10.19</version>
> > + <scope>test</scope>
> > + </dependency>
> > + </dependencies>
> > + <build>
> > + <sourceDirectory>src/main/scala</sourceDirectory>
> > + <testSourceDirectory>src/test/scala</testSourceDirectory>
> > + <plugins>
> > + <plugin>
> > + <groupId>net.alchim31.maven</groupId>
> > + <artifactId>scala-maven-plugin</artifactId>
> > + <version>${scala.maven.plugin.version}</version>
> > + <executions>
> > + <execution>
> > + <goals>
> > + <goal>compile</goal>
> > + <goal>testCompile</goal>
> > + <goal>doc-jar</goal>
> > + </goals>
> > + </execution>
> > + </executions>
> > + <configuration>
> > + <args>
> > + <arg>-feature</arg>
> > + <arg>-unchecked</arg>
> > + <arg>-deprecation</arg>
> > + </args>
> > + </configuration>
> > + </plugin>
> > + <plugin>
> > + <groupId>org.apache.maven.plugins</groupId>
> > + <artifactId>maven-surefire-plugin</artifactId>
> > + </plugin>
> > + <plugin>
> > + <groupId>org.apache.felix</groupId>
> > + <artifactId>maven-bundle-plugin</artifactId>
> > + </plugin>
> > + </plugins>
> > + </build>
> > + <reporting>
> > + <plugins>
> > + <plugin>
> > + <groupId>org.apache.maven.plugins</groupId>
> > + <artifactId>maven-changes-plugin</artifactId>
> > + <version>${changes.plugin.version}</version>
> > + <reportSets>
> > + <reportSet>
> > + <reports>
> > + <report>changes-report</report>
> > + </reports>
> > + </reportSet>
> > + </reportSets>
> > + <configuration>
> > + <issueLinkTemplate>%URL%/show_bug.cgi?id=%ISSUE%</
> > issueLinkTemplate>
> > + <useJql>true</useJql>
> > + </configuration>
> > + </plugin>
> > + <plugin>
> > + <groupId>org.apache.maven.plugins</groupId>
> > + <artifactId>maven-pmd-plugin</artifactId>
> > + <version>${pmd.plugin.version}</version>
> > + <configuration>
> > + <targetJdk>${maven.compiler.target}</targetJdk>
> > + </configuration>
> > + </plugin>
> > + <plugin>
> > + <groupId>net.alchim31.maven</groupId>
> > + <artifactId>scala-maven-plugin</artifactId>
> > + <version>${scala.maven.plugin.version}</version>
> > + </plugin>
> > + </plugins>
> > + </reporting>
> > +</project>
> >
> > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> > apache/logging/log4j/scala/Logger.scala
> > ----------------------------------------------------------------------
> > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/Logger.scala
> > b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/Logger.scala
> > new file mode 100644
> > index 0000000..b42cd5a
> > --- /dev/null
> > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/Logger.scala
> > @@ -0,0 +1,592 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache license, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the license for the specific language governing permissions and
> > + * limitations under the license.
> > + */
> > +package org.apache.logging.log4j.scala
> > +
> > +import org.apache.logging.log4j.message.{EntryMessage, Message,
> > MessageFactory2}
> > +import org.apache.logging.log4j.spi.ExtendedLogger
> > +import org.apache.logging.log4j.{Level, LogManager, Marker}
> > +
> > +import scala.language.experimental.macros
> > +
> > +/**
> > + * Factory for [[Logger]]s.
> > + *
> > + * The [[Logging]] trait provides a simple way to get a properly named
> > logger into a class.
> > + */
> > +object Logger {
> > +
> > + final val FQCN = getClass.getName
> > +
> > + /**
> > + * Create a properly named [[Logger]] for a given class.
> > + *
> > + * @param clazz the class
> > + */
> > + def apply(clazz: Class[_]): Logger = Logger(LogManager.getContext(
> clazz.getClassLoader,
> > false).getLogger(clazz.getName))
> > +
> > + /**
> > + * Create a [[Logger]] wrapping the given Log4j logger.
> > + *
> > + * @param delegate the Log4j logger to wrap
> > + */
> > + def apply(delegate: ExtendedLogger): Logger = new Logger(delegate)
> > +
> > +}
> > +
> > +/**
> > + * Scala wrapper for the Log4j `Logger` interface.
> > + *
> > + * Frequently the purpose of logging is to provide information about
> > what is happening in the system,
> > + * which requires including information about the objects being
> > manipulated. In Scala, you can use
> > + * [[http://docs.scala-lang.org/overviews/core/string-
> interpolation.html
> > string interpolation]]
> > + * to achieve this:
> > + *
> > + * {{{
> > + * logger.debug(s"Logging in user ${user.getName} with birthday
> > ${user.calcBirthday}")
> > + * }}}
> > + *
> > + * Since this wrapper is implemented with macros, the String
> > construction and method invocations
> > + * will only occur when debug logging is enabled.
> > + */
> > +class Logger private(val delegate: ExtendedLogger) extends AnyVal {
> > +
> > + def fatal(marker: Marker, message: Message): Unit =
> > + macro LoggerMacro.fatalMarkerMsg
> > +
> > + def fatal(marker: Marker, message: CharSequence): Unit =
> > + macro LoggerMacro.fatalMarkerCseq
> > +
> > + 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.fatalMarkerCseqThrowable
> > +
> > + 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.fatalCseq
> > +
> > + 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.fatalCseqThrowable
> > +
> > + 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: CharSequence): Unit =
> > + macro LoggerMacro.errorMarkerCseq
> > +
> > + 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.errorMarkerCseqThrowable
> > +
> > + 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.errorCseq
> > +
> > + 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.errorCseqThrowable
> > +
> > + 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: CharSequence): Unit =
> > + macro LoggerMacro.warnMarkerCseq
> > +
> > + 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.warnMarkerCseqThrowable
> > +
> > + 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.warnCseq
> > +
> > + 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.warnCseqThrowable
> > +
> > + 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: CharSequence): Unit =
> > + macro LoggerMacro.infoMarkerCseq
> > +
> > + 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.infoMarkerCseqThrowable
> > +
> > + 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.infoCseq
> > +
> > + 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.infoCseqThrowable
> > +
> > + 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: CharSequence): Unit =
> > + macro LoggerMacro.debugMarkerCseq
> > +
> > + 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.debugMarkerCseqThrowable
> > +
> > + 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.debugCseq
> > +
> > + 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.debugCseqThrowable
> > +
> > + 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: CharSequence): Unit =
> > + macro LoggerMacro.traceMarkerCseq
> > +
> > + 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.traceMarkerCseqThrowable
> > +
> > + 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.traceCseq
> > +
> > + 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.traceCseqThrowable
> > +
> > + def trace(message: AnyRef, cause: Throwable): Unit =
> > + macro LoggerMacro.traceObjectThrowable
> > +
> > +
> > + /**
> > + * Logs a `Message` with the specific `Marker` at the given `Level`.
> > + *
> > + * @param level the logging level
> > + * @param marker the marker data specific to this log statement
> > + * @param message the message to be logged
> > + */
> > + def apply(level: Level, marker: Marker, message: Message): Unit =
> > + macro LoggerMacro.logMarkerMsg
> > +
> > + /**
> > + * Logs a string with the specific `Marker` at the given `Level`.
> > + *
> > + * @param level the logging level
> > + * @param marker the marker data specific to this log statement
> > + * @param message the message to be logged
> > + */
> > + def apply(level: Level, marker: Marker, message: CharSequence): Unit =
> > + macro LoggerMacro.logMarkerCseq
> > +
> > + /**
> > + * Logs an object with the specific `Marker` at the given `Level`.
> > + *
> > + * @param level the logging level
> > + * @param marker the marker data specific to this log statement
> > + * @param message the message to be logged
> > + */
> > + def apply(level: Level, marker: Marker, message: AnyRef): Unit =
> > + macro LoggerMacro.logMarkerObject
> > +
> > + /**
> > + * Logs a `Message` with the specific `Marker` at the given `Level`
> > including the stack trace
> > + * of the given `Throwable`.
> > + *
> > + * @param level the logging level
> > + * @param marker the marker data specific to this log statement
> > + * @param message the message to be logged
> > + * @param cause the cause
> > + */
> > + def apply(level: Level, marker: Marker, message: Message, cause:
> > Throwable): Unit =
> > + macro LoggerMacro.logMarkerMsgThrowable
> > +
> > + /**
> > + * Logs a string with the specific `Marker` at the given `Level`
> > including the stack trace
> > + * of the given `Throwable`.
> > + *
> > + * @param level the logging level
> > + * @param marker the marker data specific to this log statement
> > + * @param message the message to be logged
> > + * @param cause the cause
> > + */
> > + def apply(level: Level, marker: Marker, message: CharSequence, cause:
> > Throwable): Unit =
> > + macro LoggerMacro.logMarkerCseqThrowable
> > +
> > + /**
> > + * Logs an object with the specific `Marker` at the given `Level`
> > including the stack trace
> > + * of the given `Throwable`.
> > + *
> > + * @param level the logging level
> > + * @param marker the marker data specific to this log statement
> > + * @param message the message to be logged
> > + * @param cause the cause
> > + */
> > + def apply(level: Level, marker: Marker, message: AnyRef, cause:
> > Throwable): Unit =
> > + macro LoggerMacro.logMarkerObjectThrowable
> > +
> > + /**
> > + * Logs a `Message` at the given `Level`.
> > + *
> > + * @param level the logging level
> > + * @param message the message to be logged
> > + */
> > + def apply(level: Level, message: Message): Unit =
> > + macro LoggerMacro.logMsg
> > +
> > + /**
> > + * Logs a string at the given `Level`.
> > + *
> > + * @param level the logging level
> > + * @param message the message to be logged
> > + */
> > + def apply(level: Level, message: CharSequence): Unit =
> > + macro LoggerMacro.logCseq
> > +
> > + /**
> > + * Logs an object at the given `Level`.
> > + *
> > + * @param level the logging level
> > + * @param message the message to be logged
> > + */
> > + def apply(level: Level, message: AnyRef): Unit =
> > + macro LoggerMacro.logObject
> > +
> > + /**
> > + * Logs a `Message` at the given `Level` including the stack trace of
> > the given `Throwable`.
> > + *
> > + * @param level the logging level
> > + * @param message the message to be logged
> > + * @param cause a `Throwable`
> > + */
> > + def apply(level: Level, message: Message, cause: Throwable): Unit =
> > + macro LoggerMacro.logMsgThrowable
> > +
> > + /**
> > + * Logs a string at the given `Level` including the stack trace of
> the
> > given `Throwable`.
> > + *
> > + * @param level the logging level
> > + * @param message the message to be logged
> > + * @param cause a `Throwable`
> > + */
> > + def apply(level: Level, message: CharSequence, cause: Throwable):
> Unit =
> > + macro LoggerMacro.logCseqThrowable
> > +
> > + /**
> > + * Logs an object at the given `Level` including the stack trace of
> > the given `Throwable`.
> > + *
> > + * @param level the logging level
> > + * @param message the message to be logged
> > + * @param cause a `Throwable`
> > + */
> > + def apply(level: Level, message: AnyRef, cause: Throwable): Unit =
> > + macro LoggerMacro.logObjectThrowable
> > +
> > +
> > + /**
> > + * Logs entry to a method. Used when the method in question has no
> > parameters or when the parameters should not be
> > + * logged.
> > + *
> > + * @return The built `EntryMessage`
> > + */
> > + def traceEntry(): EntryMessage =
> > + macro LoggerMacro.traceEntry
> > +
> > + /**
> > + * Logs entry to a method along with its parameters.
> > + *
> > + * {{{
> > + * def doSomething(foo: String, bar: Int): Unit = {
> > + * logger.traceEntry(foo, bar)
> > + * // do something
> > + * }
> > + * }}}
> > + *
> > + * @param params the parameters to the method.
> > + * @return The built `EntryMessage`
> > + */
> > + def traceEntry(params: AnyRef*): EntryMessage =
> > + macro LoggerMacro.traceEntryParams
> > +
> > + /**
> > + * Logs entry to a method using a `Message` to describe the
> parameters.
> > + *
> > + * {{{
> > + * def doSomething(foo: Request): Unit = {
> > + * logger.traceEntry(JsonMessage(foo))
> > + * // do something
> > + * }
> > + * }}}
> > + *
> > + * @param message the message
> > + * @return The built `EntryMessage`
> > + */
> > + def traceEntry(message: Message): EntryMessage =
> > + macro LoggerMacro.traceEntryMessage
> > +
> > + /**
> > + * Logs exit from a method with no result.
> > + */
> > + def traceExit(): Unit =
> > + macro LoggerMacro.traceExit
> > +
> > + /**
> > + * Logs exiting from a method with result.
> > + *
> > + * @param result The result being returned from the method call
> > + * @return `result`
> > + */
> > + def traceExit[R](result: R): R =
> > + macro LoggerMacro.traceExitResult[R]
> > +
> > + /**
> > + * Logs exiting from a method with no result.
> > + *
> > + * @param entryMessage the `EntryMessage` returned from one of the
> > `traceEntry` methods
> > + */
> > + def traceExit(entryMessage: EntryMessage): Unit =
> > + macro LoggerMacro.traceExitEntryMessage
> > +
> > + /**
> > + * Logs exiting from a method with result.
> > + *
> > + * {{{
> > + * def doSomething(foo: String, bar: Int): Int = {
> > + * val entryMessage = logger.traceEntry(foo, bar)
> > + * // do something
> > + * traceExit(entryMessage, value)
> > + * }
> > + * }}}
> > + *
> > + * @param entryMessage the `EntryMessage` returned from one of the
> > `traceEntry` methods
> > + * @param result The result being returned from the method call
> > + * @return `result`
> > + */
> > + def traceExit[R](entryMessage: EntryMessage, result: R): R =
> > + macro LoggerMacro.traceExitEntryMessageResult[R]
> > +
> > + /**
> > + * Logs exiting from a method with result. Allows custom formatting
> of
> > the result.
> > + *
> > + * @param message the Message containing the formatted result
> > + * @param result The result being returned from the method call.
> > + * @return `result`
> > + */
> > + def traceExit[R](message: Message, result: R): R =
> > + macro LoggerMacro.traceExitMessageResult[R]
> > +
> > + /**
> > + * Logs an exception or error to be thrown.
> > + *
> > + * {{{
> > + * throw logger.throwing(myException)
> > + * }}}
> > + *
> > + * @param t the Throwable
> > + * @return `t`
> > + */
> > + def throwing[T <: Throwable](t: T): T =
> > + macro LoggerMacro.throwing[T]
> > +
> > + /**
> > + * Logs an exception or error to be thrown to a specific logging
> level.
> > + *
> > + * {{{
> > + * throw logger.throwing(Level.DEBUG, myException)
> > + * }}}
> > + *
> > + * @param level the logging Level.
> > + * @param t the Throwable
> > + * @return `t`
> > + */
> > + def throwing[T <: Throwable](level: Level, t: T): T =
> > + macro LoggerMacro.throwingLevel[T]
> > +
> > + /**
> > + * Logs an exception or error that has been caught.
> > + *
> > + * @param t the Throwable.
> > + */
> > + def catching(t: Throwable): Unit =
> > + macro LoggerMacro.catching
> > +
> > + /**
> > + * Logs an exception or error that has been caught to a specific
> > logging level.
> > + *
> > + * @param level The logging Level.
> > + * @param t The Throwable.
> > + */
> > + def catching(level: Level, t: Throwable): Unit =
> > + macro LoggerMacro.catchingLevel
> > +
> > +
> > + /** 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: Message, cause:
> > Throwable): Unit = {
> > + delegate.logMessage(Logger.FQCN, level, marker, 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: CharSequence,
> > cause: Throwable): Unit = {
> > + delegate.logMessage(Logger.FQCN, level, marker,
> > delegate.getMessageFactory.asInstanceOf[MessageFactory2].
> 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(Logger.FQCN, level, marker,
> > delegate.getMessageFactory.asInstanceOf[MessageFactory2].
> newMessage(message),
> > cause)
> > + }
> > +
> > +}
> >
> > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> > apache/logging/log4j/scala/LoggerMacro.scala
> > ----------------------------------------------------------------------
> > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/LoggerMacro.scala
> > b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/LoggerMacro.scala
> > new file mode 100644
> > index 0000000..3b54db1
> > --- /dev/null
> > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/LoggerMacro.scala
> > @@ -0,0 +1,425 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache license, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the license for the specific language governing permissions and
> > + * limitations under the license.
> > + */
> > +package org.apache.logging.log4j.scala
> > +
> > +import org.apache.logging.log4j.message.{EntryMessage, Message}
> > +import org.apache.logging.log4j.spi.AbstractLogger
> > +import org.apache.logging.log4j.{Level, Marker}
> > +
> > +import scala.language.experimental.macros
> > +import scala.reflect.macros.blackbox
> > +
> > +/**
> > + * Inspired from [[https://github.com/typesafehub/scalalogging
> > ScalaLogging]].
> > + */
> > +private object LoggerMacro {
> > +
> > + 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.FATAL), marker, message)
> > +
> > + def fatalMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> > c.Expr[CharSequence]) =
> > + logMarkerCseq(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 fatalMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > + logMarkerCseqThrowable(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 fatalCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > + logCseq(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 fatalCseqThrowable(c: LoggerContext)(message:
> c.Expr[CharSequence],
> > cause: c.Expr[Throwable]) =
> > + logCseqThrowable(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 errorMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> > c.Expr[CharSequence]) =
> > + logMarkerCseq(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 errorMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > + logMarkerCseqThrowable(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 errorCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > + logCseq(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 errorCseqThrowable(c: LoggerContext)(message:
> c.Expr[CharSequence],
> > cause: c.Expr[Throwable]) =
> > + logCseqThrowable(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 warnMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> > c.Expr[CharSequence]) =
> > + logMarkerCseq(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 warnMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > + logMarkerCseqThrowable(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 warnCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > + logCseq(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 warnCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence],
> > cause: c.Expr[Throwable]) =
> > + logCseqThrowable(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 infoMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> > c.Expr[CharSequence]) =
> > + logMarkerCseq(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 infoMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > + logMarkerCseqThrowable(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 infoCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > + logCseq(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 infoCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence],
> > cause: c.Expr[Throwable]) =
> > + logCseqThrowable(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 debugMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> > c.Expr[CharSequence]) =
> > + logMarkerCseq(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 debugMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > + logMarkerCseqThrowable(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 debugCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > + logCseq(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 debugCseqThrowable(c: LoggerContext)(message:
> c.Expr[CharSequence],
> > cause: c.Expr[Throwable]) =
> > + logCseqThrowable(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 traceMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> > c.Expr[CharSequence]) =
> > + logMarkerCseq(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 traceMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> > message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> > + logMarkerCseqThrowable(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 traceCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> > + logCseq(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 traceCseqThrowable(c: LoggerContext)(message:
> c.Expr[CharSequence],
> > cause: c.Expr[Throwable]) =
> > + logCseqThrowable(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)) {
> > + c.prefix.splice.logMessage(level.splice, marker.splice,
> > message.splice, null)
> > + }
> > + )
> > +
> > + def logMarkerCseq(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, null)
> > + }
> > + )
> > +
> > + 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 logMarkerCseqThrowable(c: LoggerContext)(level: c.Expr[Level],
> > marker: c.Expr[Marker], message: c.Expr[CharSequence], 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 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)) {
> > + c.prefix.splice.logMessage(level.splice, null, message.splice,
> > null)
> > + }
> > + )
> > +
> > + def logCseq(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,
> > null)
> > + }
> > + )
> > +
> > + 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 logCseqThrowable(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)) {
> > + c.prefix.splice.logMessage(level.splice, null, message.splice,
> > cause.splice)
> > + }
> > + )
> > +
> > + 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)
> > + }
> > + )
> > +
> > +
> > + def traceEntry(c: LoggerContext)(): c.Expr[EntryMessage] =
> > + c.universe.reify(
> > + c.prefix.splice.delegate.traceEntry()
> > + )
> > +
> > + def traceEntryParams(c: LoggerContext)(params: c.Expr[AnyRef]*):
> > c.Expr[EntryMessage] = {
> > + import c.universe._
> > + val isEnabled = Apply(
> > + Select(Select(c.prefix.tree, TermName("delegate")),
> > TermName("isEnabled")),
> > + List(
> > + reify(Level.TRACE).tree,
> > + reify(AbstractLogger.ENTRY_MARKER).tree,
> > + reify(null: AnyRef).tree,
> > + reify(null).tree
> > + )
> > + )
> > +
> > + val log = Apply(
> > + Select(Select(c.prefix.tree, TermName("delegate")),
> > TermName("traceEntry")),
> > + reify(null: String).tree :: (params map (_.tree)).toList
> > + )
> > + c.Expr[EntryMessage](If(isEnabled, log, reify(null).tree))
> > + }
> > +
> > +
> > + def traceEntryMessage(c: LoggerContext)(message: c.Expr[Message]):
> > c.Expr[EntryMessage] =
> > + c.universe.reify(
> > + if (c.prefix.splice.delegate.isEnabled(Level.TRACE,
> > AbstractLogger.ENTRY_MARKER, null: AnyRef, null)) {
> > + c.prefix.splice.delegate.traceEntry(message.splice) // TODO
> > should not do ifEnabled check
> > + } else {
> > + null
> > + }
> > + )
> > +
> > + def traceExit(c: LoggerContext)(): c.Expr[Unit] =
> > + c.universe.reify(
> > + c.prefix.splice.delegate.traceExit()
> > + )
> > +
> > + def traceExitResult[R: c.WeakTypeTag](c: LoggerContext)(result:
> > c.Expr[R]): c.Expr[R] =
> > + c.universe.reify(
> > + c.prefix.splice.delegate.traceExit(result.splice)
> > + )
> > +
> > + def traceExitEntryMessage(c: LoggerContext)(entryMessage:
> > c.Expr[EntryMessage]): c.Expr[Unit] =
> > + c.universe.reify(
> > + c.prefix.splice.delegate.traceExit(entryMessage.splice)
> > + )
> > +
> > + def traceExitEntryMessageResult[R: c.WeakTypeTag](c:
> > LoggerContext)(entryMessage: c.Expr[EntryMessage], result: c.Expr[R]):
> > c.Expr[R] =
> > + c.universe.reify(
> > + c.prefix.splice.delegate.traceExit(entryMessage.splice,
> > result.splice)
> > + )
> > +
> > + def traceExitMessageResult[R: c.WeakTypeTag](c:
> LoggerContext)(message:
> > c.Expr[Message], result: c.Expr[R]): c.Expr[R] =
> > + c.universe.reify(
> > + {
> > + if (message.splice != null && c.prefix.splice.delegate.
> isEnabled(Level.TRACE,
> > AbstractLogger.EXIT_MARKER, message.splice, null)) {
> > + c.prefix.splice.delegate.traceExit(message.splice,
> > result.splice) // TODO should not do ifEnabled check
> > + }
> > + result.splice
> > + }
> > + )
> > +
> > + def throwing[T <: Throwable: c.WeakTypeTag](c: LoggerContext)(t:
> > c.Expr[T]): c.Expr[T] =
> > + c.universe.reify(
> > + c.prefix.splice.delegate.throwing(t.splice)
> > + )
> > +
> > + def throwingLevel[T <: Throwable: c.WeakTypeTag](c:
> > LoggerContext)(level: c.Expr[Level], t: c.Expr[T]): c.Expr[T] =
> > + c.universe.reify(
> > + c.prefix.splice.delegate.throwing(level.splice, t.splice)
> > + )
> > +
> > + def catching(c: LoggerContext)(t: c.Expr[Throwable]): c.Expr[Unit] =
> > + c.universe.reify(
> > + c.prefix.splice.delegate.catching(t.splice)
> > + )
> > +
> > + def catchingLevel(c: LoggerContext)(level: c.Expr[Level], t:
> > c.Expr[Throwable]): c.Expr[Unit] =
> > + c.universe.reify(
> > + c.prefix.splice.delegate.catching(level.splice, t.splice)
> > + )
> > +
> > +}
> >
> > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> > apache/logging/log4j/scala/Logging.scala
> > ----------------------------------------------------------------------
> > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/Logging.scala
> > b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/Logging.scala
> > new file mode 100644
> > index 0000000..b017de7
> > --- /dev/null
> > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/Logging.scala
> > @@ -0,0 +1,30 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache license, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the license for the specific language governing permissions and
> > + * limitations under the license.
> > + */
> > +package org.apache.logging.log4j.scala
> > +
> > +/**
> > + * Mix in this trait into classes from which you want to log,
> > + * give you a `logger` value with a [[Logger]] named according to the
> > class.
> > + */
> > +trait Logging {
> > +
> > + /**
> > + * A [[Logger]] named according to the class.
> > + */
> > + protected val logger: Logger = Logger(getClass)
> > +
> > +}
> > \ No newline at end of file
> >
> > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> > apache/logging/log4j/scala/LoggingContext.scala
> > ----------------------------------------------------------------------
> > diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/LoggingContext.scala b/log4j-api-scala_2.13/src/
> > main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
> > new file mode 100644
> > index 0000000..79efecc
> > --- /dev/null
> > +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> > log4j/scala/LoggingContext.scala
> > @@ -0,0 +1,84 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache license, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the license for the specific language governing permissions and
> > + * limitations under the license.
> > + */
> > +package org.apache.logging.log4j.scala
> > +
> > +import org.apache.logging.log4j.ThreadContext
> > +
> > +import scala.collection.JavaConverters._
> > +import scala.collection.{immutable, mutable}
> > +
> > +/** Manages the context data (context map, MDC) that is added to log
> > events.
> > + *
> > + * A wrapper around `org.apache.logging.log4j.ThreadContext`.
> > + */
> > +object LoggingContext extends mutable.Map[String, String] {
> > +
> > + override def +=(kv: (String, String)): LoggingContext.this.type = {
> > + ThreadContext.put(kv._1, kv._2)
> > + this
> > + }
> > +
> > + override def +=(elem1: (String, String), elem2: (String, String),
> > elems: (String, String)*): LoggingContext.this.type = {
> > + val builder = immutable.Map.newBuilder[String,String]
> > + builder += elem1
> > + builder += elem2
> > + builder ++= elems
> > + ThreadContext.putAll(builder.result.asJava)
> > + this
> > + }
> > +
> > + override def ++=(xs: TraversableOnce[(String, String)]):
> > LoggingContext.this.type = {
> > + ThreadContext.putAll(xs.toMap.asJava)
> > + this
> > + }
> > +
> > + override def -=(key: String): LoggingContext.this.type = {
> > + ThreadContext.remove(key)
> > + this
> > + }
> > +
> > + override def -=(elem1: String, elem2: String, elems: String*):
> > LoggingContext.this.type = {
> > + val builder = immutable.Seq.newBuilder[String]
> > + builder += elem1
> > + builder += elem2
> > + builder ++= elems
> > + ThreadContext.removeAll(builder.result.asJava)
> > + this
> > + }
> > +
> > + override def --=(xs: TraversableOnce[String]):
> LoggingContext.this.type
> > = {
> > + ThreadContext.removeAll(xs.toSeq.asJava)
> > + this
> > + }
> > +
> > + override def clear(): Unit = {
> > + ThreadContext.clearMap()
> > + }
> > +
> > + override def contains(key: String): Boolean =
> > ThreadContext.containsKey(key)
> > +
> > + override def get(key: String): Option[String] =
> > Option(ThreadContext.get(key))
> > +
> > + override def iterator: Iterator[(String, String)] = ThreadContext.
> > getImmutableContext.asScala.iterator
> > +
> > + override def foreach[U](f: ((String, String)) => U): Unit =
> > ThreadContext.getImmutableContext.asScala.foreach(f)
> > +
> > + override def size: Int = ThreadContext.getImmutableContext.size()
> > +
> > + override def isEmpty: Boolean = ThreadContext.isEmpty
> > +
> > +}
> >
> > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > blob/184045cb/log4j-api-scala_2.13/src/site/markdown/index.md
> > ----------------------------------------------------------------------
> > diff --git a/log4j-api-scala_2.13/src/site/markdown/index.md
> > b/log4j-api-scala_2.13/src/site/markdown/index.md
> > new file mode 100644
> > index 0000000..7acf397
> > --- /dev/null
> > +++ b/log4j-api-scala_2.13/src/site/markdown/index.md
> > @@ -0,0 +1,74 @@
> > +<!--
> > + Licensed to the Apache Software Foundation (ASF) under one or more
> > + contributor license agreements. See the NOTICE file distributed
> with
> > + this work for additional information regarding copyright ownership.
> > + The ASF licenses this file to You under the Apache License, Version
> > 2.0
> > + (the "License"); you may not use this file except in compliance with
> > + the License. You may obtain a copy of the License at
> > +
> > + http://www.apache.org/licenses/LICENSE-2.0
> > +
> > + Unless required by applicable law or agreed to in writing, software
> > + distributed under the License is distributed on an "AS IS" BASIS,
> > + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + See the License for the specific language governing permissions and
> > + limitations under the License.
> > +-->
> > +# Log4j Scala 2.12 API
> > +
> > +## Requirements
> > +
> > +Log4j Scala API for Scala 2.12 requires Log4j API, Java 8, the Scala
> > runtime
> > +library, and the Scala reflection library. To use Log4j as a logging
> > implementation,
> > +then Log4j Core must also be included. Instructions on using these
> > dependencies are
> > +in the [dependency information page][dependencies], and additional
> > information is
> > +included in the [Log4j artifacts][artifacts] page.
> > +
> > +## Example Usage
> > +
> > +<pre class="prettyprint linenums">
> > +import org.apache.logging.log4j.scala.Logging
> > +import org.apache.logging.log4j.Level
> > +
> > +class MyClass extends BaseClass with Logging {
> > + def doStuff(): Unit = {
> > + logger.info("Doing stuff")
> > + }
> > + def doStuffWithLevel(level: Level): Unit = {
> > + logger(level, "Doing stuff with arbitrary level")
> > + }
> > +}
> > +</pre>
> > +
> > +## Configuration
> > +
> > +Log4j Scala 2.12 API uses the standard [Log4j
> > configuration][configuration]
> > +plugins. This supports XML, properties files, and a configuration
> builder
> > DSL by
> > +default, and it optionally supports JSON and YAML formats with some
> > additional
> > +Jackson dependencies.
> > +
> > +## Substituting Parameters
> > +
> > +In the Java API, parameters to a log message are interpolated using
> > various
> > +strategies. In the Scala API, [string interpolation][interpolation] is
> > used
> > +instead. As all logger methods are implemented as macros, string
> > construction and
> > +method invocations will only occur when logging is enabled for the given
> > log
> > +level. For example:
> > +
> > +<pre class="prettyprint linenums">
> > +logger.debug(s"Logging in user ${user.getName} with birthday
> > ${user.calcBirthday}")
> > +</pre>
> > +
> > +## Logger Names
> > +
> > +Most logging implementations use a hierarchical scheme for matching
> > logger names
> > +with logging configuration. In this scheme the logger name hierarchy is
> > +represented by '.' characters in the logger name, in a fashion very
> > similar to
> > +the hierarchy used for Java/Scala package names. The [`Logging`
> > trait][logging]
> > +will automatically name the Logger accordingly to the class it is being
> > used in.
> > +
> > +[dependencies]: dependency-info.html
> > +[artifacts]: ../maven-artifacts.html
> > +[configuration]: ../configuration.html
> > +[interpolation]: http://docs.scala-lang.org/overviews/core/string-
> > interpolation.html
> > +[logging]: scaladocs/org/apache/logging/log4j/scala/Logging.html
> > \ No newline at end of file
> >
> > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > blob/184045cb/log4j-api-scala_2.13/src/site/site.xml
> > ----------------------------------------------------------------------
> > diff --git a/log4j-api-scala_2.13/src/site/site.xml
> > b/log4j-api-scala_2.13/src/site/site.xml
> > new file mode 100644
> > index 0000000..f46fa51
> > --- /dev/null
> > +++ b/log4j-api-scala_2.13/src/site/site.xml
> > @@ -0,0 +1,30 @@
> > +<?xml version="1.0" encoding="utf-8"?>
> > +<!--
> > + ~ Licensed to the Apache Software Foundation (ASF) under one or more
> > + ~ contributor license agreements. See the NOTICE file distributed with
> > + ~ this work for additional information regarding copyright ownership.
> > + ~ The ASF licenses this file to You under the Apache license, Version
> > 2.0
> > + ~ (the "License"); you may not use this file except in compliance with
> > + ~ the License. You may obtain a copy of the License at
> > + ~
> > + ~ http://www.apache.org/licenses/LICENSE-2.0
> > + ~
> > + ~ Unless required by applicable law or agreed to in writing, software
> > + ~ distributed under the License is distributed on an "AS IS" BASIS,
> > + ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + ~ See the license for the specific language governing permissions and
> > + ~ limitations under the license.
> > + -->
> > +<project name="Log4j Scala API"
> > + xmlns="http://maven.apache.org/DECORATION/1.7.0"
> > + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
> > + xsi:schemaLocation="http://maven.apache.org/DECORATION/1.7.0
> > http://maven.apache.org/xsd/decoration-1.7.0.xsd">
> > + <body>
> > + <links>
> > + <item name="Apache" href="http://www.apache.org/"/>
> > + <item name="Logging Services" href="http://logging.apache.
> > org/"/>
> > + <item name="Log4j" href="../index.html"/>
> > + </links>
> > + <menu ref="reports"/>
> > + </body>
> > +</project>
> > \ No newline at end of file
> >
> > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > blob/184045cb/log4j-api-scala_2.13/src/test/scala/org/
> > apache/logging/log4j/scala/LoggerTest.scala
> > ----------------------------------------------------------------------
> > diff --git a/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> log4j/scala/LoggerTest.scala
> > b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> > log4j/scala/LoggerTest.scala
> > new file mode 100644
> > index 0000000..bd12742
> > --- /dev/null
> > +++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> > log4j/scala/LoggerTest.scala
> > @@ -0,0 +1,552 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache license, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the license for the specific language governing permissions and
> > + * limitations under the license.
> > + */
> > +package org.apache.logging.log4j.scala
> > +
> > +import org.apache.logging.log4j.message.{DefaultFlowMessageFactory,
> > Message, ParameterizedMessage, ParameterizedMessageFactory}
> > +import org.apache.logging.log4j.spi.{AbstractLogger, ExtendedLogger}
> > +import org.apache.logging.log4j.{Level, Marker, MarkerManager}
> > +import org.junit.runner.RunWith
> > +import org.mockito.Matchers.{any, anyString, eq => eqv}
> > +import org.mockito.Mockito._
> > +import org.scalatest.junit.JUnitRunner
> > +import org.scalatest.mockito.MockitoSugar
> > +import org.scalatest.{FunSuite, Matchers}
> > +
> > +import scala.language.reflectiveCalls // needed for Mockito mocking
> > +
> > +case class Custom(i: Int)
> > +
> > +trait Manager {
> > + def fetchValue(): Int
> > +}
> > +
> > +@RunWith(classOf[JUnitRunner])
> > +class LoggerTest extends FunSuite with Matchers with MockitoSugar {
> > +
> > + val msg = new ParameterizedMessage("msg {}", 17)
> > + val entryMsg = new DefaultFlowMessageFactory().newEntryMessage(msg)
> > + val cseqMsg: CharSequence = new StringBuilder().append("cseq msg")
> > + val objectMsg = Custom(17)
> > + val cause = new RuntimeException("cause")
> > + val marker = MarkerManager.getMarker("marker")
> > + val result = "foo"
> > +
> > + def fixture =
> > + new {
> > + val mockLogger = {
> > + val mockLogger = mock[ExtendedLogger]
> > + when(mockLogger.getMessageFactory).thenReturn(new
> > ParameterizedMessageFactory)
> > + mockLogger
> > + }
> > + val manager = {
> > + val mockManager = mock[Manager]
> > + when(mockManager.fetchValue()).thenReturn(4711)
> > + mockManager
> > + }
> > + }
> > +
> > + test("fatal enabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.FATAL),
> > eqv(null), any[Message], eqv(null))
> > + verify(f.manager).fetchValue()
> > + }
> > +
> > + test("fatal disabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + verify(f.manager, never).fetchValue()
> > + }
> > +
> > + test("error enabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.error(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.ERROR),
> > eqv(null), any[Message], eqv(null))
> > + verify(f.manager).fetchValue()
> > + }
> > +
> > + test("error disabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger.error(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + verify(f.manager, never).fetchValue()
> > + }
> > +
> > + test("warn enabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.WARN),
> > eqv(null), any[Message], eqv(null))
> > + verify(f.manager).fetchValue()
> > + }
> > +
> > + test("warn disabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + verify(f.manager, never).fetchValue()
> > + }
> > +
> > + test("info enabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.info(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(null), any[Message], eqv(null))
> > + verify(f.manager).fetchValue()
> > + }
> > +
> > + test("info disabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger.info(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + verify(f.manager, never).fetchValue()
> > + }
> > +
> > + test("debug enabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.DEBUG),
> > eqv(null), any[Message], eqv(null))
> > + verify(f.manager).fetchValue()
> > + }
> > +
> > + test("debug disabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + verify(f.manager, never).fetchValue()
> > + }
> > +
> > + test("trace enabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.TRACE),
> > eqv(null), any[Message], eqv(null))
> > + verify(f.manager).fetchValue()
> > + }
> > +
> > + test("trace disabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + verify(f.manager, never).fetchValue()
> > + }
> > +
> > +
> > + test("log enabled with Message message and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, msg)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(marker), eqv(msg), eqv(null))
> > + }
> > +
> > + test("log disabled with Message message and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, msg)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with String message and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, s"string msg with value:
> > ${f.manager.fetchValue()}")
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(marker), any[Message], eqv(null))
> > + verify(f.manager).fetchValue()
> > + }
> > +
> > + test("log disabled with String message and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, s"string msg with value:
> > ${f.manager.fetchValue()}")
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + verify(f.manager, never).fetchValue()
> > + }
> > +
> > + test("log enabled with CharSequence message and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, cseqMsg)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(marker), any[Message], eqv(null))
> > + }
> > +
> > + test("log disabled with CharSequence message and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, cseqMsg)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with Object message and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, objectMsg)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(marker), any[Message], eqv(null))
> > + }
> > +
> > + test("log disabled with Object message and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, objectMsg)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with Message message and cause and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, msg, cause)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(marker), eqv(msg), eqv(cause))
> > + }
> > +
> > + test("log disabled with Message message and cause and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, msg, cause)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with String message and cause and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, s"string msg with value:
> > ${f.manager.fetchValue()}", cause)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(marker), any[Message], eqv(cause))
> > + verify(f.manager).fetchValue()
> > + }
> > +
> > + test("log disabled with String message and cause and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, s"string msg with value:
> > ${f.manager.fetchValue()}", cause)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + verify(f.manager, never).fetchValue()
> > + }
> > +
> > + test("log enabled with CharSequence message and cause and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, cseqMsg, cause)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(marker), any[Message], eqv(cause))
> > + }
> > +
> > + test("log disabled with CharSequence message and cause and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, cseqMsg, cause)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with Object message and cause and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, objectMsg, cause)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(marker), any[Message], eqv(cause))
> > + }
> > +
> > + test("log disabled with Object message and cause and Marker") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, marker, objectMsg, cause)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with Message message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, msg)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(null), eqv(msg), eqv(null))
> > + }
> > +
> > + test("log disabled with Message message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, msg)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, s"string msg with value:
> > ${f.manager.fetchValue()}")
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(null), any[Message], eqv(null))
> > + verify(f.manager).fetchValue()
> > + }
> > +
> > + test("log disabled with String message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, s"string msg with value:
> > ${f.manager.fetchValue()}")
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + verify(f.manager, never).fetchValue()
> > + }
> > +
> > + test("log enabled with CharSequence message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, cseqMsg)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(null), any[Message], eqv(null))
> > + }
> > +
> > + test("log disabled with CharSequence message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, cseqMsg)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with Object message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, objectMsg)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(null), any[Message], eqv(null))
> > + }
> > +
> > + test("log disabled with Object message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, objectMsg)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with Message message and cause") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, msg, cause)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(null), eqv(msg), eqv(cause))
> > + }
> > +
> > + test("log disabled with Message message and cause") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, msg, cause)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with String message and cause") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, s"string msg with value:
> > ${f.manager.fetchValue()}", cause)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(null), any[Message], eqv(cause))
> > + verify(f.manager).fetchValue()
> > + }
> > +
> > + test("log disabled with String message and cause") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, s"string msg with value:
> > ${f.manager.fetchValue()}", cause)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + verify(f.manager, never).fetchValue()
> > + }
> > +
> > + test("log enabled with CharSequence message and cause") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, cseqMsg, cause)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(null), any[Message], eqv(cause))
> > + }
> > +
> > + test("log disabled with CharSequence message and cause") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, cseqMsg, cause)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > + test("log enabled with Object message and cause") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, objectMsg, cause)
> > + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> > eqv(null), any[Message], eqv(cause))
> > + }
> > +
> > + test("log disabled with Object message and cause") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger(Level.INFO, objectMsg, cause)
> > + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> > any[Marker], any[Message], any[Throwable])
> > + }
> > +
> > +
> > + test("traceEntry") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> > null)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceEntry()
> > + verify(f.mockLogger).traceEntry()
> > + }
> > +
> > + test("traceEntry enabled with params") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> > null)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceEntry("foo", "bar")
> > + verify(f.mockLogger).traceEntry(null: String, "foo", "bar")
> > + }
> > +
> > + test("traceEntry disabled with params") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> > null)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceEntry("foo", "bar")
> > + verify(f.mockLogger, never).traceEntry(anyString(), anyString(),
> > anyString())
> > + }
> > +
> > + test("traceEntry enabled with message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> > null)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceEntry(msg)
> > + verify(f.mockLogger).traceEntry(eqv(msg))
> > + }
> > +
> > + test("traceEntry disabled with message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> > AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> > null)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceEntry(msg)
> > + verify(f.mockLogger, never).traceEntry(any[Message])
> > + }
> > +
> > + test("traceExit") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.EXIT_MARKER,
> > msg, null)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceExit()
> > + verify(f.mockLogger).traceExit()
> > + }
> > +
> > + test("traceExit with result") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.EXIT_MARKER,
> > msg, null)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceExit(result)
> > + verify(f.mockLogger).traceExit(result)
> > + }
> > +
> > + test("traceExit with entrymessage") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.EXIT_MARKER,
> > msg, null)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceExit(entryMsg)
> > + verify(f.mockLogger).traceExit(entryMsg)
> > + }
> > +
> > + test("traceExit with entrymessage and result") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.EXIT_MARKER,
> > msg, null)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceExit(entryMsg, result)
> > + verify(f.mockLogger).traceExit(entryMsg, result)
> > + }
> > +
> > + test("traceExit enabled with message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.EXIT_MARKER,
> > msg, null)).thenReturn(true)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceExit(msg, result)
> > + verify(f.mockLogger).traceExit(eqv(msg), eqv(result))
> > + }
> > +
> > + test("traceExit disabled with message") {
> > + val f = fixture
> > + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.EXIT_MARKER,
> > msg, null)).thenReturn(false)
> > + val logger = Logger(f.mockLogger)
> > + logger.traceExit(msg, result)
> > + verify(f.mockLogger, never).traceExit(any[Message], any[AnyRef])
> > + }
> > +
> > + test("throwing") {
> > + val f = fixture
> > + val logger = Logger(f.mockLogger)
> > + logger.throwing(cause)
> > + verify(f.mockLogger).throwing(eqv(cause))
> > + }
> > +
> > + test("throwing with level") {
> > + val f = fixture
> > + val logger = Logger(f.mockLogger)
> > + logger.throwing(Level.INFO, cause)
> > + verify(f.mockLogger).throwing(eqv(Level.INFO), eqv(cause))
> > + }
> > +
> > + test("catching") {
> > + val f = fixture
> > + val logger = Logger(f.mockLogger)
> > + logger.catching(cause)
> > + verify(f.mockLogger).catching(eqv(cause))
> > + }
> > +
> > + test("catching with level") {
> > + val f = fixture
> > + val logger = Logger(f.mockLogger)
> > + logger.catching(Level.INFO, cause)
> > + verify(f.mockLogger).catching(eqv(Level.INFO), eqv(cause))
> > + }
> > +
> > +}
> >
> > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > blob/184045cb/log4j-api-scala_2.13/src/test/scala/org/
> > apache/logging/log4j/scala/LoggingContextTest.scala
> > ----------------------------------------------------------------------
> > diff --git a/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> > log4j/scala/LoggingContextTest.scala b/log4j-api-scala_2.13/src/
> > test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
> > new file mode 100644
> > index 0000000..80ca940
> > --- /dev/null
> > +++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> log4j/scala/
> > LoggingContextTest.scala
> > @@ -0,0 +1,115 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache license, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the license for the specific language governing permissions and
> > + * limitations under the license.
> > + */
> > +package org.apache.logging.log4j.scala
> > +
> > +import org.junit.runner.RunWith
> > +import org.scalatest.junit.JUnitRunner
> > +import org.scalatest.{FunSuite, Matchers}
> > +
> > +import scala.collection.mutable
> > +
> > +@RunWith(classOf[JUnitRunner])
> > +class LoggingContextTest extends FunSuite with Matchers {
> > +
> > + test("put single, contains, get") {
> > + LoggingContext += "key" -> "value"
> > +
> > + LoggingContext.contains("key") shouldBe true
> > + LoggingContext.get("key") shouldBe Some("value")
> > + LoggingContext.contains("bogus") shouldBe false
> > + LoggingContext.get("bogus") shouldBe None
> > + }
> > +
> > + test("put multiple 1") {
> > + LoggingContext += ("key1" -> "value1", "key2" -> "value2")
> > +
> > + LoggingContext.get("key1") shouldBe Some("value1")
> > + LoggingContext.get("key2") shouldBe Some("value2")
> > + }
> > +
> > + test("put multiple 2") {
> > + LoggingContext ++= Seq("key1" -> "value1", "key2" -> "value2")
> > +
> > + LoggingContext.get("key1") shouldBe Some("value1")
> > + LoggingContext.get("key2") shouldBe Some("value2")
> > + }
> > +
> > + test("remove single") {
> > + LoggingContext += ("key1" -> "value1")
> > + LoggingContext += ("key2" -> "value2")
> > + LoggingContext += ("key3" -> "value3")
> > +
> > + LoggingContext -= "key1"
> > +
> > + LoggingContext.get("key1") shouldBe None
> > + LoggingContext.get("key2") shouldBe Some("value2")
> > + LoggingContext.get("key3") shouldBe Some("value3")
> > + }
> > +
> > + test("remove multiple 1") {
> > + LoggingContext += ("key1" -> "value1")
> > + LoggingContext += ("key2" -> "value2")
> > + LoggingContext += ("key3" -> "value3")
> > +
> > + LoggingContext -= ("key1", "key2")
> > +
> > + LoggingContext.get("key1") shouldBe None
> > + LoggingContext.get("key2") shouldBe None
> > + LoggingContext.get("key3") shouldBe Some("value3")
> > + }
> > +
> > + test("remove multiple 2") {
> > + LoggingContext += ("key1" -> "value1")
> > + LoggingContext += ("key2" -> "value2")
> > + LoggingContext += ("key3" -> "value3")
> > +
> > + LoggingContext --= Seq("key1", "key2")
> > +
> > + LoggingContext.get("key1") shouldBe None
> > + LoggingContext.get("key2") shouldBe None
> > + LoggingContext.get("key3") shouldBe Some("value3")
> > + }
> > +
> > + test("clear, size, isEmpty") {
> > + LoggingContext += ("key" -> "value")
> > +
> > + LoggingContext.clear()
> > +
> > + LoggingContext.contains("key") shouldBe false
> > + LoggingContext.size shouldBe 0
> > + LoggingContext.isEmpty shouldBe true
> > + }
> > +
> > + test("iterator") {
> > + LoggingContext += ("key1" -> "value1")
> > + LoggingContext += ("key2" -> "value2")
> > +
> > + LoggingContext.iterator.toSet shouldBe Set("key1" -> "value1",
> "key2"
> > -> "value2")
> > + }
> > +
> > + test("foreach") {
> > + LoggingContext += ("key1" -> "value1")
> > + LoggingContext += ("key2" -> "value2")
> > +
> > + val result = mutable.Set.empty[(String, String)]
> > +
> > + LoggingContext.foreach { result += _ }
> > +
> > + result shouldBe Set("key1" -> "value1", "key2" -> "value2")
> > + }
> > +
> > +}
> >
> > http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> > blob/184045cb/pom.xml
> > ----------------------------------------------------------------------
> > diff --git a/pom.xml b/pom.xml
> > index 1068ecb..c26cc7a 100644
> > --- a/pom.xml
> > +++ b/pom.xml
> > @@ -106,6 +106,7 @@
> > <module>log4j-api-scala_2.10</module>
> > <module>log4j-api-scala_2.11</module>
> > <module>log4j-api-scala_2.12</module>
> > +<!--<module>log4j-api-scala_2.13</module> -->
> > <module>log4j-api-scala-sample</module>
> > </modules>
> >
> >
> >
>
>
> --
> Matt Sicker <bo...@gmail.com>
>
Re: logging-log4j-scala git commit: Add placeholder for Scala 2.13
but do not enable the module.
Posted by Matt Sicker <bo...@gmail.com>.
I've seen on Maven Central before that a few Scala libraries have published
artifacts for 2.13.0 milestones. See for example: <
https://search.maven.org/#artifactdetails%7Corg.scalatest%7Cscalatest_2.13.0-M2%7C3.0.4%7Cbundle>.
It seems like if we published the module by naming it
"log4j-api-scala_2.13.0-M2", we could have a version specific to that
milestone at least.
On 11 November 2017 at 16:26, <gg...@apache.org> wrote:
> Repository: logging-log4j-scala
> Updated Branches:
> refs/heads/master 5a71e5caa -> 184045cbc
>
>
> Add placeholder for Scala 2.13 but do not enable the module.
>
> Project: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/repo
> Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> commit/184045cb
> Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> tree/184045cb
> Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> diff/184045cb
>
> Branch: refs/heads/master
> Commit: 184045cbc7a517faef2a709aa68e83d7a0053599
> Parents: 5a71e5c
> Author: Gary Gregory <gg...@apache.org>
> Authored: Sat Nov 11 15:26:01 2017 -0700
> Committer: Gary Gregory <gg...@apache.org>
> Committed: Sat Nov 11 15:26:01 2017 -0700
>
> ----------------------------------------------------------------------
> log4j-api-scala_2.13/pom.xml | 145 +++++
> .../org/apache/logging/log4j/scala/Logger.scala | 592 +++++++++++++++++++
> .../logging/log4j/scala/LoggerMacro.scala | 425 +++++++++++++
> .../apache/logging/log4j/scala/Logging.scala | 30 +
> .../logging/log4j/scala/LoggingContext.scala | 84 +++
> log4j-api-scala_2.13/src/site/markdown/index.md | 74 +++
> log4j-api-scala_2.13/src/site/site.xml | 30 +
> .../apache/logging/log4j/scala/LoggerTest.scala | 552 +++++++++++++++++
> .../log4j/scala/LoggingContextTest.scala | 115 ++++
> pom.xml | 1 +
> 10 files changed, 2048 insertions(+)
> ----------------------------------------------------------------------
>
>
> http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> blob/184045cb/log4j-api-scala_2.13/pom.xml
> ----------------------------------------------------------------------
> diff --git a/log4j-api-scala_2.13/pom.xml b/log4j-api-scala_2.13/pom.xml
> new file mode 100644
> index 0000000..ea0f19c
> --- /dev/null
> +++ b/log4j-api-scala_2.13/pom.xml
> @@ -0,0 +1,145 @@
> +<?xml version="1.0" encoding="UTF-8"?>
> +<!--
> + Licensed to the Apache Software Foundation (ASF) under one or more
> + contributor license agreements. See the NOTICE file distributed with
> + this work for additional information regarding copyright ownership.
> + The ASF licenses this file to You under the Apache License, Version 2.0
> + (the "License"); you may not use this file except in compliance with
> + the License. You may obtain a copy of the License at
> +
> + http://www.apache.org/licenses/LICENSE-2.0
> +
> + Unless required by applicable law or agreed to in writing, software
> + distributed under the License is distributed on an "AS IS" BASIS,
> + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
> + See the License for the specific language governing permissions and
> + limitations under the License.
> +-->
> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="
> http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://
> maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
> + <modelVersion>4.0.0</modelVersion>
> + <parent>
> + <groupId>org.apache.logging.log4j</groupId>
> + <artifactId>log4j-scala</artifactId>
> + <version>12.0-SNAPSHOT</version>
> + <relativePath>../</relativePath>
> + </parent>
> + <artifactId>log4j-api-scala_2.13</artifactId>
> + <packaging>jar</packaging>
> + <name>Scala 2.13 wrapper for Log4j API</name>
> + <description>Scala wrapper for Log4j API</description>
> + <properties>
> + <log4jParentDir>${basedir}/..</log4jParentDir>
> + <projectDir>/scala_2.13</projectDir>
> + <scala.version>2.13.0-M2</scala.version>
> + <scala.maven.plugin.version>3.3.1</scala.maven.plugin.version>
> + <maven.compiler.source>1.8</maven.compiler.source>
> + <maven.compiler.target>1.8</maven.compiler.target>
> + </properties>
> + <dependencies>
> + <dependency>
> + <groupId>org.apache.logging.log4j</groupId>
> + <artifactId>log4j-api</artifactId>
> + </dependency>
> + <dependency>
> + <groupId>org.scala-lang</groupId>
> + <artifactId>scala-library</artifactId>
> + <version>${scala.version}</version>
> + </dependency>
> + <dependency>
> + <groupId>org.scala-lang</groupId>
> + <artifactId>scala-reflect</artifactId>
> + <version>${scala.version}</version>
> + </dependency>
> + <dependency>
> + <groupId>org.apache.logging.log4j</groupId>
> + <artifactId>log4j-api</artifactId>
> + <type>test-jar</type>
> + <scope>test</scope>
> + </dependency>
> + <dependency>
> + <groupId>junit</groupId>
> + <artifactId>junit</artifactId>
> + <scope>test</scope>
> + </dependency>
> + <dependency>
> + <groupId>org.scalatest</groupId>
> + <artifactId>scalatest_2.13.0-M2</artifactId>
> + <version>3.0.4</version>
> + <scope>test</scope>
> + </dependency>
> + <dependency>
> + <groupId>org.mockito</groupId>
> + <artifactId>mockito-core</artifactId>
> + <version>1.10.19</version>
> + <scope>test</scope>
> + </dependency>
> + </dependencies>
> + <build>
> + <sourceDirectory>src/main/scala</sourceDirectory>
> + <testSourceDirectory>src/test/scala</testSourceDirectory>
> + <plugins>
> + <plugin>
> + <groupId>net.alchim31.maven</groupId>
> + <artifactId>scala-maven-plugin</artifactId>
> + <version>${scala.maven.plugin.version}</version>
> + <executions>
> + <execution>
> + <goals>
> + <goal>compile</goal>
> + <goal>testCompile</goal>
> + <goal>doc-jar</goal>
> + </goals>
> + </execution>
> + </executions>
> + <configuration>
> + <args>
> + <arg>-feature</arg>
> + <arg>-unchecked</arg>
> + <arg>-deprecation</arg>
> + </args>
> + </configuration>
> + </plugin>
> + <plugin>
> + <groupId>org.apache.maven.plugins</groupId>
> + <artifactId>maven-surefire-plugin</artifactId>
> + </plugin>
> + <plugin>
> + <groupId>org.apache.felix</groupId>
> + <artifactId>maven-bundle-plugin</artifactId>
> + </plugin>
> + </plugins>
> + </build>
> + <reporting>
> + <plugins>
> + <plugin>
> + <groupId>org.apache.maven.plugins</groupId>
> + <artifactId>maven-changes-plugin</artifactId>
> + <version>${changes.plugin.version}</version>
> + <reportSets>
> + <reportSet>
> + <reports>
> + <report>changes-report</report>
> + </reports>
> + </reportSet>
> + </reportSets>
> + <configuration>
> + <issueLinkTemplate>%URL%/show_bug.cgi?id=%ISSUE%</
> issueLinkTemplate>
> + <useJql>true</useJql>
> + </configuration>
> + </plugin>
> + <plugin>
> + <groupId>org.apache.maven.plugins</groupId>
> + <artifactId>maven-pmd-plugin</artifactId>
> + <version>${pmd.plugin.version}</version>
> + <configuration>
> + <targetJdk>${maven.compiler.target}</targetJdk>
> + </configuration>
> + </plugin>
> + <plugin>
> + <groupId>net.alchim31.maven</groupId>
> + <artifactId>scala-maven-plugin</artifactId>
> + <version>${scala.maven.plugin.version}</version>
> + </plugin>
> + </plugins>
> + </reporting>
> +</project>
>
> http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> apache/logging/log4j/scala/Logger.scala
> ----------------------------------------------------------------------
> diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
> b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/Logger.scala
> new file mode 100644
> index 0000000..b42cd5a
> --- /dev/null
> +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/Logger.scala
> @@ -0,0 +1,592 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache license, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the license for the specific language governing permissions and
> + * limitations under the license.
> + */
> +package org.apache.logging.log4j.scala
> +
> +import org.apache.logging.log4j.message.{EntryMessage, Message,
> MessageFactory2}
> +import org.apache.logging.log4j.spi.ExtendedLogger
> +import org.apache.logging.log4j.{Level, LogManager, Marker}
> +
> +import scala.language.experimental.macros
> +
> +/**
> + * Factory for [[Logger]]s.
> + *
> + * The [[Logging]] trait provides a simple way to get a properly named
> logger into a class.
> + */
> +object Logger {
> +
> + final val FQCN = getClass.getName
> +
> + /**
> + * Create a properly named [[Logger]] for a given class.
> + *
> + * @param clazz the class
> + */
> + def apply(clazz: Class[_]): Logger = Logger(LogManager.getContext(clazz.getClassLoader,
> false).getLogger(clazz.getName))
> +
> + /**
> + * Create a [[Logger]] wrapping the given Log4j logger.
> + *
> + * @param delegate the Log4j logger to wrap
> + */
> + def apply(delegate: ExtendedLogger): Logger = new Logger(delegate)
> +
> +}
> +
> +/**
> + * Scala wrapper for the Log4j `Logger` interface.
> + *
> + * Frequently the purpose of logging is to provide information about
> what is happening in the system,
> + * which requires including information about the objects being
> manipulated. In Scala, you can use
> + * [[http://docs.scala-lang.org/overviews/core/string-interpolation.html
> string interpolation]]
> + * to achieve this:
> + *
> + * {{{
> + * logger.debug(s"Logging in user ${user.getName} with birthday
> ${user.calcBirthday}")
> + * }}}
> + *
> + * Since this wrapper is implemented with macros, the String
> construction and method invocations
> + * will only occur when debug logging is enabled.
> + */
> +class Logger private(val delegate: ExtendedLogger) extends AnyVal {
> +
> + def fatal(marker: Marker, message: Message): Unit =
> + macro LoggerMacro.fatalMarkerMsg
> +
> + def fatal(marker: Marker, message: CharSequence): Unit =
> + macro LoggerMacro.fatalMarkerCseq
> +
> + 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.fatalMarkerCseqThrowable
> +
> + 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.fatalCseq
> +
> + 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.fatalCseqThrowable
> +
> + 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: CharSequence): Unit =
> + macro LoggerMacro.errorMarkerCseq
> +
> + 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.errorMarkerCseqThrowable
> +
> + 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.errorCseq
> +
> + 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.errorCseqThrowable
> +
> + 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: CharSequence): Unit =
> + macro LoggerMacro.warnMarkerCseq
> +
> + 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.warnMarkerCseqThrowable
> +
> + 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.warnCseq
> +
> + 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.warnCseqThrowable
> +
> + 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: CharSequence): Unit =
> + macro LoggerMacro.infoMarkerCseq
> +
> + 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.infoMarkerCseqThrowable
> +
> + 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.infoCseq
> +
> + 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.infoCseqThrowable
> +
> + 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: CharSequence): Unit =
> + macro LoggerMacro.debugMarkerCseq
> +
> + 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.debugMarkerCseqThrowable
> +
> + 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.debugCseq
> +
> + 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.debugCseqThrowable
> +
> + 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: CharSequence): Unit =
> + macro LoggerMacro.traceMarkerCseq
> +
> + 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.traceMarkerCseqThrowable
> +
> + 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.traceCseq
> +
> + 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.traceCseqThrowable
> +
> + def trace(message: AnyRef, cause: Throwable): Unit =
> + macro LoggerMacro.traceObjectThrowable
> +
> +
> + /**
> + * Logs a `Message` with the specific `Marker` at the given `Level`.
> + *
> + * @param level the logging level
> + * @param marker the marker data specific to this log statement
> + * @param message the message to be logged
> + */
> + def apply(level: Level, marker: Marker, message: Message): Unit =
> + macro LoggerMacro.logMarkerMsg
> +
> + /**
> + * Logs a string with the specific `Marker` at the given `Level`.
> + *
> + * @param level the logging level
> + * @param marker the marker data specific to this log statement
> + * @param message the message to be logged
> + */
> + def apply(level: Level, marker: Marker, message: CharSequence): Unit =
> + macro LoggerMacro.logMarkerCseq
> +
> + /**
> + * Logs an object with the specific `Marker` at the given `Level`.
> + *
> + * @param level the logging level
> + * @param marker the marker data specific to this log statement
> + * @param message the message to be logged
> + */
> + def apply(level: Level, marker: Marker, message: AnyRef): Unit =
> + macro LoggerMacro.logMarkerObject
> +
> + /**
> + * Logs a `Message` with the specific `Marker` at the given `Level`
> including the stack trace
> + * of the given `Throwable`.
> + *
> + * @param level the logging level
> + * @param marker the marker data specific to this log statement
> + * @param message the message to be logged
> + * @param cause the cause
> + */
> + def apply(level: Level, marker: Marker, message: Message, cause:
> Throwable): Unit =
> + macro LoggerMacro.logMarkerMsgThrowable
> +
> + /**
> + * Logs a string with the specific `Marker` at the given `Level`
> including the stack trace
> + * of the given `Throwable`.
> + *
> + * @param level the logging level
> + * @param marker the marker data specific to this log statement
> + * @param message the message to be logged
> + * @param cause the cause
> + */
> + def apply(level: Level, marker: Marker, message: CharSequence, cause:
> Throwable): Unit =
> + macro LoggerMacro.logMarkerCseqThrowable
> +
> + /**
> + * Logs an object with the specific `Marker` at the given `Level`
> including the stack trace
> + * of the given `Throwable`.
> + *
> + * @param level the logging level
> + * @param marker the marker data specific to this log statement
> + * @param message the message to be logged
> + * @param cause the cause
> + */
> + def apply(level: Level, marker: Marker, message: AnyRef, cause:
> Throwable): Unit =
> + macro LoggerMacro.logMarkerObjectThrowable
> +
> + /**
> + * Logs a `Message` at the given `Level`.
> + *
> + * @param level the logging level
> + * @param message the message to be logged
> + */
> + def apply(level: Level, message: Message): Unit =
> + macro LoggerMacro.logMsg
> +
> + /**
> + * Logs a string at the given `Level`.
> + *
> + * @param level the logging level
> + * @param message the message to be logged
> + */
> + def apply(level: Level, message: CharSequence): Unit =
> + macro LoggerMacro.logCseq
> +
> + /**
> + * Logs an object at the given `Level`.
> + *
> + * @param level the logging level
> + * @param message the message to be logged
> + */
> + def apply(level: Level, message: AnyRef): Unit =
> + macro LoggerMacro.logObject
> +
> + /**
> + * Logs a `Message` at the given `Level` including the stack trace of
> the given `Throwable`.
> + *
> + * @param level the logging level
> + * @param message the message to be logged
> + * @param cause a `Throwable`
> + */
> + def apply(level: Level, message: Message, cause: Throwable): Unit =
> + macro LoggerMacro.logMsgThrowable
> +
> + /**
> + * Logs a string at the given `Level` including the stack trace of the
> given `Throwable`.
> + *
> + * @param level the logging level
> + * @param message the message to be logged
> + * @param cause a `Throwable`
> + */
> + def apply(level: Level, message: CharSequence, cause: Throwable): Unit =
> + macro LoggerMacro.logCseqThrowable
> +
> + /**
> + * Logs an object at the given `Level` including the stack trace of
> the given `Throwable`.
> + *
> + * @param level the logging level
> + * @param message the message to be logged
> + * @param cause a `Throwable`
> + */
> + def apply(level: Level, message: AnyRef, cause: Throwable): Unit =
> + macro LoggerMacro.logObjectThrowable
> +
> +
> + /**
> + * Logs entry to a method. Used when the method in question has no
> parameters or when the parameters should not be
> + * logged.
> + *
> + * @return The built `EntryMessage`
> + */
> + def traceEntry(): EntryMessage =
> + macro LoggerMacro.traceEntry
> +
> + /**
> + * Logs entry to a method along with its parameters.
> + *
> + * {{{
> + * def doSomething(foo: String, bar: Int): Unit = {
> + * logger.traceEntry(foo, bar)
> + * // do something
> + * }
> + * }}}
> + *
> + * @param params the parameters to the method.
> + * @return The built `EntryMessage`
> + */
> + def traceEntry(params: AnyRef*): EntryMessage =
> + macro LoggerMacro.traceEntryParams
> +
> + /**
> + * Logs entry to a method using a `Message` to describe the parameters.
> + *
> + * {{{
> + * def doSomething(foo: Request): Unit = {
> + * logger.traceEntry(JsonMessage(foo))
> + * // do something
> + * }
> + * }}}
> + *
> + * @param message the message
> + * @return The built `EntryMessage`
> + */
> + def traceEntry(message: Message): EntryMessage =
> + macro LoggerMacro.traceEntryMessage
> +
> + /**
> + * Logs exit from a method with no result.
> + */
> + def traceExit(): Unit =
> + macro LoggerMacro.traceExit
> +
> + /**
> + * Logs exiting from a method with result.
> + *
> + * @param result The result being returned from the method call
> + * @return `result`
> + */
> + def traceExit[R](result: R): R =
> + macro LoggerMacro.traceExitResult[R]
> +
> + /**
> + * Logs exiting from a method with no result.
> + *
> + * @param entryMessage the `EntryMessage` returned from one of the
> `traceEntry` methods
> + */
> + def traceExit(entryMessage: EntryMessage): Unit =
> + macro LoggerMacro.traceExitEntryMessage
> +
> + /**
> + * Logs exiting from a method with result.
> + *
> + * {{{
> + * def doSomething(foo: String, bar: Int): Int = {
> + * val entryMessage = logger.traceEntry(foo, bar)
> + * // do something
> + * traceExit(entryMessage, value)
> + * }
> + * }}}
> + *
> + * @param entryMessage the `EntryMessage` returned from one of the
> `traceEntry` methods
> + * @param result The result being returned from the method call
> + * @return `result`
> + */
> + def traceExit[R](entryMessage: EntryMessage, result: R): R =
> + macro LoggerMacro.traceExitEntryMessageResult[R]
> +
> + /**
> + * Logs exiting from a method with result. Allows custom formatting of
> the result.
> + *
> + * @param message the Message containing the formatted result
> + * @param result The result being returned from the method call.
> + * @return `result`
> + */
> + def traceExit[R](message: Message, result: R): R =
> + macro LoggerMacro.traceExitMessageResult[R]
> +
> + /**
> + * Logs an exception or error to be thrown.
> + *
> + * {{{
> + * throw logger.throwing(myException)
> + * }}}
> + *
> + * @param t the Throwable
> + * @return `t`
> + */
> + def throwing[T <: Throwable](t: T): T =
> + macro LoggerMacro.throwing[T]
> +
> + /**
> + * Logs an exception or error to be thrown to a specific logging level.
> + *
> + * {{{
> + * throw logger.throwing(Level.DEBUG, myException)
> + * }}}
> + *
> + * @param level the logging Level.
> + * @param t the Throwable
> + * @return `t`
> + */
> + def throwing[T <: Throwable](level: Level, t: T): T =
> + macro LoggerMacro.throwingLevel[T]
> +
> + /**
> + * Logs an exception or error that has been caught.
> + *
> + * @param t the Throwable.
> + */
> + def catching(t: Throwable): Unit =
> + macro LoggerMacro.catching
> +
> + /**
> + * Logs an exception or error that has been caught to a specific
> logging level.
> + *
> + * @param level The logging Level.
> + * @param t The Throwable.
> + */
> + def catching(level: Level, t: Throwable): Unit =
> + macro LoggerMacro.catchingLevel
> +
> +
> + /** 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: Message, cause:
> Throwable): Unit = {
> + delegate.logMessage(Logger.FQCN, level, marker, 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: CharSequence,
> cause: Throwable): Unit = {
> + delegate.logMessage(Logger.FQCN, level, marker,
> delegate.getMessageFactory.asInstanceOf[MessageFactory2].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(Logger.FQCN, level, marker,
> delegate.getMessageFactory.asInstanceOf[MessageFactory2].newMessage(message),
> cause)
> + }
> +
> +}
>
> http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> apache/logging/log4j/scala/LoggerMacro.scala
> ----------------------------------------------------------------------
> diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
> b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/LoggerMacro.scala
> new file mode 100644
> index 0000000..3b54db1
> --- /dev/null
> +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/LoggerMacro.scala
> @@ -0,0 +1,425 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache license, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the license for the specific language governing permissions and
> + * limitations under the license.
> + */
> +package org.apache.logging.log4j.scala
> +
> +import org.apache.logging.log4j.message.{EntryMessage, Message}
> +import org.apache.logging.log4j.spi.AbstractLogger
> +import org.apache.logging.log4j.{Level, Marker}
> +
> +import scala.language.experimental.macros
> +import scala.reflect.macros.blackbox
> +
> +/**
> + * Inspired from [[https://github.com/typesafehub/scalalogging
> ScalaLogging]].
> + */
> +private object LoggerMacro {
> +
> + 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.FATAL), marker, message)
> +
> + def fatalMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> c.Expr[CharSequence]) =
> + logMarkerCseq(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 fatalMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> + logMarkerCseqThrowable(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 fatalCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> + logCseq(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 fatalCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence],
> cause: c.Expr[Throwable]) =
> + logCseqThrowable(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 errorMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> c.Expr[CharSequence]) =
> + logMarkerCseq(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 errorMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> + logMarkerCseqThrowable(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 errorCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> + logCseq(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 errorCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence],
> cause: c.Expr[Throwable]) =
> + logCseqThrowable(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 warnMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> c.Expr[CharSequence]) =
> + logMarkerCseq(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 warnMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> + logMarkerCseqThrowable(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 warnCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> + logCseq(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 warnCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence],
> cause: c.Expr[Throwable]) =
> + logCseqThrowable(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 infoMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> c.Expr[CharSequence]) =
> + logMarkerCseq(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 infoMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> + logMarkerCseqThrowable(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 infoCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> + logCseq(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 infoCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence],
> cause: c.Expr[Throwable]) =
> + logCseqThrowable(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 debugMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> c.Expr[CharSequence]) =
> + logMarkerCseq(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 debugMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> + logMarkerCseqThrowable(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 debugCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> + logCseq(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 debugCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence],
> cause: c.Expr[Throwable]) =
> + logCseqThrowable(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 traceMarkerCseq(c: LoggerContext)(marker: c.Expr[Marker], message:
> c.Expr[CharSequence]) =
> + logMarkerCseq(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 traceMarkerCseqThrowable(c: LoggerContext)(marker: c.Expr[Marker],
> message: c.Expr[CharSequence], cause: c.Expr[Throwable]) =
> + logMarkerCseqThrowable(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 traceCseq(c: LoggerContext)(message: c.Expr[CharSequence]) =
> + logCseq(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 traceCseqThrowable(c: LoggerContext)(message: c.Expr[CharSequence],
> cause: c.Expr[Throwable]) =
> + logCseqThrowable(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)) {
> + c.prefix.splice.logMessage(level.splice, marker.splice,
> message.splice, null)
> + }
> + )
> +
> + def logMarkerCseq(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, null)
> + }
> + )
> +
> + 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 logMarkerCseqThrowable(c: LoggerContext)(level: c.Expr[Level],
> marker: c.Expr[Marker], message: c.Expr[CharSequence], 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 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)) {
> + c.prefix.splice.logMessage(level.splice, null, message.splice,
> null)
> + }
> + )
> +
> + def logCseq(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,
> null)
> + }
> + )
> +
> + 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 logCseqThrowable(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)) {
> + c.prefix.splice.logMessage(level.splice, null, message.splice,
> cause.splice)
> + }
> + )
> +
> + 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)
> + }
> + )
> +
> +
> + def traceEntry(c: LoggerContext)(): c.Expr[EntryMessage] =
> + c.universe.reify(
> + c.prefix.splice.delegate.traceEntry()
> + )
> +
> + def traceEntryParams(c: LoggerContext)(params: c.Expr[AnyRef]*):
> c.Expr[EntryMessage] = {
> + import c.universe._
> + val isEnabled = Apply(
> + Select(Select(c.prefix.tree, TermName("delegate")),
> TermName("isEnabled")),
> + List(
> + reify(Level.TRACE).tree,
> + reify(AbstractLogger.ENTRY_MARKER).tree,
> + reify(null: AnyRef).tree,
> + reify(null).tree
> + )
> + )
> +
> + val log = Apply(
> + Select(Select(c.prefix.tree, TermName("delegate")),
> TermName("traceEntry")),
> + reify(null: String).tree :: (params map (_.tree)).toList
> + )
> + c.Expr[EntryMessage](If(isEnabled, log, reify(null).tree))
> + }
> +
> +
> + def traceEntryMessage(c: LoggerContext)(message: c.Expr[Message]):
> c.Expr[EntryMessage] =
> + c.universe.reify(
> + if (c.prefix.splice.delegate.isEnabled(Level.TRACE,
> AbstractLogger.ENTRY_MARKER, null: AnyRef, null)) {
> + c.prefix.splice.delegate.traceEntry(message.splice) // TODO
> should not do ifEnabled check
> + } else {
> + null
> + }
> + )
> +
> + def traceExit(c: LoggerContext)(): c.Expr[Unit] =
> + c.universe.reify(
> + c.prefix.splice.delegate.traceExit()
> + )
> +
> + def traceExitResult[R: c.WeakTypeTag](c: LoggerContext)(result:
> c.Expr[R]): c.Expr[R] =
> + c.universe.reify(
> + c.prefix.splice.delegate.traceExit(result.splice)
> + )
> +
> + def traceExitEntryMessage(c: LoggerContext)(entryMessage:
> c.Expr[EntryMessage]): c.Expr[Unit] =
> + c.universe.reify(
> + c.prefix.splice.delegate.traceExit(entryMessage.splice)
> + )
> +
> + def traceExitEntryMessageResult[R: c.WeakTypeTag](c:
> LoggerContext)(entryMessage: c.Expr[EntryMessage], result: c.Expr[R]):
> c.Expr[R] =
> + c.universe.reify(
> + c.prefix.splice.delegate.traceExit(entryMessage.splice,
> result.splice)
> + )
> +
> + def traceExitMessageResult[R: c.WeakTypeTag](c: LoggerContext)(message:
> c.Expr[Message], result: c.Expr[R]): c.Expr[R] =
> + c.universe.reify(
> + {
> + if (message.splice != null && c.prefix.splice.delegate.isEnabled(Level.TRACE,
> AbstractLogger.EXIT_MARKER, message.splice, null)) {
> + c.prefix.splice.delegate.traceExit(message.splice,
> result.splice) // TODO should not do ifEnabled check
> + }
> + result.splice
> + }
> + )
> +
> + def throwing[T <: Throwable: c.WeakTypeTag](c: LoggerContext)(t:
> c.Expr[T]): c.Expr[T] =
> + c.universe.reify(
> + c.prefix.splice.delegate.throwing(t.splice)
> + )
> +
> + def throwingLevel[T <: Throwable: c.WeakTypeTag](c:
> LoggerContext)(level: c.Expr[Level], t: c.Expr[T]): c.Expr[T] =
> + c.universe.reify(
> + c.prefix.splice.delegate.throwing(level.splice, t.splice)
> + )
> +
> + def catching(c: LoggerContext)(t: c.Expr[Throwable]): c.Expr[Unit] =
> + c.universe.reify(
> + c.prefix.splice.delegate.catching(t.splice)
> + )
> +
> + def catchingLevel(c: LoggerContext)(level: c.Expr[Level], t:
> c.Expr[Throwable]): c.Expr[Unit] =
> + c.universe.reify(
> + c.prefix.splice.delegate.catching(level.splice, t.splice)
> + )
> +
> +}
>
> http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> apache/logging/log4j/scala/Logging.scala
> ----------------------------------------------------------------------
> diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
> b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/Logging.scala
> new file mode 100644
> index 0000000..b017de7
> --- /dev/null
> +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/Logging.scala
> @@ -0,0 +1,30 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache license, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the license for the specific language governing permissions and
> + * limitations under the license.
> + */
> +package org.apache.logging.log4j.scala
> +
> +/**
> + * Mix in this trait into classes from which you want to log,
> + * give you a `logger` value with a [[Logger]] named according to the
> class.
> + */
> +trait Logging {
> +
> + /**
> + * A [[Logger]] named according to the class.
> + */
> + protected val logger: Logger = Logger(getClass)
> +
> +}
> \ No newline at end of file
>
> http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> blob/184045cb/log4j-api-scala_2.13/src/main/scala/org/
> apache/logging/log4j/scala/LoggingContext.scala
> ----------------------------------------------------------------------
> diff --git a/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/LoggingContext.scala b/log4j-api-scala_2.13/src/
> main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
> new file mode 100644
> index 0000000..79efecc
> --- /dev/null
> +++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/
> log4j/scala/LoggingContext.scala
> @@ -0,0 +1,84 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache license, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the license for the specific language governing permissions and
> + * limitations under the license.
> + */
> +package org.apache.logging.log4j.scala
> +
> +import org.apache.logging.log4j.ThreadContext
> +
> +import scala.collection.JavaConverters._
> +import scala.collection.{immutable, mutable}
> +
> +/** Manages the context data (context map, MDC) that is added to log
> events.
> + *
> + * A wrapper around `org.apache.logging.log4j.ThreadContext`.
> + */
> +object LoggingContext extends mutable.Map[String, String] {
> +
> + override def +=(kv: (String, String)): LoggingContext.this.type = {
> + ThreadContext.put(kv._1, kv._2)
> + this
> + }
> +
> + override def +=(elem1: (String, String), elem2: (String, String),
> elems: (String, String)*): LoggingContext.this.type = {
> + val builder = immutable.Map.newBuilder[String,String]
> + builder += elem1
> + builder += elem2
> + builder ++= elems
> + ThreadContext.putAll(builder.result.asJava)
> + this
> + }
> +
> + override def ++=(xs: TraversableOnce[(String, String)]):
> LoggingContext.this.type = {
> + ThreadContext.putAll(xs.toMap.asJava)
> + this
> + }
> +
> + override def -=(key: String): LoggingContext.this.type = {
> + ThreadContext.remove(key)
> + this
> + }
> +
> + override def -=(elem1: String, elem2: String, elems: String*):
> LoggingContext.this.type = {
> + val builder = immutable.Seq.newBuilder[String]
> + builder += elem1
> + builder += elem2
> + builder ++= elems
> + ThreadContext.removeAll(builder.result.asJava)
> + this
> + }
> +
> + override def --=(xs: TraversableOnce[String]): LoggingContext.this.type
> = {
> + ThreadContext.removeAll(xs.toSeq.asJava)
> + this
> + }
> +
> + override def clear(): Unit = {
> + ThreadContext.clearMap()
> + }
> +
> + override def contains(key: String): Boolean =
> ThreadContext.containsKey(key)
> +
> + override def get(key: String): Option[String] =
> Option(ThreadContext.get(key))
> +
> + override def iterator: Iterator[(String, String)] = ThreadContext.
> getImmutableContext.asScala.iterator
> +
> + override def foreach[U](f: ((String, String)) => U): Unit =
> ThreadContext.getImmutableContext.asScala.foreach(f)
> +
> + override def size: Int = ThreadContext.getImmutableContext.size()
> +
> + override def isEmpty: Boolean = ThreadContext.isEmpty
> +
> +}
>
> http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> blob/184045cb/log4j-api-scala_2.13/src/site/markdown/index.md
> ----------------------------------------------------------------------
> diff --git a/log4j-api-scala_2.13/src/site/markdown/index.md
> b/log4j-api-scala_2.13/src/site/markdown/index.md
> new file mode 100644
> index 0000000..7acf397
> --- /dev/null
> +++ b/log4j-api-scala_2.13/src/site/markdown/index.md
> @@ -0,0 +1,74 @@
> +<!--
> + Licensed to the Apache Software Foundation (ASF) under one or more
> + contributor license agreements. See the NOTICE file distributed with
> + this work for additional information regarding copyright ownership.
> + The ASF licenses this file to You under the Apache License, Version
> 2.0
> + (the "License"); you may not use this file except in compliance with
> + the License. You may obtain a copy of the License at
> +
> + http://www.apache.org/licenses/LICENSE-2.0
> +
> + Unless required by applicable law or agreed to in writing, software
> + distributed under the License is distributed on an "AS IS" BASIS,
> + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + See the License for the specific language governing permissions and
> + limitations under the License.
> +-->
> +# Log4j Scala 2.12 API
> +
> +## Requirements
> +
> +Log4j Scala API for Scala 2.12 requires Log4j API, Java 8, the Scala
> runtime
> +library, and the Scala reflection library. To use Log4j as a logging
> implementation,
> +then Log4j Core must also be included. Instructions on using these
> dependencies are
> +in the [dependency information page][dependencies], and additional
> information is
> +included in the [Log4j artifacts][artifacts] page.
> +
> +## Example Usage
> +
> +<pre class="prettyprint linenums">
> +import org.apache.logging.log4j.scala.Logging
> +import org.apache.logging.log4j.Level
> +
> +class MyClass extends BaseClass with Logging {
> + def doStuff(): Unit = {
> + logger.info("Doing stuff")
> + }
> + def doStuffWithLevel(level: Level): Unit = {
> + logger(level, "Doing stuff with arbitrary level")
> + }
> +}
> +</pre>
> +
> +## Configuration
> +
> +Log4j Scala 2.12 API uses the standard [Log4j
> configuration][configuration]
> +plugins. This supports XML, properties files, and a configuration builder
> DSL by
> +default, and it optionally supports JSON and YAML formats with some
> additional
> +Jackson dependencies.
> +
> +## Substituting Parameters
> +
> +In the Java API, parameters to a log message are interpolated using
> various
> +strategies. In the Scala API, [string interpolation][interpolation] is
> used
> +instead. As all logger methods are implemented as macros, string
> construction and
> +method invocations will only occur when logging is enabled for the given
> log
> +level. For example:
> +
> +<pre class="prettyprint linenums">
> +logger.debug(s"Logging in user ${user.getName} with birthday
> ${user.calcBirthday}")
> +</pre>
> +
> +## Logger Names
> +
> +Most logging implementations use a hierarchical scheme for matching
> logger names
> +with logging configuration. In this scheme the logger name hierarchy is
> +represented by '.' characters in the logger name, in a fashion very
> similar to
> +the hierarchy used for Java/Scala package names. The [`Logging`
> trait][logging]
> +will automatically name the Logger accordingly to the class it is being
> used in.
> +
> +[dependencies]: dependency-info.html
> +[artifacts]: ../maven-artifacts.html
> +[configuration]: ../configuration.html
> +[interpolation]: http://docs.scala-lang.org/overviews/core/string-
> interpolation.html
> +[logging]: scaladocs/org/apache/logging/log4j/scala/Logging.html
> \ No newline at end of file
>
> http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> blob/184045cb/log4j-api-scala_2.13/src/site/site.xml
> ----------------------------------------------------------------------
> diff --git a/log4j-api-scala_2.13/src/site/site.xml
> b/log4j-api-scala_2.13/src/site/site.xml
> new file mode 100644
> index 0000000..f46fa51
> --- /dev/null
> +++ b/log4j-api-scala_2.13/src/site/site.xml
> @@ -0,0 +1,30 @@
> +<?xml version="1.0" encoding="utf-8"?>
> +<!--
> + ~ Licensed to the Apache Software Foundation (ASF) under one or more
> + ~ contributor license agreements. See the NOTICE file distributed with
> + ~ this work for additional information regarding copyright ownership.
> + ~ The ASF licenses this file to You under the Apache license, Version
> 2.0
> + ~ (the "License"); you may not use this file except in compliance with
> + ~ the License. You may obtain a copy of the License at
> + ~
> + ~ http://www.apache.org/licenses/LICENSE-2.0
> + ~
> + ~ Unless required by applicable law or agreed to in writing, software
> + ~ distributed under the License is distributed on an "AS IS" BASIS,
> + ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + ~ See the license for the specific language governing permissions and
> + ~ limitations under the license.
> + -->
> +<project name="Log4j Scala API"
> + xmlns="http://maven.apache.org/DECORATION/1.7.0"
> + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
> + xsi:schemaLocation="http://maven.apache.org/DECORATION/1.7.0
> http://maven.apache.org/xsd/decoration-1.7.0.xsd">
> + <body>
> + <links>
> + <item name="Apache" href="http://www.apache.org/"/>
> + <item name="Logging Services" href="http://logging.apache.
> org/"/>
> + <item name="Log4j" href="../index.html"/>
> + </links>
> + <menu ref="reports"/>
> + </body>
> +</project>
> \ No newline at end of file
>
> http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> blob/184045cb/log4j-api-scala_2.13/src/test/scala/org/
> apache/logging/log4j/scala/LoggerTest.scala
> ----------------------------------------------------------------------
> diff --git a/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
> b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> log4j/scala/LoggerTest.scala
> new file mode 100644
> index 0000000..bd12742
> --- /dev/null
> +++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> log4j/scala/LoggerTest.scala
> @@ -0,0 +1,552 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache license, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the license for the specific language governing permissions and
> + * limitations under the license.
> + */
> +package org.apache.logging.log4j.scala
> +
> +import org.apache.logging.log4j.message.{DefaultFlowMessageFactory,
> Message, ParameterizedMessage, ParameterizedMessageFactory}
> +import org.apache.logging.log4j.spi.{AbstractLogger, ExtendedLogger}
> +import org.apache.logging.log4j.{Level, Marker, MarkerManager}
> +import org.junit.runner.RunWith
> +import org.mockito.Matchers.{any, anyString, eq => eqv}
> +import org.mockito.Mockito._
> +import org.scalatest.junit.JUnitRunner
> +import org.scalatest.mockito.MockitoSugar
> +import org.scalatest.{FunSuite, Matchers}
> +
> +import scala.language.reflectiveCalls // needed for Mockito mocking
> +
> +case class Custom(i: Int)
> +
> +trait Manager {
> + def fetchValue(): Int
> +}
> +
> +@RunWith(classOf[JUnitRunner])
> +class LoggerTest extends FunSuite with Matchers with MockitoSugar {
> +
> + val msg = new ParameterizedMessage("msg {}", 17)
> + val entryMsg = new DefaultFlowMessageFactory().newEntryMessage(msg)
> + val cseqMsg: CharSequence = new StringBuilder().append("cseq msg")
> + val objectMsg = Custom(17)
> + val cause = new RuntimeException("cause")
> + val marker = MarkerManager.getMarker("marker")
> + val result = "foo"
> +
> + def fixture =
> + new {
> + val mockLogger = {
> + val mockLogger = mock[ExtendedLogger]
> + when(mockLogger.getMessageFactory).thenReturn(new
> ParameterizedMessageFactory)
> + mockLogger
> + }
> + val manager = {
> + val mockManager = mock[Manager]
> + when(mockManager.fetchValue()).thenReturn(4711)
> + mockManager
> + }
> + }
> +
> + test("fatal enabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.FATAL),
> eqv(null), any[Message], eqv(null))
> + verify(f.manager).fetchValue()
> + }
> +
> + test("fatal disabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + verify(f.manager, never).fetchValue()
> + }
> +
> + test("error enabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.error(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.ERROR),
> eqv(null), any[Message], eqv(null))
> + verify(f.manager).fetchValue()
> + }
> +
> + test("error disabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger.error(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + verify(f.manager, never).fetchValue()
> + }
> +
> + test("warn enabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.WARN),
> eqv(null), any[Message], eqv(null))
> + verify(f.manager).fetchValue()
> + }
> +
> + test("warn disabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + verify(f.manager, never).fetchValue()
> + }
> +
> + test("info enabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.info(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(null), any[Message], eqv(null))
> + verify(f.manager).fetchValue()
> + }
> +
> + test("info disabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger.info(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + verify(f.manager, never).fetchValue()
> + }
> +
> + test("debug enabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.DEBUG),
> eqv(null), any[Message], eqv(null))
> + verify(f.manager).fetchValue()
> + }
> +
> + test("debug disabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + verify(f.manager, never).fetchValue()
> + }
> +
> + test("trace enabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.TRACE),
> eqv(null), any[Message], eqv(null))
> + verify(f.manager).fetchValue()
> + }
> +
> + test("trace disabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + verify(f.manager, never).fetchValue()
> + }
> +
> +
> + test("log enabled with Message message and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, msg)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(marker), eqv(msg), eqv(null))
> + }
> +
> + test("log disabled with Message message and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, msg)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with String message and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, s"string msg with value:
> ${f.manager.fetchValue()}")
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(marker), any[Message], eqv(null))
> + verify(f.manager).fetchValue()
> + }
> +
> + test("log disabled with String message and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, s"string msg with value:
> ${f.manager.fetchValue()}")
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + verify(f.manager, never).fetchValue()
> + }
> +
> + test("log enabled with CharSequence message and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, cseqMsg)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(marker), any[Message], eqv(null))
> + }
> +
> + test("log disabled with CharSequence message and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, cseqMsg)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with Object message and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, objectMsg)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(marker), any[Message], eqv(null))
> + }
> +
> + test("log disabled with Object message and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, objectMsg)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with Message message and cause and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, msg, cause)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(marker), eqv(msg), eqv(cause))
> + }
> +
> + test("log disabled with Message message and cause and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, msg, cause)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with String message and cause and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, s"string msg with value:
> ${f.manager.fetchValue()}", cause)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(marker), any[Message], eqv(cause))
> + verify(f.manager).fetchValue()
> + }
> +
> + test("log disabled with String message and cause and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, s"string msg with value:
> ${f.manager.fetchValue()}", cause)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + verify(f.manager, never).fetchValue()
> + }
> +
> + test("log enabled with CharSequence message and cause and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, cseqMsg, cause)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(marker), any[Message], eqv(cause))
> + }
> +
> + test("log disabled with CharSequence message and cause and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, cseqMsg, cause)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with Object message and cause and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, objectMsg, cause)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(marker), any[Message], eqv(cause))
> + }
> +
> + test("log disabled with Object message and cause and Marker") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, marker, objectMsg, cause)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with Message message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, msg)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(null), eqv(msg), eqv(null))
> + }
> +
> + test("log disabled with Message message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, msg)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, s"string msg with value:
> ${f.manager.fetchValue()}")
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(null), any[Message], eqv(null))
> + verify(f.manager).fetchValue()
> + }
> +
> + test("log disabled with String message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, s"string msg with value:
> ${f.manager.fetchValue()}")
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + verify(f.manager, never).fetchValue()
> + }
> +
> + test("log enabled with CharSequence message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, cseqMsg)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(null), any[Message], eqv(null))
> + }
> +
> + test("log disabled with CharSequence message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, cseqMsg)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with Object message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, objectMsg)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(null), any[Message], eqv(null))
> + }
> +
> + test("log disabled with Object message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, objectMsg)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with Message message and cause") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, msg, cause)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(null), eqv(msg), eqv(cause))
> + }
> +
> + test("log disabled with Message message and cause") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, msg, cause)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with String message and cause") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, s"string msg with value:
> ${f.manager.fetchValue()}", cause)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(null), any[Message], eqv(cause))
> + verify(f.manager).fetchValue()
> + }
> +
> + test("log disabled with String message and cause") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, s"string msg with value:
> ${f.manager.fetchValue()}", cause)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + verify(f.manager, never).fetchValue()
> + }
> +
> + test("log enabled with CharSequence message and cause") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, cseqMsg, cause)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(null), any[Message], eqv(cause))
> + }
> +
> + test("log disabled with CharSequence message and cause") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, cseqMsg, cause)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> + test("log enabled with Object message and cause") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, objectMsg, cause)
> + verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO),
> eqv(null), any[Message], eqv(cause))
> + }
> +
> + test("log disabled with Object message and cause") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger(Level.INFO, objectMsg, cause)
> + verify(f.mockLogger, never).logMessage(anyString(), any[Level],
> any[Marker], any[Message], any[Throwable])
> + }
> +
> +
> + test("traceEntry") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> null)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.traceEntry()
> + verify(f.mockLogger).traceEntry()
> + }
> +
> + test("traceEntry enabled with params") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> null)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.traceEntry("foo", "bar")
> + verify(f.mockLogger).traceEntry(null: String, "foo", "bar")
> + }
> +
> + test("traceEntry disabled with params") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> null)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger.traceEntry("foo", "bar")
> + verify(f.mockLogger, never).traceEntry(anyString(), anyString(),
> anyString())
> + }
> +
> + test("traceEntry enabled with message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> null)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.traceEntry(msg)
> + verify(f.mockLogger).traceEntry(eqv(msg))
> + }
> +
> + test("traceEntry disabled with message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE,
> AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef],
> null)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger.traceEntry(msg)
> + verify(f.mockLogger, never).traceEntry(any[Message])
> + }
> +
> + test("traceExit") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER,
> msg, null)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.traceExit()
> + verify(f.mockLogger).traceExit()
> + }
> +
> + test("traceExit with result") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER,
> msg, null)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.traceExit(result)
> + verify(f.mockLogger).traceExit(result)
> + }
> +
> + test("traceExit with entrymessage") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER,
> msg, null)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.traceExit(entryMsg)
> + verify(f.mockLogger).traceExit(entryMsg)
> + }
> +
> + test("traceExit with entrymessage and result") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER,
> msg, null)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.traceExit(entryMsg, result)
> + verify(f.mockLogger).traceExit(entryMsg, result)
> + }
> +
> + test("traceExit enabled with message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER,
> msg, null)).thenReturn(true)
> + val logger = Logger(f.mockLogger)
> + logger.traceExit(msg, result)
> + verify(f.mockLogger).traceExit(eqv(msg), eqv(result))
> + }
> +
> + test("traceExit disabled with message") {
> + val f = fixture
> + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER,
> msg, null)).thenReturn(false)
> + val logger = Logger(f.mockLogger)
> + logger.traceExit(msg, result)
> + verify(f.mockLogger, never).traceExit(any[Message], any[AnyRef])
> + }
> +
> + test("throwing") {
> + val f = fixture
> + val logger = Logger(f.mockLogger)
> + logger.throwing(cause)
> + verify(f.mockLogger).throwing(eqv(cause))
> + }
> +
> + test("throwing with level") {
> + val f = fixture
> + val logger = Logger(f.mockLogger)
> + logger.throwing(Level.INFO, cause)
> + verify(f.mockLogger).throwing(eqv(Level.INFO), eqv(cause))
> + }
> +
> + test("catching") {
> + val f = fixture
> + val logger = Logger(f.mockLogger)
> + logger.catching(cause)
> + verify(f.mockLogger).catching(eqv(cause))
> + }
> +
> + test("catching with level") {
> + val f = fixture
> + val logger = Logger(f.mockLogger)
> + logger.catching(Level.INFO, cause)
> + verify(f.mockLogger).catching(eqv(Level.INFO), eqv(cause))
> + }
> +
> +}
>
> http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> blob/184045cb/log4j-api-scala_2.13/src/test/scala/org/
> apache/logging/log4j/scala/LoggingContextTest.scala
> ----------------------------------------------------------------------
> diff --git a/log4j-api-scala_2.13/src/test/scala/org/apache/logging/
> log4j/scala/LoggingContextTest.scala b/log4j-api-scala_2.13/src/
> test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
> new file mode 100644
> index 0000000..80ca940
> --- /dev/null
> +++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/
> LoggingContextTest.scala
> @@ -0,0 +1,115 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache license, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the license for the specific language governing permissions and
> + * limitations under the license.
> + */
> +package org.apache.logging.log4j.scala
> +
> +import org.junit.runner.RunWith
> +import org.scalatest.junit.JUnitRunner
> +import org.scalatest.{FunSuite, Matchers}
> +
> +import scala.collection.mutable
> +
> +@RunWith(classOf[JUnitRunner])
> +class LoggingContextTest extends FunSuite with Matchers {
> +
> + test("put single, contains, get") {
> + LoggingContext += "key" -> "value"
> +
> + LoggingContext.contains("key") shouldBe true
> + LoggingContext.get("key") shouldBe Some("value")
> + LoggingContext.contains("bogus") shouldBe false
> + LoggingContext.get("bogus") shouldBe None
> + }
> +
> + test("put multiple 1") {
> + LoggingContext += ("key1" -> "value1", "key2" -> "value2")
> +
> + LoggingContext.get("key1") shouldBe Some("value1")
> + LoggingContext.get("key2") shouldBe Some("value2")
> + }
> +
> + test("put multiple 2") {
> + LoggingContext ++= Seq("key1" -> "value1", "key2" -> "value2")
> +
> + LoggingContext.get("key1") shouldBe Some("value1")
> + LoggingContext.get("key2") shouldBe Some("value2")
> + }
> +
> + test("remove single") {
> + LoggingContext += ("key1" -> "value1")
> + LoggingContext += ("key2" -> "value2")
> + LoggingContext += ("key3" -> "value3")
> +
> + LoggingContext -= "key1"
> +
> + LoggingContext.get("key1") shouldBe None
> + LoggingContext.get("key2") shouldBe Some("value2")
> + LoggingContext.get("key3") shouldBe Some("value3")
> + }
> +
> + test("remove multiple 1") {
> + LoggingContext += ("key1" -> "value1")
> + LoggingContext += ("key2" -> "value2")
> + LoggingContext += ("key3" -> "value3")
> +
> + LoggingContext -= ("key1", "key2")
> +
> + LoggingContext.get("key1") shouldBe None
> + LoggingContext.get("key2") shouldBe None
> + LoggingContext.get("key3") shouldBe Some("value3")
> + }
> +
> + test("remove multiple 2") {
> + LoggingContext += ("key1" -> "value1")
> + LoggingContext += ("key2" -> "value2")
> + LoggingContext += ("key3" -> "value3")
> +
> + LoggingContext --= Seq("key1", "key2")
> +
> + LoggingContext.get("key1") shouldBe None
> + LoggingContext.get("key2") shouldBe None
> + LoggingContext.get("key3") shouldBe Some("value3")
> + }
> +
> + test("clear, size, isEmpty") {
> + LoggingContext += ("key" -> "value")
> +
> + LoggingContext.clear()
> +
> + LoggingContext.contains("key") shouldBe false
> + LoggingContext.size shouldBe 0
> + LoggingContext.isEmpty shouldBe true
> + }
> +
> + test("iterator") {
> + LoggingContext += ("key1" -> "value1")
> + LoggingContext += ("key2" -> "value2")
> +
> + LoggingContext.iterator.toSet shouldBe Set("key1" -> "value1", "key2"
> -> "value2")
> + }
> +
> + test("foreach") {
> + LoggingContext += ("key1" -> "value1")
> + LoggingContext += ("key2" -> "value2")
> +
> + val result = mutable.Set.empty[(String, String)]
> +
> + LoggingContext.foreach { result += _ }
> +
> + result shouldBe Set("key1" -> "value1", "key2" -> "value2")
> + }
> +
> +}
>
> http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/
> blob/184045cb/pom.xml
> ----------------------------------------------------------------------
> diff --git a/pom.xml b/pom.xml
> index 1068ecb..c26cc7a 100644
> --- a/pom.xml
> +++ b/pom.xml
> @@ -106,6 +106,7 @@
> <module>log4j-api-scala_2.10</module>
> <module>log4j-api-scala_2.11</module>
> <module>log4j-api-scala_2.12</module>
> +<!--<module>log4j-api-scala_2.13</module> -->
> <module>log4j-api-scala-sample</module>
> </modules>
>
>
>
--
Matt Sicker <bo...@gmail.com>