You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by vy...@apache.org on 2023/09/15 06:57:55 UTC
[logging-log4j-scala] branch facelift created (now 3c019b5)
This is an automated email from the ASF dual-hosted git repository.
vy pushed a change to branch facelift
in repository https://gitbox.apache.org/repos/asf/logging-log4j-scala.git
at 3c019b5 Attempt to add Maven
This branch includes the following new commits:
new 39ac9ab Add sbt wrapper
new a5e02d4 Switch to semantic versioning: `13.0.0-SNAPSHOT`
new 86638c3 Simplify `build.sbt`
new 3c019b5 Attempt to add Maven
The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[logging-log4j-scala] 04/04: Attempt to add Maven
Posted by vy...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
vy pushed a commit to branch facelift
in repository https://gitbox.apache.org/repos/asf/logging-log4j-scala.git
commit 3c019b53d0c7e10522c77714d3b48c0d38f7c424
Author: Volkan Yazıcı <vo...@yazi.ci>
AuthorDate: Fri Sep 15 08:58:14 2023 +0200
Attempt to add Maven
---
.java-version | 1 +
.mvn/jvm.config | 1 +
.mvn/wrapper/maven-wrapper.jar | Bin 0 -> 62547 bytes
.mvn/wrapper/maven-wrapper.properties | 18 +
log4j-api-scala_2.10/pom.xml | 81 +++
.../org/apache/logging/log4j/scala/Logger.scala | 596 ++++++++++++++++++++
.../apache/logging/log4j/scala/LoggerMacro.scala | 339 ++++++++++++
.../org/apache/logging/log4j/scala/Logging.scala | 22 +-
.../logging/log4j/scala/LoggingContext.scala | 84 +++
.../apache/logging/log4j/scala/LoggerTest.scala | 555 +++++++++++++++++++
.../logging/log4j/scala/LoggingContextTest.scala | 116 ++++
log4j-api-scala_2.11/pom.xml | 81 +++
.../org/apache/logging/log4j/scala/Logger.scala | 1 +
.../apache/logging/log4j/scala/LoggerMacro.scala | 339 ++++++++++++
.../org/apache/logging/log4j/scala/Logging.scala | 1 +
.../logging/log4j/scala/LoggingContext.scala | 1 +
.../apache/logging/log4j/scala/LoggerTest.scala | 1 +
.../logging/log4j/scala/LoggingContextTest.scala | 1 +
log4j-api-scala_2.12/pom.xml | 81 +++
.../org/apache/logging/log4j/scala/Logger.scala | 1 +
.../apache/logging/log4j/scala/LoggerMacro.scala | 1 +
.../org/apache/logging/log4j/scala/Logging.scala | 1 +
.../logging/log4j/scala/LoggingContext.scala | 84 +++
.../apache/logging/log4j/scala/LoggerTest.scala | 1 +
.../logging/log4j/scala/LoggingContextTest.scala | 1 +
log4j-api-scala_2.13/pom.xml | 81 +++
.../org/apache/logging/log4j/scala/Logger.scala | 1 +
.../apache/logging/log4j/scala/LoggerMacro.scala | 1 +
.../org/apache/logging/log4j/scala/Logging.scala | 1 +
.../logging/log4j/scala/LoggingContext.scala | 75 +++
.../apache/logging/log4j/scala/LoggerTest.scala | 1 +
.../logging/log4j/scala/LoggingContextTest.scala | 1 +
log4j-api-scala_3/pom.xml | 81 +++
.../org/apache/logging/log4j/scala/Logger.scala | 597 +++++++++++++++++++++
.../apache/logging/log4j/scala/LoggerMacro.scala | 556 +++++++++++++++++++
.../org/apache/logging/log4j/scala/Logging.scala | 1 +
.../logging/log4j/scala/LoggingContext.scala | 1 +
.../apache/logging/log4j/scala/LoggerTest.scala | 555 +++++++++++++++++++
.../logging/log4j/scala/LoggingContextTest.scala | 1 +
mvnw | 311 +++++++++++
mvnw.cmd | 212 ++++++++
pom.xml | 159 ++++++
42 files changed, 5035 insertions(+), 8 deletions(-)
diff --git a/.java-version b/.java-version
new file mode 100644
index 0000000..6259340
--- /dev/null
+++ b/.java-version
@@ -0,0 +1 @@
+1.8
diff --git a/.mvn/jvm.config b/.mvn/jvm.config
new file mode 100644
index 0000000..2a2667e
--- /dev/null
+++ b/.mvn/jvm.config
@@ -0,0 +1 @@
+-Djava.awt.headless=true
diff --git a/.mvn/wrapper/maven-wrapper.jar b/.mvn/wrapper/maven-wrapper.jar
new file mode 100644
index 0000000..cb28b0e
Binary files /dev/null and b/.mvn/wrapper/maven-wrapper.jar differ
diff --git a/.mvn/wrapper/maven-wrapper.properties b/.mvn/wrapper/maven-wrapper.properties
new file mode 100644
index 0000000..08ea486
--- /dev/null
+++ b/.mvn/wrapper/maven-wrapper.properties
@@ -0,0 +1,18 @@
+# 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.
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.0/apache-maven-3.9.0-bin.zip
+wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar
diff --git a/log4j-api-scala_2.10/pom.xml b/log4j-api-scala_2.10/pom.xml
new file mode 100644
index 0000000..b05db0e
--- /dev/null
+++ b/log4j-api-scala_2.10/pom.xml
@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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</groupId>
+ <artifactId>log4j-api-scala-parent</artifactId>
+ <version>${revision}</version>
+ <relativePath>../pom.xml</relativePath>
+ </parent>
+
+ <artifactId>log4j-api-scala_2.10</artifactId>
+
+ <properties>
+ <scala.version.group>2.10</scala.version.group>
+ <scala.version>${scala.version.group}.7</scala.version>
+ </properties>
+
+ <dependencies>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-funsuite_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-matchers-core_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>junit-4-13_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>mockito-3-12_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>net.alchim31.maven</groupId>
+ <artifactId>scala-maven-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
new file mode 100644
index 0000000..1d0024f
--- /dev/null
+++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
@@ -0,0 +1,596 @@
+/*
+ * 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 =
+ delegate.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 = {
+ params match {
+ case Seq() => delegate.traceEntry()
+ case seq => delegate.traceEntry(seq.head.toString, seq.tail:_*)
+ }
+ }
+
+ /**
+ * 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 =
+ delegate.traceEntry(message)
+
+ /**
+ * Logs exit from a method with no result.
+ */
+ def traceExit(): Unit =
+ delegate.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 =
+ delegate.traceExit(result)
+
+ /**
+ * Logs exiting from a method with no result.
+ *
+ * @param entryMessage the `EntryMessage` returned from one of the `traceEntry` methods
+ */
+ def traceExit(entryMessage: EntryMessage): Unit =
+ delegate.traceExit(entryMessage)
+
+ /**
+ * 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 =
+ delegate.traceExit(entryMessage, result)
+
+ /**
+ * 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 =
+ delegate.traceExit(message, result)
+
+ /**
+ * 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 =
+ delegate.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 =
+ delegate.throwing(level, t)
+
+ /**
+ * Logs an exception or error that has been caught.
+ *
+ * @param t the Throwable.
+ */
+ def catching(t: Throwable): Unit =
+ delegate.catching(t)
+
+ /**
+ * 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 =
+ delegate.catching(level, t)
+
+
+ /** 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)
+ }
+
+}
diff --git a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
new file mode 100644
index 0000000..c30dfee
--- /dev/null
+++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
@@ -0,0 +1,339 @@
+/*
+ * 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.Message
+import org.apache.logging.log4j.{Level, Marker}
+
+import scala.language.experimental.macros
+import scala.reflect.macros.Context
+
+/**
+ * Inspired from [[https://github.com/typesafehub/scalalogging ScalaLogging]].
+ */
+private object LoggerMacro {
+
+ type LoggerContext = Context {type PrefixType = Logger}
+
+
+ def fatalMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) =
+ logMarkerMsg(c)(c.universe.reify(Level.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)
+ }
+ )
+
+}
diff --git a/project/plugins.sbt b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
similarity index 63%
rename from project/plugins.sbt
rename to log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
index de63ac9..b017de7 100644
--- a/project/plugins.sbt
+++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
@@ -14,11 +14,17 @@
* See the license for the specific language governing permissions and
* limitations under the license.
*/
-addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.1.1")
-addSbtPlugin("com.github.gseitz" % "sbt-release" % "1.0.8")
-addSbtPlugin("com.typesafe.sbt" % "sbt-license-report" % "1.2.0")
-addSbtPlugin("com.typesafe.sbt" % "sbt-site" % "1.3.2")
-addSbtPlugin("com.typesafe.sbt" % "sbt-osgi" % "0.9.3")
-// for quicker resolutions from Maven Central of new releases, uncomment:
-//resolvers += Resolver.sonatypeRepo("public")
-addSbtPlugin("org.musigma" % "sbt-rat" % "0.5.1")
+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
diff --git a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
new file mode 100644
index 0000000..246ab02
--- /dev/null
+++ b/log4j-api-scala_2.10/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.{immutable, mutable}
+import scala.collection.JavaConverters._
+
+/** 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
+
+}
diff --git a/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
new file mode 100644
index 0000000..979b8b6
--- /dev/null
+++ b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
@@ -0,0 +1,555 @@
+/*
+ * 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, EntryMessage, 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.ArgumentMatchers.{any, anyString, eq => eqv}
+import org.mockito.Mockito._
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatestplus.junit.JUnitRunner
+import org.scalatestplus.mockito.MockitoSugar
+
+case class Custom(i: Int)
+
+trait Manager {
+ def fetchValue(): Int
+}
+
+case class TestFixture(mockLogger: ExtendedLogger, manager: Manager)
+
+@RunWith(classOf[JUnitRunner])
+class LoggerTest extends AnyFunSuite with MockitoSugar {
+
+ val msg = new ParameterizedMessage("msg {}", 17)
+ val entryMsg: EntryMessage = new DefaultFlowMessageFactory().newEntryMessage(msg)
+ val cseqMsg : CharSequence = new StringBuilder().append("cseq msg")
+ val objectMsg = Custom(17)
+ val cause = new RuntimeException("cause")
+ val marker : Marker = MarkerManager.getMarker("marker")
+ val result = "foo"
+
+ def fixture: TestFixture = {
+ 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
+ }
+ TestFixture(mockLogger, manager)
+ }
+
+ 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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("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")
+ //traceEntry is now passes through to the underlying logger without checking if logging is enabled (the delegate checks anyway)
+ verify(f.mockLogger).traceEntry("foo", "bar")
+ }
+
+ 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)
+ //traceEntry is now passes through to the underlying logger without checking if logging is enabled (the delegate checks anyway)
+ verify(f.mockLogger).traceEntry(eqv(msg))
+ }
+
+ 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)
+ //traceExit is now passes through to the underlying logger without checking if logging is enabled (the delegate checks anyway)
+ verify(f.mockLogger).traceExit(eqv(msg), eqv(result))
+ }
+
+ 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))
+ }
+
+}
diff --git a/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
new file mode 100644
index 0000000..b37124c
--- /dev/null
+++ b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
@@ -0,0 +1,116 @@
+/*
+ * 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.matchers.should.Matchers
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatestplus.junit.JUnitRunner
+
+import scala.collection.mutable
+
+@RunWith(classOf[JUnitRunner])
+class LoggingContextTest extends AnyFunSuite 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 ++= Seq("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 --= Set("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")
+ }
+
+}
diff --git a/log4j-api-scala_2.11/pom.xml b/log4j-api-scala_2.11/pom.xml
new file mode 100644
index 0000000..ca9a454
--- /dev/null
+++ b/log4j-api-scala_2.11/pom.xml
@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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</groupId>
+ <artifactId>log4j-api-scala-parent</artifactId>
+ <version>${revision}</version>
+ <relativePath>../pom.xml</relativePath>
+ </parent>
+
+ <artifactId>log4j-api-scala_2.11</artifactId>
+
+ <properties>
+ <scala.version.group>2.11</scala.version.group>
+ <scala.version>${scala.version.group}.12</scala.version>
+ </properties>
+
+ <dependencies>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-funsuite_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-matchers-core_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>junit-4-13_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>mockito-3-12_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>net.alchim31.maven</groupId>
+ <artifactId>scala-maven-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
new file mode 120000
index 0000000..d45a1ad
--- /dev/null
+++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
\ No newline at end of file
diff --git a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
new file mode 100644
index 0000000..c8b5301
--- /dev/null
+++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
@@ -0,0 +1,339 @@
+/*
+ * 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.Message
+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)
+ }
+ )
+
+}
diff --git a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logging.scala b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
new file mode 120000
index 0000000..f8b0826
--- /dev/null
+++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
\ No newline at end of file
diff --git a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
new file mode 120000
index 0000000..31ecf05
--- /dev/null
+++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
\ No newline at end of file
diff --git a/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
new file mode 120000
index 0000000..2127511
--- /dev/null
+++ b/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
\ No newline at end of file
diff --git a/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala b/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
new file mode 120000
index 0000000..1fb174b
--- /dev/null
+++ b/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
\ No newline at end of file
diff --git a/log4j-api-scala_2.12/pom.xml b/log4j-api-scala_2.12/pom.xml
new file mode 100644
index 0000000..2b5afc7
--- /dev/null
+++ b/log4j-api-scala_2.12/pom.xml
@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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</groupId>
+ <artifactId>log4j-api-scala-parent</artifactId>
+ <version>${revision}</version>
+ <relativePath>../pom.xml</relativePath>
+ </parent>
+
+ <artifactId>log4j-api-scala_2.12</artifactId>
+
+ <properties>
+ <scala.version.group>2.12</scala.version.group>
+ <scala.version>${scala.version.group}.18</scala.version>
+ </properties>
+
+ <dependencies>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-funsuite_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-matchers-core_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>junit-4-13_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>mockito-3-12_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>net.alchim31.maven</groupId>
+ <artifactId>scala-maven-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
new file mode 120000
index 0000000..d45a1ad
--- /dev/null
+++ b/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
\ No newline at end of file
diff --git a/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
new file mode 120000
index 0000000..837f3b4
--- /dev/null
+++ b/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
\ No newline at end of file
diff --git a/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/Logging.scala b/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
new file mode 120000
index 0000000..f8b0826
--- /dev/null
+++ b/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
\ No newline at end of file
diff --git a/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala b/log4j-api-scala_2.12/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
new file mode 100644
index 0000000..246ab02
--- /dev/null
+++ b/log4j-api-scala_2.12/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.{immutable, mutable}
+import scala.collection.JavaConverters._
+
+/** 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
+
+}
diff --git a/log4j-api-scala_2.12/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_2.12/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
new file mode 120000
index 0000000..2127511
--- /dev/null
+++ b/log4j-api-scala_2.12/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
\ No newline at end of file
diff --git a/log4j-api-scala_2.12/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala b/log4j-api-scala_2.12/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
new file mode 120000
index 0000000..1fb174b
--- /dev/null
+++ b/log4j-api-scala_2.12/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
\ No newline at end of file
diff --git a/log4j-api-scala_2.13/pom.xml b/log4j-api-scala_2.13/pom.xml
new file mode 100644
index 0000000..b3aae80
--- /dev/null
+++ b/log4j-api-scala_2.13/pom.xml
@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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</groupId>
+ <artifactId>log4j-api-scala-parent</artifactId>
+ <version>${revision}</version>
+ <relativePath>../pom.xml</relativePath>
+ </parent>
+
+ <artifactId>log4j-api-scala_2.13</artifactId>
+
+ <properties>
+ <scala.version.group>2.13</scala.version.group>
+ <scala.version>${scala.version.group}.6</scala.version>
+ </properties>
+
+ <dependencies>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-funsuite_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-matchers-core_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>junit-4-13_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>mockito-3-12_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>net.alchim31.maven</groupId>
+ <artifactId>scala-maven-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
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 120000
index 0000000..d45a1ad
--- /dev/null
+++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
\ No newline at end of file
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 120000
index 0000000..837f3b4
--- /dev/null
+++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
\ No newline at end of file
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 120000
index 0000000..f8b0826
--- /dev/null
+++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
\ No newline at end of file
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..c21529c
--- /dev/null
+++ b/log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
@@ -0,0 +1,75 @@
+/*
+ * 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.jdk.CollectionConverters._
+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 addOne(kv: (String, String)): LoggingContext.this.type = {
+ ThreadContext.put(kv._1, kv._2)
+ this
+ }
+
+ override def addAll(xs: IterableOnce[(String, String)]): LoggingContext.this.type = {
+ ThreadContext.putAll(xs.iterator.to(Map).asJava)
+ this
+ }
+
+ override def subtractOne(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 subtractAll(xs: IterableOnce[String]): LoggingContext.this.type = {
+ ThreadContext.removeAll(xs.iterator.to(Seq).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
+
+}
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 120000
index 0000000..2127511
--- /dev/null
+++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
\ No newline at end of file
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 120000
index 0000000..1fb174b
--- /dev/null
+++ b/log4j-api-scala_2.13/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
\ No newline at end of file
diff --git a/log4j-api-scala_3/pom.xml b/log4j-api-scala_3/pom.xml
new file mode 100644
index 0000000..eaa6639
--- /dev/null
+++ b/log4j-api-scala_3/pom.xml
@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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</groupId>
+ <artifactId>log4j-api-scala-parent</artifactId>
+ <version>${revision}</version>
+ <relativePath>../pom.xml</relativePath>
+ </parent>
+
+ <artifactId>log4j-api-scala_3</artifactId>
+
+ <properties>
+ <scala.version.group>3</scala.version.group>
+ <scala.version>${scala.version.group}.3.1</scala.version>
+ </properties>
+
+ <dependencies>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-funsuite_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-matchers-core_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>junit-4-13_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>mockito-3-12_${scala.version.group}</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>net.alchim31.maven</groupId>
+ <artifactId>scala-maven-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
new file mode 100644
index 0000000..8184496
--- /dev/null
+++ b/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
@@ -0,0 +1,597 @@
+/*
+ * 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.quoted.*
+
+/**
+ * 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 {
+
+ inline def fatal(inline marker: Marker, inline message: Message): Unit =
+ ${LoggerMacro.fatalMarkerMsg('this, 'marker, 'message)}
+
+ inline def fatal(inline marker: Marker, inline message: CharSequence): Unit =
+ ${LoggerMacro.fatalMarkerCseq('this, 'marker, 'message)}
+
+ inline def fatal(inline marker: Marker, inline message: AnyRef): Unit =
+ ${LoggerMacro.fatalMarkerObject('this, 'marker, 'message)}
+
+ inline def fatal(inline marker: Marker, inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.fatalMarkerMsgThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def fatal(inline marker: Marker, inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.fatalMarkerCseqThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def fatal(inline marker: Marker, inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.fatalMarkerObjectThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def fatal(inline message: Message): Unit =
+ ${LoggerMacro.fatalMsg('this, 'message)}
+
+ inline def fatal(inline message: CharSequence): Unit =
+ ${LoggerMacro.fatalCseq('this, 'message)}
+
+ inline def fatal(inline message: AnyRef): Unit =
+ ${LoggerMacro.fatalObject('this, 'message)}
+
+ inline def fatal(inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.fatalMsgThrowable('this, 'message, 'cause)}
+
+ inline def fatal(inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.fatalCseqThrowable('this, 'message, 'cause)}
+
+ inline def fatal(inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.fatalObjectThrowable('this, 'message, 'cause)}
+
+ inline def error(inline marker: Marker, inline message: Message): Unit =
+ ${LoggerMacro.errorMarkerMsg('this, 'marker, 'message)}
+
+ inline def error(inline marker: Marker, inline message: CharSequence): Unit =
+ ${LoggerMacro.errorMarkerCseq('this, 'marker, 'message)}
+
+ inline def error(inline marker: Marker, inline message: AnyRef): Unit =
+ ${LoggerMacro.errorMarkerObject('this, 'marker, 'message)}
+
+
+ inline def error(inline marker: Marker, inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.errorMarkerMsgThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def error(inline marker: Marker, inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.errorMarkerCseqThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def error(inline marker: Marker, inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.errorMarkerObjectThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def error(inline message: Message): Unit =
+ ${LoggerMacro.errorMsg('this, 'message)}
+
+ inline def error(inline message: CharSequence): Unit =
+ ${LoggerMacro.errorCseq('this, 'message)}
+
+ inline def error(inline message: AnyRef): Unit =
+ ${LoggerMacro.errorObject('this, 'message)}
+
+ inline def error(inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.errorMsgThrowable('this, 'message, 'cause)}
+
+ inline def error(inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.errorCseqThrowable('this, 'message, 'cause)}
+
+ inline def error(inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.errorObjectThrowable('this, 'message, 'cause)}
+
+
+ inline def warn(inline marker: Marker, inline message: Message): Unit =
+ ${LoggerMacro.warnMarkerMsg('this, 'marker, 'message)}
+
+ inline def warn(inline marker: Marker, inline message: CharSequence): Unit =
+ ${LoggerMacro.warnMarkerCseq('this, 'marker, 'message)}
+
+ inline def warn(inline marker: Marker, inline message: AnyRef): Unit =
+ ${LoggerMacro.warnMarkerObject('this, 'marker, 'message)}
+
+ inline def warn(inline marker: Marker, inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.warnMarkerMsgThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def warn(inline marker: Marker, inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.warnMarkerCseqThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def warn(inline marker: Marker, inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.warnMarkerObjectThrowable('this, 'marker, 'message, 'cause)}
+
+
+ inline def warn(message: Message): Unit =
+ ${LoggerMacro.warnMsg('this, 'message)}
+
+ inline def warn(inline message: CharSequence): Unit =
+ ${LoggerMacro.warnCseq('this, 'message)}
+
+ inline def warn(inline message: AnyRef): Unit =
+ ${LoggerMacro.warnObject('this, 'message)}
+
+ inline def warn(inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.warnMsgThrowable('this, 'message, 'cause)}
+
+ inline def warn(inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.warnCseqThrowable('this, 'message, 'cause)}
+
+ inline def warn(inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.warnObjectThrowable('this, 'message, 'cause)}
+
+
+ inline def info(inline marker: Marker, inline message: Message): Unit =
+ ${LoggerMacro.infoMarkerMsg('this, 'marker, 'message)}
+
+ inline def info(inline marker: Marker, inline message: CharSequence): Unit =
+ ${LoggerMacro.infoMarkerCseq('this, 'marker, 'message)}
+
+ inline def info(inline marker: Marker, inline message: AnyRef): Unit =
+ ${LoggerMacro.infoMarkerObject('this, 'marker, 'message)}
+
+ inline def info(inline marker: Marker, inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.infoMarkerMsgThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def info(inline marker: Marker, inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.infoMarkerCseqThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def info(inline marker: Marker, inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.infoMarkerObjectThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def info(inline message: Message): Unit =
+ ${LoggerMacro.infoMsg('this, 'message)}
+
+ inline def info(inline message: CharSequence): Unit =
+ ${LoggerMacro.infoCseq('this, 'message)}
+
+ inline def info(inline message: AnyRef): Unit =
+ ${LoggerMacro.infoObject('this, 'message)}
+
+ inline def info(inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.infoMsgThrowable('this, 'message, 'cause)}
+
+ inline def info(inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.infoCseqThrowable('this, 'message, 'cause)}
+
+ inline def info(inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.infoObjectThrowable('this, 'message, 'cause)}
+
+
+ inline def debug(inline marker: Marker, inline message: Message): Unit =
+ ${LoggerMacro.debugMarkerMsg('this, 'marker, 'message)}
+
+ inline def debug(inline marker: Marker, inline message: CharSequence): Unit =
+ ${LoggerMacro.debugMarkerCseq('this, 'marker, 'message)}
+
+ inline def debug(inline marker: Marker, inline message: AnyRef): Unit =
+ ${LoggerMacro.debugMarkerObject('this, 'marker, 'message)}
+
+ inline def debug(inline marker: Marker, inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.debugMarkerMsgThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def debug(inline marker: Marker, inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.fatalMarkerCseqThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def debug(inline marker: Marker, inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.debugMarkerObjectThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def debug(inline message: Message): Unit =
+ ${LoggerMacro.debugMsg('this, 'message)}
+
+ inline def debug(inline message: CharSequence): Unit =
+ ${LoggerMacro.debugCseq('this, 'message)}
+
+ inline def debug(inline message: AnyRef): Unit =
+ ${LoggerMacro.debugObject('this, 'message)}
+
+ inline def debug(inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.debugMsgThrowable('this, 'message, 'cause)}
+
+ inline def debug(inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.debugCseqThrowable('this, 'message, 'cause)}
+
+ inline def debug(inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.debugObjectThrowable('this, 'message, 'cause)}
+
+
+ inline def trace(inline marker: Marker, inline message: Message): Unit =
+ ${LoggerMacro.traceMarkerMsg('this, 'marker, 'message)}
+
+ inline def trace(inline marker: Marker, inline message: CharSequence): Unit =
+ ${LoggerMacro.traceMarkerCseq('this, 'marker, 'message)}
+
+ inline def trace(inline marker: Marker, inline message: AnyRef): Unit =
+ ${LoggerMacro.traceMarkerObject('this, 'marker, 'message)}
+
+ inline def trace(inline marker: Marker, inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.traceMarkerMsgThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def trace(inline marker: Marker, inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.fatalMarkerCseqThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def trace(inline marker: Marker, inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.traceMarkerObjectThrowable('this, 'marker, 'message, 'cause)}
+
+ inline def trace(inline message: Message): Unit =
+ ${LoggerMacro.traceMsg('this, 'message)}
+
+ inline def trace(inline message: CharSequence): Unit =
+ ${LoggerMacro.traceCseq('this, 'message)}
+
+ inline def trace(inline message: AnyRef): Unit =
+ ${LoggerMacro.traceObject('this, 'message)}
+
+ inline def trace(inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.traceMsgThrowable('this, 'message, 'cause)}
+
+ inline def trace(inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.traceCseqThrowable('this, 'message, 'cause)}
+
+ inline def trace(inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.traceObjectThrowable('this, 'message, 'cause)}
+
+
+ /**
+ * 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
+ */
+ inline def apply(inline level: Level, inline marker: Marker, inline message: Message): Unit =
+ ${LoggerMacro.logMarkerMsg('this, 'level, 'marker, 'message)}
+
+ /**
+ * 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
+ */
+ inline def apply(inline level: Level, inline marker: Marker, inline message: CharSequence): Unit =
+ ${LoggerMacro.logMarkerCseq('this, 'level, 'marker, 'message)}
+
+ /**
+ * 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
+ */
+ inline def apply(inline level: Level, inline marker: Marker, inline message: AnyRef): Unit =
+ ${LoggerMacro.logMarkerObject('this, 'level, 'marker, 'message)}
+
+ /**
+ * 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
+ */
+ inline def apply(inline level: Level, inline marker: Marker, inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.logMarkerMsgThrowable('this, 'level, 'marker, 'message, 'cause)}
+
+ /**
+ * 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
+ */
+ inline def apply(inline level: Level, inline marker: Marker, inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.logMarkerCseqThrowable('this, 'level, 'marker, 'message, 'cause)}
+
+ /**
+ * 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
+ */
+ inline def apply(inline level: Level, inline marker: Marker, inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.logMarkerObjectThrowable('this, 'level, 'marker, 'message, 'cause)}
+
+ /**
+ * Logs a `Message` at the given `Level`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ */
+ inline def apply(inline level: Level, inline message: Message): Unit =
+ ${LoggerMacro.logMsg('this, 'level, 'message)}
+
+ /**
+ * Logs a string at the given `Level`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ */
+ inline def apply(inline level: Level, inline message: CharSequence): Unit =
+ ${LoggerMacro.logCseq('this, 'level, 'message)}
+
+ /**
+ * Logs an object at the given `Level`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ */
+ inline def apply(inline level: Level, inline message: AnyRef): Unit =
+ ${LoggerMacro.logObject('this, 'level, 'message)}
+
+ /**
+ * 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`
+ */
+ inline def apply(inline level: Level, inline message: Message, inline cause: Throwable): Unit =
+ ${LoggerMacro.logMsgThrowable('this, 'level, 'message, 'cause)}
+
+ /**
+ * 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`
+ */
+ inline def apply(inline level: Level, inline message: CharSequence, inline cause: Throwable): Unit =
+ ${LoggerMacro.logCseqThrowable('this, 'level, 'message, 'cause)}
+
+ /**
+ * 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`
+ */
+ inline def apply(inline level: Level, inline message: AnyRef, inline cause: Throwable): Unit =
+ ${LoggerMacro.logObjectThrowable('this, 'level, 'message, 'cause)}
+
+
+ /**
+ * 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`
+ */
+ inline def traceEntry(): EntryMessage =
+ delegate.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`
+ */
+ inline def traceEntry(inline params: AnyRef*): EntryMessage = {
+ params match {
+ case Seq() => delegate.traceEntry()
+ case seq => delegate.traceEntry(seq.head.toString, seq.tail:_*)
+ }
+ }
+
+ /**
+ * 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`
+ */
+ inline def traceEntry(inline message: Message): EntryMessage =
+ delegate.traceEntry(message)
+
+ /**
+ * Logs exit from a method with no result.
+ */
+ inline def traceExit(): Unit =
+ delegate.traceExit()
+
+ /**
+ * Logs exiting from a method with result.
+ *
+ * @param result The result being returned from the method call
+ * @return `result`
+ */
+ inline def traceExit[R](inline result: R): R =
+ delegate.traceExit(result)
+
+ /**
+ * Logs exiting from a method with no result.
+ *
+ * @param entryMessage the `EntryMessage` returned from one of the `traceEntry` methods
+ */
+ inline def traceExit(inline entryMessage: EntryMessage): Unit =
+ delegate.traceExit(entryMessage)
+
+ /**
+ * 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`
+ */
+ inline def traceExit[R](inline entryMessage: EntryMessage, result: R): R =
+ delegate.traceExit(entryMessage, result)
+
+ /**
+ * 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`
+ */
+ inline def traceExit[R](inline message: Message, result: R): R =
+ delegate.traceExit(message, result)
+
+ /**
+ * Logs an exception or error to be thrown.
+ *
+ * {{{
+ * throw logger.throwing(myException)
+ * }}}
+ *
+ * @param t the Throwable
+ * @return `t`
+ */
+ inline def throwing[T <: Throwable](inline t: T): T =
+ delegate.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`
+ */
+ inline def throwing[T <: Throwable](inline level: Level, inline t: T): T =
+ delegate.throwing(level, t)
+
+ /**
+ * Logs an exception or error that has been caught.
+ *
+ * @param t the Throwable.
+ */
+ inline def catching(inline t: Throwable): Unit =
+ delegate.catching(t)
+
+ /**
+ * Logs an exception or error that has been caught to a specific logging level.
+ *
+ * @param level The logging Level.
+ * @param t The Throwable.
+ */
+ inline def catching(inline level: Level, inline t: Throwable): Unit =
+ delegate.catching(level, t)
+
+
+ /** 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)
+ }
+
+}
diff --git a/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
new file mode 100644
index 0000000..d3ec3f4
--- /dev/null
+++ b/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
@@ -0,0 +1,556 @@
+/*
+ * 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, ExtendedLogger}
+import org.apache.logging.log4j.{Level, Marker}
+
+import scala.quoted.*
+
+/**
+ * Inspired from [[https://github.com/typesafehub/scalalogging ScalaLogging]].
+ */
+private object LoggerMacro {
+ // Trace
+
+ def traceMsg(underlying: Expr[Logger], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.TRACE)) $underlying.trace($message) }
+ }
+
+ def traceMsgThrowable(underlying: Expr[Logger], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.TRACE)) $underlying.trace($message, $throwable) }
+ }
+
+ def traceMarkerMsg(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.TRACE, $marker)) $underlying.trace($marker, $message) }
+ }
+
+ def traceMarkerMsgThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.TRACE, $marker)) $underlying.trace($marker, $message, $throwable) }
+ }
+
+ def traceCseq(underlying: Expr[Logger], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgs(underlying, '{Level.TRACE}, messageFormat, Expr.ofSeq(args))
+ }
+
+ def traceCseqThrowable(underlying: Expr[Logger], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgsThrowable(underlying, '{Level.TRACE}, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def traceMarkerCseq(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgs(underlying, '{Level.TRACE}, marker, messageFormat, Expr.ofSeq(args))
+ }
+
+ def traceMarkerCseqThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgsThrowable(underlying, '{Level.TRACE}, marker, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def traceObject(underlying: Expr[Logger], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.TRACE)) $underlying.trace($message) }
+ }
+
+ def traceObjectThrowable(underlying: Expr[Logger], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.TRACE)) $underlying.trace($message, $throwable) }
+ }
+
+ def traceMarkerObject(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.TRACE, $marker)) $underlying.trace($marker, $message) }
+ }
+
+ def traceMarkerObjectThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.TRACE, $marker)) $underlying.trace($marker, $message, $throwable) }
+ }
+
+ // Debug
+
+ def debugMsg(underlying: Expr[Logger], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.DEBUG)) $underlying.debug($message) }
+ }
+
+ def debugMsgThrowable(underlying: Expr[Logger], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.DEBUG)) $underlying.debug($message, $throwable) }
+ }
+
+ def debugMarkerMsg(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.DEBUG, $marker)) $underlying.debug($marker, $message) }
+ }
+
+ def debugMarkerMsgThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.DEBUG, $marker)) $underlying.debug($marker, $message, $throwable) }
+ }
+
+ def debugCseq(underlying: Expr[Logger], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgs(underlying, '{Level.DEBUG}, messageFormat, Expr.ofSeq(args))
+ }
+
+ def debugCseqThrowable(underlying: Expr[Logger], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgsThrowable(underlying, '{Level.DEBUG}, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def debugMarkerCseq(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgs(underlying, '{Level.DEBUG}, marker, messageFormat, Expr.ofSeq(args))
+ }
+
+ def debugMarkerCseqThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgsThrowable(underlying, '{Level.DEBUG}, marker, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def debugObject(underlying: Expr[Logger], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.DEBUG)) $underlying.debug($message) }
+ }
+
+ def debugObjectThrowable(underlying: Expr[Logger], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.DEBUG)) $underlying.debug($message, $throwable) }
+ }
+
+ def debugMarkerObject(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.DEBUG, $marker)) $underlying.debug($marker, $message) }
+ }
+
+ def debugMarkerObjectThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.DEBUG, $marker)) $underlying.debug($marker, $message, $throwable) }
+ }
+
+ // Info
+
+ def infoMsg(underlying: Expr[Logger], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.INFO)) $underlying.info($message) }
+ }
+
+ def infoMsgThrowable(underlying: Expr[Logger], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.INFO)) $underlying.info($message, $throwable) }
+ }
+
+ def infoMarkerMsg(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.INFO, $marker)) $underlying.info($marker, $message) }
+ }
+
+ def infoMarkerMsgThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.INFO, $marker)) $underlying.info($marker, $message, $throwable) }
+ }
+
+ def infoCseq(underlying: Expr[Logger], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgs(underlying, '{Level.INFO}, messageFormat, Expr.ofSeq(args))
+ }
+
+ def infoCseqThrowable(underlying: Expr[Logger], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgsThrowable(underlying, '{Level.INFO}, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def infoMarkerCseq(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgs(underlying, '{Level.INFO}, marker, messageFormat, Expr.ofSeq(args))
+ }
+
+ def infoMarkerCseqThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgsThrowable(underlying, '{Level.INFO}, marker, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+
+ def infoObject(underlying: Expr[Logger], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.INFO)) $underlying.info($message) }
+ }
+
+ def infoObjectThrowable(underlying: Expr[Logger], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.INFO)) $underlying.info($message, $throwable) }
+ }
+
+ def infoMarkerObject(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.INFO, $marker)) $underlying.info($marker, $message) }
+ }
+
+ def infoMarkerObjectThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.INFO, $marker)) $underlying.info($marker, $message, $throwable) }
+ }
+
+ //Warn
+
+ def warnMsg(underlying: Expr[Logger], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.WARN)) $underlying.warn($message) }
+ }
+
+ def warnMsgThrowable(underlying: Expr[Logger], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.WARN)) $underlying.warn($message, $throwable) }
+ }
+
+ def warnMarkerMsg(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.WARN, $marker)) $underlying.warn($marker, $message) }
+ }
+
+ def warnMarkerMsgThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.WARN, $marker)) $underlying.warn($marker, $message, $throwable) }
+ }
+
+ def warnCseq(underlying: Expr[Logger], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgs(underlying, '{Level.WARN}, messageFormat, Expr.ofSeq(args))
+ }
+
+ def warnCseqThrowable(underlying: Expr[Logger], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgsThrowable(underlying, '{Level.WARN}, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def warnMarkerCseq(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgs(underlying, '{Level.WARN}, marker, messageFormat, Expr.ofSeq(args))
+ }
+
+ def warnMarkerCseqThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgsThrowable(underlying, '{Level.WARN}, marker, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def warnObject(underlying: Expr[Logger], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.WARN)) $underlying.warn($message) }
+ }
+
+ def warnObjectThrowable(underlying: Expr[Logger], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.WARN)) $underlying.warn($message, $throwable) }
+ }
+
+ def warnMarkerObject(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.WARN, $marker)) $underlying.warn($marker, $message) }
+ }
+
+ def warnMarkerObjectThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.WARN, $marker)) $underlying.warn($marker, $message, $throwable) }
+ }
+
+ //Error
+
+ def errorMsg(underlying: Expr[Logger], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.ERROR)) $underlying.error($message) }
+ }
+
+ def errorMsgThrowable(underlying: Expr[Logger], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.ERROR)) $underlying.error($message, $throwable) }
+ }
+
+ def errorMarkerMsg(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.ERROR, $marker)) $underlying.error($marker, $message) }
+ }
+
+ def errorMarkerMsgThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.ERROR, $marker)) $underlying.error($marker, $message, $throwable) }
+ }
+
+ def errorCseq(underlying: Expr[Logger], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgs(underlying, '{Level.ERROR}, messageFormat, Expr.ofSeq(args))
+ }
+
+ def errorCseqThrowable(underlying: Expr[Logger], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgsThrowable(underlying, '{Level.ERROR}, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def errorMarkerCseq(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgs(underlying, '{Level.ERROR}, marker, messageFormat, Expr.ofSeq(args))
+ }
+
+ def errorMarkerCseqThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgsThrowable(underlying, '{Level.ERROR}, marker, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def errorObject(underlying: Expr[Logger], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.ERROR)) $underlying.error($message) }
+ }
+
+ def errorObjectThrowable(underlying: Expr[Logger], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.ERROR)) $underlying.error($message, $throwable) }
+ }
+
+ def errorMarkerObject(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.ERROR, $marker)) $underlying.error($marker, $message) }
+ }
+
+ def errorMarkerObjectThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.ERROR, $marker)) $underlying.error($marker, $message, $throwable) }
+ }
+
+ //Fatal
+
+ def fatalMsg(underlying: Expr[Logger], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.FATAL)) $underlying.fatal($message) }
+ }
+
+ def fatalMsgThrowable(underlying: Expr[Logger], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.FATAL)) $underlying.fatal($message, $throwable) }
+ }
+
+ def fatalMarkerMsg(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.FATAL, $marker)) $underlying.fatal($marker, $message) }
+ }
+
+ def fatalMarkerMsgThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[Message],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.FATAL, $marker)) $underlying.fatal($marker, $message, $throwable) }
+ }
+
+ def fatalCseq(underlying: Expr[Logger], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgs(underlying, '{Level.FATAL}, messageFormat, Expr.ofSeq(args))
+ }
+
+ def fatalCseqThrowable(underlying: Expr[Logger], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgsThrowable(underlying, '{Level.FATAL}, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def fatalMarkerCseq(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgs(underlying, '{Level.FATAL}, marker, messageFormat, Expr.ofSeq(args))
+ }
+
+ def fatalMarkerCseqThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgsThrowable(underlying, '{Level.FATAL}, marker, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def fatalObject(underlying: Expr[Logger], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.FATAL)) $underlying.fatal($message) }
+ }
+
+ def fatalObjectThrowable(underlying: Expr[Logger], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.FATAL)) $underlying.fatal($message, $throwable) }
+ }
+
+ def fatalMarkerObject(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.FATAL, $marker)) $underlying.fatal($marker, $message) }
+ }
+
+ def fatalMarkerObjectThrowable(underlying: Expr[Logger], marker: Expr[Marker], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled(Level.FATAL, $marker)) $underlying.fatal($marker, $message, $throwable) }
+ }
+
+ def logMsg(underlying: Expr[Logger], level: Expr[Level], message: Expr[Message])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled($level)) $underlying.delegate.log($level, $message) }
+ }
+
+ def logMsgThrowable(underlying: Expr[Logger], level: Expr[Level], message: Expr[Message], throwable: Expr[Throwable])
+ (using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled($level)) $underlying.delegate.log($level, $message, $throwable) }
+ }
+
+ def logObject(underlying: Expr[Logger], level: Expr[Level], message: Expr[AnyRef])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled($level)) $underlying.delegate.log($level, $message) }
+ }
+
+ def logObjectThrowable(underlying: Expr[Logger], level: Expr[Level], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled($level)) $underlying.delegate.log($level, $message, $throwable) }
+ }
+
+ def logCseq(underlying: Expr[Logger], level: Expr[Level], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgs(underlying, level, messageFormat, Expr.ofSeq(args))
+ }
+
+ def logCseqThrowable(underlying: Expr[Logger], level: Expr[Level], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMessageArgsThrowable(underlying, level, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ def logMarkerMsg(underlying: Expr[Logger], level: Expr[Level], marker: Expr[Marker], message: Expr[Message])
+ (using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled($level, $marker)) $underlying.delegate.log($level, $marker, $message) }
+ }
+
+ def logMarkerMsgThrowable(underlying: Expr[Logger], level: Expr[Level], marker: Expr[Marker], message: Expr[Message], throwable: Expr[Throwable])
+ (using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled($level, $marker)) $underlying.delegate.log($level, $marker, $message, $throwable) }
+ }
+
+ def logMarkerObject(underlying: Expr[Logger], level: Expr[Level], marker: Expr[Marker], message: Expr[AnyRef])
+ (using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled($level, $marker)) $underlying.delegate.log($level, $marker, $message) }
+ }
+
+ def logMarkerObjectThrowable(underlying: Expr[Logger], level: Expr[Level], marker: Expr[Marker], message: Expr[AnyRef],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ '{ if ($underlying.delegate.isEnabled($level, $marker)) $underlying.delegate.log($level, $marker, $message, $throwable) }
+ }
+
+ def logMarkerCseq(underlying: Expr[Logger], level: Expr[Level], marker: Expr[Marker], message: Expr[CharSequence])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgs(underlying, level, marker, messageFormat, Expr.ofSeq(args))
+ }
+
+ def logMarkerCseqThrowable(underlying: Expr[Logger], level: Expr[Level], marker: Expr[Marker], message: Expr[CharSequence],
+ throwable: Expr[Throwable])(using Quotes): Expr[Unit] = {
+ val (messageFormat, args) = deconstructInterpolatedMessage(message)
+ logMarkerMessageArgsThrowable(underlying, level, marker, messageFormat, Expr.ofSeq(args), throwable)
+ }
+
+ private def logMessageArgs(underlying: Expr[Logger], level: Expr[Level], message: Expr[CharSequence],
+ args: Expr[Seq[Any]]) (using Quotes) = {
+ val anyRefArgs = formatArgs(args)
+ if(anyRefArgs.isEmpty)
+ '{ if ($underlying.delegate.isEnabled($level)) $underlying.logMessage($level, null, ${charSequenceExprToStringExpr(message)}, null) }
+ else if(anyRefArgs.length == 1)
+ '{ if ($underlying.delegate.isEnabled($level)) $underlying.delegate.log($level, ${charSequenceExprToStringExpr(message)}, ${anyRefArgs.head}) }
+ else
+ '{ if ($underlying.delegate.isEnabled($level)) $underlying.delegate.log($level, ${charSequenceExprToStringExpr(message)}, ${Expr.ofSeq(anyRefArgs)}*) }
+ }
+
+ private def logMessageArgsThrowable(underlying: Expr[Logger], level: Expr[Level], message: Expr[CharSequence],
+ args: Expr[Seq[Any]], throwable: Expr[Throwable]) (using Quotes) = {
+ val anyRefArgs = formatArgs(args)
+ if(anyRefArgs.isEmpty)
+ '{ if ($underlying.delegate.isEnabled($level)) $underlying.logMessage($level, null, ${charSequenceExprToStringExpr(message)}, $throwable) }
+ else if(anyRefArgs.length == 1)
+ '{ if ($underlying.delegate.isEnabled($level)) $underlying.delegate.log($level, ${charSequenceExprToStringExpr(message)}, ${anyRefArgs.head}, $throwable) }
+ else {
+ val extendedArgs = anyRefArgs :+ throwable
+ '{ if ($underlying.delegate.isEnabled($level)) $underlying.delegate.log($level, ${charSequenceExprToStringExpr(message)}, ${Expr.ofSeq(extendedArgs)}*) }
+ }
+ }
+
+ private def logMarkerMessageArgs(underlying: Expr[Logger], level: Expr[Level], marker: Expr[Marker], message: Expr[CharSequence],
+ args: Expr[Seq[Any]]) (using Quotes) = {
+ val anyRefArgs = formatArgs(args)
+ if(anyRefArgs.isEmpty)
+ '{ if ($underlying.delegate.isEnabled($level, $marker)) $underlying.logMessage($level, $marker, ${charSequenceExprToStringExpr(message)}, null) }
+ else if(anyRefArgs.length == 1)
+ '{ if ($underlying.delegate.isEnabled($level, $marker)) $underlying.delegate.log($level, $marker, ${charSequenceExprToStringExpr(message)}, ${anyRefArgs.head}) }
+ else
+ '{ if ($underlying.delegate.isEnabled($level, $marker)) $underlying.delegate.log($level, $marker, ${charSequenceExprToStringExpr(message)}, ${Expr.ofSeq(anyRefArgs)}*) }
+ }
+
+ private def logMarkerMessageArgsThrowable(underlying: Expr[Logger], level: Expr[Level], marker: Expr[Marker],
+ message: Expr[CharSequence], args: Expr[Seq[Any]], throwable: Expr[Throwable]) (using Quotes) = {
+ val anyRefArgs = formatArgs(args)
+ if(anyRefArgs.isEmpty)
+ '{ if ($underlying.delegate.isEnabled($level, $marker)) $underlying.logMessage($level, $marker, ${charSequenceExprToStringExpr(message)}, $throwable) }
+ else if(anyRefArgs.length == 1)
+ '{ if ($underlying.delegate.isEnabled($level, $marker)) $underlying.delegate.log($level, $marker, ${charSequenceExprToStringExpr(message)}, ${anyRefArgs.head}, $throwable) }
+ else {
+ val extendedArgs = anyRefArgs :+ throwable
+ '{ if ($underlying.delegate.isEnabled($level, $marker)) $underlying.delegate.log($level, $marker, ${charSequenceExprToStringExpr(message)}, ${Expr.ofSeq(extendedArgs)}*) }
+ }
+ }
+
+ /** Checks whether `message` is an interpolated string and transforms it into LOG4J string interpolation. */
+ private def deconstructInterpolatedMessage(message: Expr[CharSequence])(using Quotes): (Expr[String], Seq[Expr[Any]]) = {
+ import quotes.reflect.*
+ import util.*
+
+ message.asTerm match{
+ case Inlined(_, _, Apply(Select(Apply(Select(Select(_, "StringContext"), _), messageNode), _), argumentsNode)) =>
+ val messageTextPartsOpt: Option[List[String]] =
+ messageNode.collectFirst{
+ case Typed(Repeated(ls, _), _) =>
+ ls.collect{ case Literal(StringConstant(s)) => s}
+ }
+ val argsOpt: Option[List[Term]] =
+ argumentsNode.collectFirst {
+ case Typed(Repeated(ls, _), _) => ls
+ }
+
+ (messageTextPartsOpt, argsOpt) match{
+ case (Some(messageTextParts), Some(args)) =>
+ val format = messageTextParts.iterator
+ // Emulate standard interpolator escaping
+ .map(StringContext.processEscapes)
+ // Escape literal log4j format anchors if the resulting call will require a format string
+ .map(str => if (args.nonEmpty) str.replace("{}", "\\{}") else str)
+ .mkString("{}")
+
+ val formatArgs = args.map(_.asExpr)
+
+ (Expr(format), formatArgs)
+ case _ =>
+ (charSequenceExprToStringExpr(message), Seq.empty)
+ }
+ case _ => (charSequenceExprToStringExpr(message), Seq.empty)
+ }
+ }
+
+ private def formatArgs(args: Expr[Seq[Any]])(using q: Quotes): Seq[Expr[Object]] = {
+ import quotes.reflect.*
+ import util.*
+
+ args.asTerm match {
+ case p@Inlined(_, _, Typed(Repeated(v, _),_)) =>
+ v.map{
+ case t if t.tpe <:< TypeRepr.of[AnyRef] => t.asExprOf[Object]
+ case t => '{${t.asExpr}.asInstanceOf[Object]}
+ }
+ case Repeated(v, _) =>
+ v.map{
+ case t if t.tpe <:< TypeRepr.of[Object] => t.asExprOf[Object]
+ case t => '{${t.asExpr}.asInstanceOf[Object]}
+ }
+ case _ => Seq.empty
+ }
+ }
+
+ private def charSequenceExprToStringExpr(expr: Expr[CharSequence])(using Quotes): Expr[String] = expr match {
+ case '{ $cs } => Expr(cs.toString)
+ }
+}
diff --git a/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/Logging.scala b/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
new file mode 120000
index 0000000..f8b0826
--- /dev/null
+++ b/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
\ No newline at end of file
diff --git a/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala b/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
new file mode 120000
index 0000000..d495205
--- /dev/null
+++ b/log4j-api-scala_3/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.13/src/main/scala/org/apache/logging/log4j/scala/LoggingContext.scala
\ No newline at end of file
diff --git a/log4j-api-scala_3/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_3/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
new file mode 100644
index 0000000..b1ffb61
--- /dev/null
+++ b/log4j-api-scala_3/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
@@ -0,0 +1,555 @@
+/*
+ * 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.*
+import org.apache.logging.log4j.spi.{AbstractLogger, ExtendedLogger}
+import org.apache.logging.log4j.{Level, Marker, MarkerManager}
+import org.junit.runner.RunWith
+import org.mockito.ArgumentMatchers.{any, anyString, eq as eqv}
+import org.mockito.Mockito.*
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatestplus.junit.JUnitRunner
+import org.scalatestplus.mockito.MockitoSugar
+
+case class Custom(i: Int)
+
+trait Manager {
+ def fetchValue(): Int
+}
+
+case class TestFixture(mockLogger: ExtendedLogger, manager: Manager)
+
+@RunWith(classOf[JUnitRunner])
+class LoggerTest extends AnyFunSuite with MockitoSugar {
+
+ val msg = new ParameterizedMessage("msg {}", 17)
+ val entryMsg: EntryMessage = new DefaultFlowMessageFactory().newEntryMessage(msg)
+ val cseqMsg : CharSequence = new StringBuilder().append("cseq msg")
+ val objectMsg = Custom(17)
+ val cause = new RuntimeException("cause")
+ val marker : Marker = MarkerManager.getMarker("marker")
+ val result = "foo"
+
+ def fixture: TestFixture = {
+ 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
+ }
+ TestFixture(mockLogger, manager)
+ }
+
+ 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).log(eqv(Level.FATAL), any[String], any[String])
+ 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).log(any[Level], any[String], any[String])
+ 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).log(eqv(Level.ERROR), any[String], any[String])
+ 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).log(any[Level], any[String], any[String])
+ 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).log(eqv(Level.WARN), any[String], any[String])
+ 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).log(any[Level], any[String], any[String])
+ 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).log(eqv(Level.INFO), any[String], any[String])
+ 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).log(any[Level], any[String], any[String])
+ 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).log(eqv(Level.DEBUG), any[String], any[String])
+ 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).log(any[Level], any[String], any[String])
+ 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).log(eqv(Level.TRACE), any[String], any[String])
+ 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).log(any[Level], any[String], any[String])
+ 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).log(eqv(Level.INFO), eqv(marker), eqv(msg))
+ }
+
+ 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).log(any[Level], any[Marker], any[Message])
+ }
+
+ 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).log(eqv(Level.INFO), eqv(marker), any[String], eqv(4711))
+ 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).log(any[Level], any[Marker], any[String], any[Object])
+ 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(eqv(Logger.FQCN), 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(any[String], 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).log(eqv(Level.INFO), eqv(marker), eqv(objectMsg))
+ }
+
+ 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).log(any[Level], any[Marker], any[Object], 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).log(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).log(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).log(eqv(Level.INFO), eqv(marker), any[String], eqv(4711), 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).log(any[Level], any[Marker], any[String], any[Object], 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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).log(eqv(Level.INFO), eqv(marker), eqv(objectMsg), 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).log(any[Level], any[Marker], any[Object], 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).log(eqv(Level.INFO), eqv(msg))
+ }
+
+ 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).log(any[Level], any[Message])
+ }
+
+ 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).log(eqv(Level.INFO), any[String], eqv(4711))
+ 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).log(any[Level], any[String], any[Object])
+ 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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).log(eqv(Level.INFO), any[Object])
+ }
+
+ 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).log(any[Level], any[Object], 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).log(eqv(Level.INFO), 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).log(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).log(eqv(Level.INFO), any[String], eqv(4711), 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).log(any[Level], any[String], any[Object], 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(eqv(Logger.FQCN), 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(eqv(Logger.FQCN), 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).log(eqv(Level.INFO), eqv(objectMsg), 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).log(any[Level], any[Object], 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("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")
+ //traceEntry is now passes through to the underlying logger without checking if logging is enabled (the delegate checks anyway)
+ verify(f.mockLogger).traceEntry("foo", "bar")
+ }
+
+ 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)
+ //traceEntry is now passes through to the underlying logger without checking if logging is enabled (the delegate checks anyway)
+ verify(f.mockLogger).traceEntry(eqv(msg))
+ }
+
+ 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)
+ //traceExit is now passes through to the underlying logger without checking if logging is enabled (the delegate checks anyway)
+ verify(f.mockLogger).traceExit(eqv(msg), eqv(result))
+ }
+
+ 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))
+ }
+
+}
diff --git a/log4j-api-scala_3/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala b/log4j-api-scala_3/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
new file mode 120000
index 0000000..1fb174b
--- /dev/null
+++ b/log4j-api-scala_3/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
@@ -0,0 +1 @@
+../../../../../../../../../log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala
\ No newline at end of file
diff --git a/mvnw b/mvnw
new file mode 100755
index 0000000..af46563
--- /dev/null
+++ b/mvnw
@@ -0,0 +1,311 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# 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.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version 3.2.0
+#
+# Required ENV vars:
+# ------------------
+# JAVA_HOME - location of a JDK home dir
+#
+# Optional ENV vars
+# -----------------
+# MAVEN_OPTS - parameters passed to the Java VM when running Maven
+# e.g. to debug Maven itself, use
+# set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+# MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+# ----------------------------------------------------------------------------
+
+if [ -z "$MAVEN_SKIP_RC" ] ; then
+
+ if [ -f /usr/local/etc/mavenrc ] ; then
+ . /usr/local/etc/mavenrc
+ fi
+
+ if [ -f /etc/mavenrc ] ; then
+ . /etc/mavenrc
+ fi
+
+ if [ -f "$HOME/.mavenrc" ] ; then
+ . "$HOME/.mavenrc"
+ fi
+
+fi
+
+# OS specific support. $var _must_ be set to either true or false.
+cygwin=false;
+darwin=false;
+mingw=false
+case "$(uname)" in
+ CYGWIN*) cygwin=true ;;
+ MINGW*) mingw=true;;
+ Darwin*) darwin=true
+ # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+ # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+ if [ -z "$JAVA_HOME" ]; then
+ if [ -x "/usr/libexec/java_home" ]; then
+ JAVA_HOME="$(/usr/libexec/java_home)"; export JAVA_HOME
+ else
+ JAVA_HOME="/Library/Java/Home"; export JAVA_HOME
+ fi
+ fi
+ ;;
+esac
+
+if [ -z "$JAVA_HOME" ] ; then
+ if [ -r /etc/gentoo-release ] ; then
+ JAVA_HOME=$(java-config --jre-home)
+ fi
+fi
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched
+if $cygwin ; then
+ [ -n "$JAVA_HOME" ] &&
+ JAVA_HOME=$(cygpath --unix "$JAVA_HOME")
+ [ -n "$CLASSPATH" ] &&
+ CLASSPATH=$(cygpath --path --unix "$CLASSPATH")
+fi
+
+# For Mingw, ensure paths are in UNIX format before anything is touched
+if $mingw ; then
+ [ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] &&
+ JAVA_HOME="$(cd "$JAVA_HOME" || (echo "cannot cd into $JAVA_HOME."; exit 1); pwd)"
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+ javaExecutable="$(which javac)"
+ if [ -n "$javaExecutable" ] && ! [ "$(expr "\"$javaExecutable\"" : '\([^ ]*\)')" = "no" ]; then
+ # readlink(1) is not available as standard on Solaris 10.
+ readLink=$(which readlink)
+ if [ ! "$(expr "$readLink" : '\([^ ]*\)')" = "no" ]; then
+ if $darwin ; then
+ javaHome="$(dirname "\"$javaExecutable\"")"
+ javaExecutable="$(cd "\"$javaHome\"" && pwd -P)/javac"
+ else
+ javaExecutable="$(readlink -f "\"$javaExecutable\"")"
+ fi
+ javaHome="$(dirname "\"$javaExecutable\"")"
+ javaHome=$(expr "$javaHome" : '\(.*\)/bin')
+ JAVA_HOME="$javaHome"
+ export JAVA_HOME
+ fi
+ fi
+fi
+
+if [ -z "$JAVACMD" ] ; then
+ if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ else
+ JAVACMD="$(\unset -f command 2>/dev/null; \command -v java)"
+ fi
+fi
+
+if [ ! -x "$JAVACMD" ] ; then
+ echo "Error: JAVA_HOME is not defined correctly." >&2
+ echo " We cannot execute $JAVACMD" >&2
+ exit 1
+fi
+
+if [ -z "$JAVA_HOME" ] ; then
+ echo "Warning: JAVA_HOME environment variable is not set."
+fi
+
+# traverses directory structure from process work directory to filesystem root
+# first directory with .mvn subdirectory is considered project base directory
+find_maven_basedir() {
+ if [ -z "$1" ]
+ then
+ echo "Path not specified to find_maven_basedir"
+ return 1
+ fi
+
+ basedir="$1"
+ wdir="$1"
+ while [ "$wdir" != '/' ] ; do
+ if [ -d "$wdir"/.mvn ] ; then
+ basedir=$wdir
+ break
+ fi
+ # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+ if [ -d "${wdir}" ]; then
+ wdir=$(cd "$wdir/.." || exit 1; pwd)
+ fi
+ # end of workaround
+ done
+ printf '%s' "$(cd "$basedir" || exit 1; pwd)"
+}
+
+# concatenates all lines of a file
+concat_lines() {
+ if [ -f "$1" ]; then
+ # Remove \r in case we run on Windows within Git Bash
+ # and check out the repository with auto CRLF management
+ # enabled. Otherwise, we may read lines that are delimited with
+ # \r\n and produce $'-Xarg\r' rather than -Xarg due to word
+ # splitting rules.
+ tr -s '\r\n' ' ' < "$1"
+ fi
+}
+
+log() {
+ if [ "$MVNW_VERBOSE" = true ]; then
+ printf '%s\n' "$1"
+ fi
+}
+
+BASE_DIR=$(find_maven_basedir "$(dirname "$0")")
+if [ -z "$BASE_DIR" ]; then
+ exit 1;
+fi
+
+MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}; export MAVEN_PROJECTBASEDIR
+log "$MAVEN_PROJECTBASEDIR"
+
+##########################################################################################
+# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+# This allows using the maven wrapper in projects that prohibit checking in binary data.
+##########################################################################################
+wrapperJarPath="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar"
+if [ -r "$wrapperJarPath" ]; then
+ log "Found $wrapperJarPath"
+else
+ log "Couldn't find $wrapperJarPath, downloading it ..."
+
+ if [ -n "$MVNW_REPOURL" ]; then
+ wrapperUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
+ else
+ wrapperUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
+ fi
+ while IFS="=" read -r key value; do
+ # Remove '\r' from value to allow usage on windows as IFS does not consider '\r' as a separator ( considers space, tab, new line ('\n'), and custom '=' )
+ safeValue=$(echo "$value" | tr -d '\r')
+ case "$key" in (wrapperUrl) wrapperUrl="$safeValue"; break ;;
+ esac
+ done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
+ log "Downloading from: $wrapperUrl"
+
+ if $cygwin; then
+ wrapperJarPath=$(cygpath --path --windows "$wrapperJarPath")
+ fi
+
+ if command -v wget > /dev/null; then
+ log "Found wget ... using wget"
+ [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--quiet"
+ if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+ wget $QUIET "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+ else
+ wget $QUIET --http-user="$MVNW_USERNAME" --http-password="$MVNW_PASSWORD" "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+ fi
+ elif command -v curl > /dev/null; then
+ log "Found curl ... using curl"
+ [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--silent"
+ if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+ curl $QUIET -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
+ else
+ curl $QUIET --user "$MVNW_USERNAME:$MVNW_PASSWORD" -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
+ fi
+ else
+ log "Falling back to using Java to download"
+ javaSource="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.java"
+ javaClass="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.class"
+ # For Cygwin, switch paths to Windows format before running javac
+ if $cygwin; then
+ javaSource=$(cygpath --path --windows "$javaSource")
+ javaClass=$(cygpath --path --windows "$javaClass")
+ fi
+ if [ -e "$javaSource" ]; then
+ if [ ! -e "$javaClass" ]; then
+ log " - Compiling MavenWrapperDownloader.java ..."
+ ("$JAVA_HOME/bin/javac" "$javaSource")
+ fi
+ if [ -e "$javaClass" ]; then
+ log " - Running MavenWrapperDownloader.java ..."
+ ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$wrapperUrl" "$wrapperJarPath") || rm -f "$wrapperJarPath"
+ fi
+ fi
+ fi
+fi
+##########################################################################################
+# End of extension
+##########################################################################################
+
+# If specified, validate the SHA-256 sum of the Maven wrapper jar file
+wrapperSha256Sum=""
+while IFS="=" read -r key value; do
+ case "$key" in (wrapperSha256Sum) wrapperSha256Sum=$value; break ;;
+ esac
+done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
+if [ -n "$wrapperSha256Sum" ]; then
+ wrapperSha256Result=false
+ if command -v sha256sum > /dev/null; then
+ if echo "$wrapperSha256Sum $wrapperJarPath" | sha256sum -c > /dev/null 2>&1; then
+ wrapperSha256Result=true
+ fi
+ elif command -v shasum > /dev/null; then
+ if echo "$wrapperSha256Sum $wrapperJarPath" | shasum -a 256 -c > /dev/null 2>&1; then
+ wrapperSha256Result=true
+ fi
+ else
+ echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available."
+ echo "Please install either command, or disable validation by removing 'wrapperSha256Sum' from your maven-wrapper.properties."
+ exit 1
+ fi
+ if [ $wrapperSha256Result = false ]; then
+ echo "Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised." >&2
+ echo "Investigate or delete $wrapperJarPath to attempt a clean download." >&2
+ echo "If you updated your Maven version, you need to update the specified wrapperSha256Sum property." >&2
+ exit 1
+ fi
+fi
+
+MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin; then
+ [ -n "$JAVA_HOME" ] &&
+ JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME")
+ [ -n "$CLASSPATH" ] &&
+ CLASSPATH=$(cygpath --path --windows "$CLASSPATH")
+ [ -n "$MAVEN_PROJECTBASEDIR" ] &&
+ MAVEN_PROJECTBASEDIR=$(cygpath --path --windows "$MAVEN_PROJECTBASEDIR")
+fi
+
+# Provide a "standardized" way to retrieve the CLI args that will
+# work with both Windows and non-Windows executions.
+MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $*"
+export MAVEN_CMD_LINE_ARGS
+
+WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+LINE_SEPARATOR="
+"
+
+# shellcheck disable=SC2086 # safe args
+exec "$JAVACMD" \
+ $MAVEN_OPTS \
+ $MAVEN_DEBUG_OPTS \
+ "-Dline.separator=$LINE_SEPARATOR" \
+ -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+ "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+ ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"
diff --git a/mvnw.cmd b/mvnw.cmd
new file mode 100644
index 0000000..3cb089f
--- /dev/null
+++ b/mvnw.cmd
@@ -0,0 +1,212 @@
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements. See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership. The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License. You may obtain a copy of the License at
+@REM
+@REM http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied. See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.2.0
+@REM
+@REM Required ENV vars:
+@REM JAVA_HOME - location of a JDK home dir
+@REM
+@REM Optional ENV vars
+@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
+@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM e.g. to debug Maven itself, use
+@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM ----------------------------------------------------------------------------
+
+@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@echo off
+@REM set title of command window
+title %0
+@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@if "%MAVEN_BATCH_ECHO%" == "on" echo %MAVEN_BATCH_ECHO%
+
+@REM set %HOME% to equivalent of $HOME
+if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+
+@REM Execute a user defined script before this one
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
+if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
+:skipRcPre
+
+@setlocal
+
+set ERROR_CODE=0
+
+@REM To isolate internal variables from possible post scripts, we use another setlocal
+@setlocal
+
+@REM ==== START VALIDATION ====
+if not "%JAVA_HOME%" == "" goto OkJHome
+
+echo.
+echo Error: JAVA_HOME not found in your environment. >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+:OkJHome
+if exist "%JAVA_HOME%\bin\java.exe" goto init
+
+echo.
+echo Error: JAVA_HOME is set to an invalid directory. >&2
+echo JAVA_HOME = "%JAVA_HOME%" >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+@REM ==== END VALIDATION ====
+
+:init
+
+@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM Fallback to current working directory if not found.
+
+set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+
+set EXEC_DIR=%CD%
+set WDIR=%EXEC_DIR%
+:findBaseDir
+IF EXIST "%WDIR%"\.mvn goto baseDirFound
+cd ..
+IF "%WDIR%"=="%CD%" goto baseDirNotFound
+set WDIR=%CD%
+goto findBaseDir
+
+:baseDirFound
+set MAVEN_PROJECTBASEDIR=%WDIR%
+cd "%EXEC_DIR%"
+goto endDetectBaseDir
+
+:baseDirNotFound
+set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+cd "%EXEC_DIR%"
+
+:endDetectBaseDir
+
+IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+
+@setlocal EnableExtensions EnableDelayedExpansion
+for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+
+:endReadAdditionalConfig
+
+SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
+
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+ IF "%%A"=="wrapperUrl" SET WRAPPER_URL=%%B
+)
+
+@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
+if exist %WRAPPER_JAR% (
+ if "%MVNW_VERBOSE%" == "true" (
+ echo Found %WRAPPER_JAR%
+ )
+) else (
+ if not "%MVNW_REPOURL%" == "" (
+ SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
+ )
+ if "%MVNW_VERBOSE%" == "true" (
+ echo Couldn't find %WRAPPER_JAR%, downloading it ...
+ echo Downloading from: %WRAPPER_URL%
+ )
+
+ powershell -Command "&{"^
+ "$webclient = new-object System.Net.WebClient;"^
+ "if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
+ "$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
+ "}"^
+ "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%WRAPPER_URL%', '%WRAPPER_JAR%')"^
+ "}"
+ if "%MVNW_VERBOSE%" == "true" (
+ echo Finished downloading %WRAPPER_JAR%
+ )
+)
+@REM End of extension
+
+@REM If specified, validate the SHA-256 sum of the Maven wrapper jar file
+SET WRAPPER_SHA_256_SUM=""
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+ IF "%%A"=="wrapperSha256Sum" SET WRAPPER_SHA_256_SUM=%%B
+)
+IF NOT %WRAPPER_SHA_256_SUM%=="" (
+ powershell -Command "&{"^
+ "$hash = (Get-FileHash \"%WRAPPER_JAR%\" -Algorithm SHA256).Hash.ToLower();"^
+ "If('%WRAPPER_SHA_256_SUM%' -ne $hash){"^
+ " Write-Output 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^
+ " Write-Output 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^
+ " Write-Output 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^
+ " exit 1;"^
+ "}"^
+ "}"
+ if ERRORLEVEL 1 goto error
+)
+
+@REM Provide a "standardized" way to retrieve the CLI args that will
+@REM work with both Windows and non-Windows executions.
+set MAVEN_CMD_LINE_ARGS=%*
+@REM Do not remove the blank lines
+(set \n=^^^
+
+^
+
+)
+
+%MAVEN_JAVA_EXE% ^
+ %JVM_CONFIG_MAVEN_PROPS% ^
+ %MAVEN_OPTS% ^
+ %MAVEN_DEBUG_OPTS% ^
+ -Dline.separator=%\n% ^
+ -classpath %WRAPPER_JAR% ^
+ "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
+ %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+if ERRORLEVEL 1 goto error
+goto end
+
+:error
+set ERROR_CODE=1
+
+:end
+@endlocal & set ERROR_CODE=%ERROR_CODE%
+
+if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
+@REM check for post script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
+if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
+:skipRcPost
+
+@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+if "%MAVEN_BATCH_PAUSE%"=="on" pause
+
+if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
+
+cmd /C exit /B %ERROR_CODE%
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..68333ca
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,159 @@
+<?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</groupId>
+ <artifactId>logging-parent</artifactId>
+ <version>10.0.0</version>
+ <relativePath/>
+ </parent>
+
+ <artifactId>log4j-api-scala-parent</artifactId>
+ <version>${revision}</version>
+ <packaging>pom</packaging>
+
+ <modules>
+ <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_3</module>
+ </modules>
+
+ <properties>
+
+ <!-- project version -->
+ <revision>13.0.0-SNAPSHOT</revision>
+
+ <!-- javac version (should work with the minimum `scala.version`!) -->
+ <minimalJavaBuildVersion>[1.8,1.9)</minimalJavaBuildVersion>
+
+ <!-- scala version (to be overridden by modules!) -->
+ <scala.version.group>2.10</scala.version.group>
+ <scala.version>${scala.version.group}.7</scala.version>
+
+ <!-- disable `maven-site-plugin`-->
+ <maven.site.skip>true</maven.site.skip>
+ <maven.site.deploy.skip>true</maven.site.deploy.skip>
+
+ <!-- dependency version -->
+ <junit.version>4.13.2</junit.version>
+ <log4j.version>2.20.0</log4j.version>
+ <mockito.version>4.11.0</mockito.version>
+ <scalatest.version>3.2.10</scalatest.version>
+ <scalatestplus.version>3.2.10.0</scalatestplus.version>
+
+ <!-- plugin versions -->
+ <scala-maven-plugin.version>4.8.1</scala-maven-plugin.version>
+
+ </properties>
+
+ <dependencyManagement>
+ <dependencies>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-bom</artifactId>
+ <version>${log4j.version}</version>
+ <scope>import</scope>
+ <type>pom</type>
+ </dependency>
+
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>${junit.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <version>${mockito.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest_${scala.version.group}</artifactId>
+ <version>${scalatest.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-funsuite_${scala.version.group}</artifactId>
+ <version>${scalatest.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatest</groupId>
+ <artifactId>scalatest-matchers-core_${scala.version.group}</artifactId>
+ <version>${scalatest.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>junit-4-13_${scala.version.group}</artifactId>
+ <version>${scalatestplus.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.scalatestplus</groupId>
+ <artifactId>mockito-3-12_${scala.version.group}</artifactId>
+ <version>${scalatestplus.version}</version>
+ </dependency>
+
+ </dependencies>
+ </dependencyManagement>
+
+ <build>
+
+ <sourceDirectory>src/main/scala</sourceDirectory>
+
+ <testSourceDirectory>src/test/scala</testSourceDirectory>
+
+ <pluginManagement>
+ <plugins>
+
+ <plugin>
+ <groupId>net.alchim31.maven</groupId>
+ <artifactId>scala-maven-plugin</artifactId>
+ <version>${scala-maven-plugin.version}</version>
+ <executions>
+ <execution>
+ <id>scala-${scala.version.group}</id>
+ <goals>
+ <goal>compile</goal>
+ <goal>testCompile</goal>
+ </goals>
+ <configuration>
+ <scalaVersion>${scala.version}</scalaVersion>
+ <!-- disabling zinc, since it is causing compilation failures -->
+ <recompileMode>all</recompileMode>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+
+ </plugins>
+ </pluginManagement>
+
+ </build>
+
+</project>
[logging-log4j-scala] 01/04: Add sbt wrapper
Posted by vy...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
vy pushed a commit to branch facelift
in repository https://gitbox.apache.org/repos/asf/logging-log4j-scala.git
commit 39ac9ab949dc883125508df44649f5e8bab1eb4e
Author: Volkan Yazıcı <vo...@yazi.ci>
AuthorDate: Fri Sep 15 08:57:02 2023 +0200
Add sbt wrapper
---
sbt | 664 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 664 insertions(+)
diff --git a/sbt b/sbt
new file mode 100755
index 0000000..631f707
--- /dev/null
+++ b/sbt
@@ -0,0 +1,664 @@
+#!/usr/bin/env bash
+#
+# A more capable sbt runner, coincidentally also called sbt.
+# Author: Paul Phillips <pa...@improving.org>
+# https://github.com/paulp/sbt-extras
+#
+# Generated from http://www.opensource.org/licenses/bsd-license.php
+# Copyright (c) 2011, Paul Phillips. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+# * Neither the name of the author nor the names of its contributors
+# may be used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+set -o pipefail
+
+declare -r sbt_release_version="1.9.5"
+declare -r sbt_unreleased_version="1.9.5"
+
+declare -r latest_213="2.13.12"
+declare -r latest_212="2.12.18"
+declare -r latest_211="2.11.12"
+declare -r latest_210="2.10.7"
+declare -r latest_29="2.9.3"
+declare -r latest_28="2.8.2"
+
+declare -r buildProps="project/build.properties"
+
+declare -r sbt_launch_ivy_release_repo="https://repo.typesafe.com/typesafe/ivy-releases"
+declare -r sbt_launch_ivy_snapshot_repo="https://repo.scala-sbt.org/scalasbt/ivy-snapshots"
+declare -r sbt_launch_mvn_release_repo="https://repo1.maven.org/maven2"
+declare -r sbt_launch_mvn_snapshot_repo="https://repo.scala-sbt.org/scalasbt/maven-snapshots"
+
+declare -r default_jvm_opts_common="-Xms512m -Xss2m -XX:MaxInlineLevel=18"
+declare -r noshare_opts="-Dsbt.global.base=project/.sbtboot -Dsbt.boot.directory=project/.boot -Dsbt.ivy.home=project/.ivy -Dsbt.coursier.home=project/.coursier"
+
+declare sbt_jar sbt_dir sbt_create sbt_version sbt_script sbt_new
+declare sbt_explicit_version
+declare verbose noshare batch trace_level
+
+declare java_cmd="java"
+declare sbt_launch_dir="$HOME/.sbt/launchers"
+declare sbt_launch_repo
+
+# pull -J and -D options to give to java.
+declare -a java_args scalac_args sbt_commands residual_args
+
+# args to jvm/sbt via files or environment variables
+declare -a extra_jvm_opts extra_sbt_opts
+
+echoerr() { echo >&2 "$@"; }
+vlog() { [[ -n "$verbose" ]] && echoerr "$@"; }
+die() {
+ echo "Aborting: $*"
+ exit 1
+}
+
+setTrapExit() {
+ # save stty and trap exit, to ensure echo is re-enabled if we are interrupted.
+ SBT_STTY="$(stty -g 2>/dev/null)"
+ export SBT_STTY
+
+ # restore stty settings (echo in particular)
+ onSbtRunnerExit() {
+ [ -t 0 ] || return
+ vlog ""
+ vlog "restoring stty: $SBT_STTY"
+ stty "$SBT_STTY"
+ }
+
+ vlog "saving stty: $SBT_STTY"
+ trap onSbtRunnerExit EXIT
+}
+
+# this seems to cover the bases on OSX, and someone will
+# have to tell me about the others.
+get_script_path() {
+ local path="$1"
+ [[ -L "$path" ]] || {
+ echo "$path"
+ return
+ }
+
+ local -r target="$(readlink "$path")"
+ if [[ "${target:0:1}" == "/" ]]; then
+ echo "$target"
+ else
+ echo "${path%/*}/$target"
+ fi
+}
+
+script_path="$(get_script_path "${BASH_SOURCE[0]}")"
+declare -r script_path
+script_name="${script_path##*/}"
+declare -r script_name
+
+init_default_option_file() {
+ local overriding_var="${!1}"
+ local default_file="$2"
+ if [[ ! -r "$default_file" && "$overriding_var" =~ ^@(.*)$ ]]; then
+ local envvar_file="${BASH_REMATCH[1]}"
+ if [[ -r "$envvar_file" ]]; then
+ default_file="$envvar_file"
+ fi
+ fi
+ echo "$default_file"
+}
+
+sbt_opts_file="$(init_default_option_file SBT_OPTS .sbtopts)"
+sbtx_opts_file="$(init_default_option_file SBTX_OPTS .sbtxopts)"
+jvm_opts_file="$(init_default_option_file JVM_OPTS .jvmopts)"
+
+build_props_sbt() {
+ [[ -r "$buildProps" ]] &&
+ grep '^sbt\.version' "$buildProps" | tr '=\r' ' ' | awk '{ print $2; }'
+}
+
+set_sbt_version() {
+ sbt_version="${sbt_explicit_version:-$(build_props_sbt)}"
+ [[ -n "$sbt_version" ]] || sbt_version=$sbt_release_version
+ export sbt_version
+}
+
+url_base() {
+ local version="$1"
+
+ case "$version" in
+ 0.7.*) echo "https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/simple-build-tool" ;;
+ 0.10.*) echo "$sbt_launch_ivy_release_repo" ;;
+ 0.11.[12]) echo "$sbt_launch_ivy_release_repo" ;;
+ 0.*-[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9][0-9][0-9]) # ie "*-yyyymmdd-hhMMss"
+ echo "$sbt_launch_ivy_snapshot_repo" ;;
+ 0.*) echo "$sbt_launch_ivy_release_repo" ;;
+ *-[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]T[0-9][0-9][0-9][0-9][0-9][0-9]) # ie "*-yyyymmddThhMMss"
+ echo "$sbt_launch_mvn_snapshot_repo" ;;
+ *) echo "$sbt_launch_mvn_release_repo" ;;
+ esac
+}
+
+make_url() {
+ local version="$1"
+
+ local base="${sbt_launch_repo:-$(url_base "$version")}"
+
+ case "$version" in
+ 0.7.*) echo "$base/sbt-launch-0.7.7.jar" ;;
+ 0.10.*) echo "$base/org.scala-tools.sbt/sbt-launch/$version/sbt-launch.jar" ;;
+ 0.11.[12]) echo "$base/org.scala-tools.sbt/sbt-launch/$version/sbt-launch.jar" ;;
+ 0.*) echo "$base/org.scala-sbt/sbt-launch/$version/sbt-launch.jar" ;;
+ *) echo "$base/org/scala-sbt/sbt-launch/$version/sbt-launch-${version}.jar" ;;
+ esac
+}
+
+addJava() {
+ vlog "[addJava] arg = '$1'"
+ java_args+=("$1")
+}
+addSbt() {
+ vlog "[addSbt] arg = '$1'"
+ sbt_commands+=("$1")
+}
+addScalac() {
+ vlog "[addScalac] arg = '$1'"
+ scalac_args+=("$1")
+}
+addResidual() {
+ vlog "[residual] arg = '$1'"
+ residual_args+=("$1")
+}
+
+addResolver() { addSbt "set resolvers += $1"; }
+
+addDebugger() { addJava "-Xdebug" && addJava "-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=$1"; }
+
+setThisBuild() {
+ vlog "[addBuild] args = '$*'"
+ local key="$1" && shift
+ addSbt "set $key in ThisBuild := $*"
+}
+setScalaVersion() {
+ [[ "$1" == *"-SNAPSHOT" ]] && addResolver 'Resolver.sonatypeRepo("snapshots")'
+ addSbt "++ $1"
+}
+setJavaHome() {
+ java_cmd="$1/bin/java"
+ setThisBuild javaHome "_root_.scala.Some(file(\"$1\"))"
+ export JAVA_HOME="$1"
+ export JDK_HOME="$1"
+ export PATH="$JAVA_HOME/bin:$PATH"
+}
+
+getJavaVersion() {
+ local -r str=$("$1" -version 2>&1 | grep -E -e '(java|openjdk) version' | awk '{ print $3 }' | tr -d '"')
+
+ # java -version on java8 says 1.8.x
+ # but on 9 and 10 it's 9.x.y and 10.x.y.
+ if [[ "$str" =~ ^1\.([0-9]+)(\..*)?$ ]]; then
+ echo "${BASH_REMATCH[1]}"
+ # Fixes https://github.com/dwijnand/sbt-extras/issues/326
+ elif [[ "$str" =~ ^([0-9]+)(\..*)?(-ea)?$ ]]; then
+ echo "${BASH_REMATCH[1]}"
+ elif [[ -n "$str" ]]; then
+ echoerr "Can't parse java version from: $str"
+ fi
+}
+
+checkJava() {
+ # Warn if there is a Java version mismatch between PATH and JAVA_HOME/JDK_HOME
+
+ [[ -n "$JAVA_HOME" && -e "$JAVA_HOME/bin/java" ]] && java="$JAVA_HOME/bin/java"
+ [[ -n "$JDK_HOME" && -e "$JDK_HOME/lib/tools.jar" ]] && java="$JDK_HOME/bin/java"
+
+ if [[ -n "$java" ]]; then
+ pathJavaVersion=$(getJavaVersion java)
+ homeJavaVersion=$(getJavaVersion "$java")
+ if [[ "$pathJavaVersion" != "$homeJavaVersion" ]]; then
+ echoerr "Warning: Java version mismatch between PATH and JAVA_HOME/JDK_HOME, sbt will use the one in PATH"
+ echoerr " Either: fix your PATH, remove JAVA_HOME/JDK_HOME or use -java-home"
+ echoerr " java version from PATH: $pathJavaVersion"
+ echoerr " java version from JAVA_HOME/JDK_HOME: $homeJavaVersion"
+ fi
+ fi
+}
+
+java_version() {
+ local -r version=$(getJavaVersion "$java_cmd")
+ vlog "Detected Java version: $version"
+ echo "$version"
+}
+
+is_apple_silicon() { [[ "$(uname -s)" == "Darwin" && "$(uname -m)" == "arm64" ]]; }
+
+# MaxPermSize critical on pre-8 JVMs but incurs noisy warning on 8+
+default_jvm_opts() {
+ local -r v="$(java_version)"
+ if [[ $v -ge 17 ]]; then
+ echo "$default_jvm_opts_common"
+ elif [[ $v -ge 10 ]]; then
+ if is_apple_silicon; then
+ # As of Dec 2020, JVM for Apple Silicon (M1) doesn't support JVMCI
+ echo "$default_jvm_opts_common"
+ else
+ echo "$default_jvm_opts_common -XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler"
+ fi
+ elif [[ $v -ge 8 ]]; then
+ echo "$default_jvm_opts_common"
+ else
+ echo "-XX:MaxPermSize=384m $default_jvm_opts_common"
+ fi
+}
+
+execRunner() {
+ # print the arguments one to a line, quoting any containing spaces
+ vlog "# Executing command line:" && {
+ for arg; do
+ if [[ -n "$arg" ]]; then
+ if printf "%s\n" "$arg" | grep -q ' '; then
+ printf >&2 "\"%s\"\n" "$arg"
+ else
+ printf >&2 "%s\n" "$arg"
+ fi
+ fi
+ done
+ vlog ""
+ }
+
+ setTrapExit
+
+ if [[ -n "$batch" ]]; then
+ "$@" </dev/null
+ else
+ "$@"
+ fi
+}
+
+jar_url() { make_url "$1"; }
+
+is_cygwin() { [[ "$(uname -a)" == "CYGWIN"* ]]; }
+
+jar_file() {
+ is_cygwin &&
+ cygpath -w "$sbt_launch_dir/$1/sbt-launch.jar" ||
+ echo "$sbt_launch_dir/$1/sbt-launch.jar"
+}
+
+download_url() {
+ local url="$1"
+ local jar="$2"
+
+ mkdir -p "${jar%/*}" && {
+ if command -v curl >/dev/null 2>&1; then
+ curl --fail --silent --location "$url" --output "$jar"
+ elif command -v wget >/dev/null 2>&1; then
+ wget -q -O "$jar" "$url"
+ fi
+ } && [[ -r "$jar" ]]
+}
+
+acquire_sbt_jar() {
+ {
+ sbt_jar="$(jar_file "$sbt_version")"
+ [[ -r "$sbt_jar" ]]
+ } || {
+ sbt_jar="$HOME/.ivy2/local/org.scala-sbt/sbt-launch/$sbt_version/jars/sbt-launch.jar"
+ [[ -r "$sbt_jar" ]]
+ } || {
+ sbt_jar="$(jar_file "$sbt_version")"
+ jar_url="$(make_url "$sbt_version")"
+
+ echoerr "Downloading sbt launcher for ${sbt_version}:"
+ echoerr " From ${jar_url}"
+ echoerr " To ${sbt_jar}"
+
+ download_url "${jar_url}" "${sbt_jar}"
+
+ case "${sbt_version}" in
+ 0.*)
+ vlog "SBT versions < 1.0 do not have published MD5 checksums, skipping check"
+ echo ""
+ ;;
+ *) verify_sbt_jar "${sbt_jar}" ;;
+ esac
+ }
+}
+
+verify_sbt_jar() {
+ local jar="${1}"
+ local md5="${jar}.md5"
+ md5url="$(make_url "${sbt_version}").md5"
+
+ echoerr "Downloading sbt launcher ${sbt_version} md5 hash:"
+ echoerr " From ${md5url}"
+ echoerr " To ${md5}"
+
+ download_url "${md5url}" "${md5}" >/dev/null 2>&1
+
+ if command -v md5sum >/dev/null 2>&1; then
+ if echo "$(cat "${md5}") ${jar}" | md5sum -c -; then
+ rm -rf "${md5}"
+ return 0
+ else
+ echoerr "Checksum does not match"
+ return 1
+ fi
+ elif command -v md5 >/dev/null 2>&1; then
+ if [ "$(md5 -q "${jar}")" == "$(cat "${md5}")" ]; then
+ rm -rf "${md5}"
+ return 0
+ else
+ echoerr "Checksum does not match"
+ return 1
+ fi
+ elif command -v openssl >/dev/null 2>&1; then
+ if [ "$(openssl md5 -r "${jar}" | awk '{print $1}')" == "$(cat "${md5}")" ]; then
+ rm -rf "${md5}"
+ return 0
+ else
+ echoerr "Checksum does not match"
+ return 1
+ fi
+ else
+ echoerr "Could not find an MD5 command"
+ return 1
+ fi
+}
+
+usage() {
+ set_sbt_version
+ cat <<EOM
+Usage: $script_name [options]
+
+Note that options which are passed along to sbt begin with -- whereas
+options to this runner use a single dash. Any sbt command can be scheduled
+to run first by prefixing the command with --, so --warn, --error and so on
+are not special.
+
+ -h | -help print this message
+ -v verbose operation (this runner is chattier)
+ -d, -w, -q aliases for --debug, --warn, --error (q means quiet)
+ -x debug this script
+ -trace <level> display stack traces with a max of <level> frames (default: -1, traces suppressed)
+ -debug-inc enable debugging log for the incremental compiler
+ -no-colors disable ANSI color codes
+ -sbt-create start sbt even if current directory contains no sbt project
+ -sbt-dir <path> path to global settings/plugins directory (default: ~/.sbt/<version>)
+ -sbt-boot <path> path to shared boot directory (default: ~/.sbt/boot in 0.11+)
+ -ivy <path> path to local Ivy repository (default: ~/.ivy2)
+ -no-share use all local caches; no sharing
+ -offline put sbt in offline mode
+ -jvm-debug <port> Turn on JVM debugging, open at the given port.
+ -batch Disable interactive mode
+ -prompt <expr> Set the sbt prompt; in expr, 's' is the State and 'e' is Extracted
+ -script <file> Run the specified file as a scala script
+
+ # sbt version (default: sbt.version from $buildProps if present, otherwise $sbt_release_version)
+ -sbt-version <version> use the specified version of sbt (default: $sbt_release_version)
+ -sbt-force-latest force the use of the latest release of sbt: $sbt_release_version
+ -sbt-dev use the latest pre-release version of sbt: $sbt_unreleased_version
+ -sbt-jar <path> use the specified jar as the sbt launcher
+ -sbt-launch-dir <path> directory to hold sbt launchers (default: $sbt_launch_dir)
+ -sbt-launch-repo <url> repo url for downloading sbt launcher jar (default: $(url_base "$sbt_version"))
+
+ # scala version (default: as chosen by sbt)
+ -28 use $latest_28
+ -29 use $latest_29
+ -210 use $latest_210
+ -211 use $latest_211
+ -212 use $latest_212
+ -213 use $latest_213
+ -scala-home <path> use the scala build at the specified directory
+ -scala-version <version> use the specified version of scala
+ -binary-version <version> use the specified scala version when searching for dependencies
+
+ # java version (default: java from PATH, currently $(java -version 2>&1 | grep version))
+ -java-home <path> alternate JAVA_HOME
+
+ # passing options to the jvm - note it does NOT use JAVA_OPTS due to pollution
+ # The default set is used if JVM_OPTS is unset and no -jvm-opts file is found
+ <default> $(default_jvm_opts)
+ JVM_OPTS environment variable holding either the jvm args directly, or
+ the reference to a file containing jvm args if given path is prepended by '@' (e.g. '@/etc/jvmopts')
+ Note: "@"-file is overridden by local '.jvmopts' or '-jvm-opts' argument.
+ -jvm-opts <path> file containing jvm args (if not given, .jvmopts in project root is used if present)
+ -Dkey=val pass -Dkey=val directly to the jvm
+ -J-X pass option -X directly to the jvm (-J is stripped)
+
+ # passing options to sbt, OR to this runner
+ SBT_OPTS environment variable holding either the sbt args directly, or
+ the reference to a file containing sbt args if given path is prepended by '@' (e.g. '@/etc/sbtopts')
+ Note: "@"-file is overridden by local '.sbtopts' or '-sbt-opts' argument.
+ -sbt-opts <path> file containing sbt args (if not given, .sbtopts in project root is used if present)
+ -S-X add -X to sbt's scalacOptions (-S is stripped)
+
+ # passing options exclusively to this runner
+ SBTX_OPTS environment variable holding either the sbt-extras args directly, or
+ the reference to a file containing sbt-extras args if given path is prepended by '@' (e.g. '@/etc/sbtxopts')
+ Note: "@"-file is overridden by local '.sbtxopts' or '-sbtx-opts' argument.
+ -sbtx-opts <path> file containing sbt-extras args (if not given, .sbtxopts in project root is used if present)
+EOM
+ exit 0
+}
+
+process_args() {
+ require_arg() {
+ local type="$1"
+ local opt="$2"
+ local arg="$3"
+
+ if [[ -z "$arg" ]] || [[ "${arg:0:1}" == "-" ]]; then
+ die "$opt requires <$type> argument"
+ fi
+ }
+ while [[ $# -gt 0 ]]; do
+ case "$1" in
+ -h | -help) usage ;;
+ -v) verbose=true && shift ;;
+ -d) addSbt "--debug" && shift ;;
+ -w) addSbt "--warn" && shift ;;
+ -q) addSbt "--error" && shift ;;
+ -x) shift ;; # currently unused
+ -trace) require_arg integer "$1" "$2" && trace_level="$2" && shift 2 ;;
+ -debug-inc) addJava "-Dxsbt.inc.debug=true" && shift ;;
+
+ -no-colors) addJava "-Dsbt.log.noformat=true" && addJava "-Dsbt.color=false" && shift ;;
+ -sbt-create) sbt_create=true && shift ;;
+ -sbt-dir) require_arg path "$1" "$2" && sbt_dir="$2" && shift 2 ;;
+ -sbt-boot) require_arg path "$1" "$2" && addJava "-Dsbt.boot.directory=$2" && shift 2 ;;
+ -ivy) require_arg path "$1" "$2" && addJava "-Dsbt.ivy.home=$2" && shift 2 ;;
+ -no-share) noshare=true && shift ;;
+ -offline) addSbt "set offline in Global := true" && shift ;;
+ -jvm-debug) require_arg port "$1" "$2" && addDebugger "$2" && shift 2 ;;
+ -batch) batch=true && shift ;;
+ -prompt) require_arg "expr" "$1" "$2" && setThisBuild shellPrompt "(s => { val e = Project.extract(s) ; $2 })" && shift 2 ;;
+ -script) require_arg file "$1" "$2" && sbt_script="$2" && addJava "-Dsbt.main.class=sbt.ScriptMain" && shift 2 ;;
+
+ -sbt-version) require_arg version "$1" "$2" && sbt_explicit_version="$2" && shift 2 ;;
+ -sbt-force-latest) sbt_explicit_version="$sbt_release_version" && shift ;;
+ -sbt-dev) sbt_explicit_version="$sbt_unreleased_version" && shift ;;
+ -sbt-jar) require_arg path "$1" "$2" && sbt_jar="$2" && shift 2 ;;
+ -sbt-launch-dir) require_arg path "$1" "$2" && sbt_launch_dir="$2" && shift 2 ;;
+ -sbt-launch-repo) require_arg path "$1" "$2" && sbt_launch_repo="$2" && shift 2 ;;
+
+ -28) setScalaVersion "$latest_28" && shift ;;
+ -29) setScalaVersion "$latest_29" && shift ;;
+ -210) setScalaVersion "$latest_210" && shift ;;
+ -211) setScalaVersion "$latest_211" && shift ;;
+ -212) setScalaVersion "$latest_212" && shift ;;
+ -213) setScalaVersion "$latest_213" && shift ;;
+
+ -scala-version) require_arg version "$1" "$2" && setScalaVersion "$2" && shift 2 ;;
+ -binary-version) require_arg version "$1" "$2" && setThisBuild scalaBinaryVersion "\"$2\"" && shift 2 ;;
+ -scala-home) require_arg path "$1" "$2" && setThisBuild scalaHome "_root_.scala.Some(file(\"$2\"))" && shift 2 ;;
+ -java-home) require_arg path "$1" "$2" && setJavaHome "$2" && shift 2 ;;
+ -sbt-opts) require_arg path "$1" "$2" && sbt_opts_file="$2" && shift 2 ;;
+ -sbtx-opts) require_arg path "$1" "$2" && sbtx_opts_file="$2" && shift 2 ;;
+ -jvm-opts) require_arg path "$1" "$2" && jvm_opts_file="$2" && shift 2 ;;
+
+ -D*) addJava "$1" && shift ;;
+ -J*) addJava "${1:2}" && shift ;;
+ -S*) addScalac "${1:2}" && shift ;;
+
+ new) sbt_new=true && : ${sbt_explicit_version:=$sbt_release_version} && addResidual "$1" && shift ;;
+
+ *) addResidual "$1" && shift ;;
+ esac
+ done
+}
+
+# process the direct command line arguments
+process_args "$@"
+
+# skip #-styled comments and blank lines
+readConfigFile() {
+ local end=false
+ until $end; do
+ read -r || end=true
+ [[ $REPLY =~ ^# ]] || [[ -z $REPLY ]] || echo "$REPLY"
+ done <"$1"
+}
+
+# if there are file/environment sbt_opts, process again so we
+# can supply args to this runner
+if [[ -r "$sbt_opts_file" ]]; then
+ vlog "Using sbt options defined in file $sbt_opts_file"
+ while read -r opt; do extra_sbt_opts+=("$opt"); done < <(readConfigFile "$sbt_opts_file")
+elif [[ -n "$SBT_OPTS" && ! ("$SBT_OPTS" =~ ^@.*) ]]; then
+ vlog "Using sbt options defined in variable \$SBT_OPTS"
+ IFS=" " read -r -a extra_sbt_opts <<<"$SBT_OPTS"
+else
+ vlog "No extra sbt options have been defined"
+fi
+
+# if there are file/environment sbtx_opts, process again so we
+# can supply args to this runner
+if [[ -r "$sbtx_opts_file" ]]; then
+ vlog "Using sbt options defined in file $sbtx_opts_file"
+ while read -r opt; do extra_sbt_opts+=("$opt"); done < <(readConfigFile "$sbtx_opts_file")
+elif [[ -n "$SBTX_OPTS" && ! ("$SBTX_OPTS" =~ ^@.*) ]]; then
+ vlog "Using sbt options defined in variable \$SBTX_OPTS"
+ IFS=" " read -r -a extra_sbt_opts <<<"$SBTX_OPTS"
+else
+ vlog "No extra sbt options have been defined"
+fi
+
+[[ -n "${extra_sbt_opts[*]}" ]] && process_args "${extra_sbt_opts[@]}"
+
+# reset "$@" to the residual args
+set -- "${residual_args[@]}"
+argumentCount=$#
+
+# set sbt version
+set_sbt_version
+
+checkJava
+
+# only exists in 0.12+
+setTraceLevel() {
+ case "$sbt_version" in
+ "0.7."* | "0.10."* | "0.11."*) echoerr "Cannot set trace level in sbt version $sbt_version" ;;
+ *) setThisBuild traceLevel "$trace_level" ;;
+ esac
+}
+
+# set scalacOptions if we were given any -S opts
+[[ ${#scalac_args[@]} -eq 0 ]] || addSbt "set scalacOptions in ThisBuild += \"${scalac_args[*]}\""
+
+[[ -n "$sbt_explicit_version" && -z "$sbt_new" ]] && addJava "-Dsbt.version=$sbt_explicit_version"
+vlog "Detected sbt version $sbt_version"
+
+if [[ -n "$sbt_script" ]]; then
+ residual_args=("$sbt_script" "${residual_args[@]}")
+else
+ # no args - alert them there's stuff in here
+ ((argumentCount > 0)) || {
+ vlog "Starting $script_name: invoke with -help for other options"
+ residual_args=(shell)
+ }
+fi
+
+# verify this is an sbt dir, -create was given or user attempts to run a scala script
+[[ -r ./build.sbt || -d ./project || -n "$sbt_create" || -n "$sbt_script" || -n "$sbt_new" ]] || {
+ cat <<EOM
+$(pwd) doesn't appear to be an sbt project.
+If you want to start sbt anyway, run:
+ $0 -sbt-create
+
+EOM
+ exit 1
+}
+
+# pick up completion if present; todo
+# shellcheck disable=SC1091
+[[ -r .sbt_completion.sh ]] && source .sbt_completion.sh
+
+# directory to store sbt launchers
+[[ -d "$sbt_launch_dir" ]] || mkdir -p "$sbt_launch_dir"
+[[ -w "$sbt_launch_dir" ]] || sbt_launch_dir="$(mktemp -d -t sbt_extras_launchers.XXXXXX)"
+
+# no jar? download it.
+[[ -r "$sbt_jar" ]] || acquire_sbt_jar || {
+ # still no jar? uh-oh.
+ echo "Could not download and verify the launcher. Obtain the jar manually and place it at $sbt_jar"
+ exit 1
+}
+
+if [[ -n "$noshare" ]]; then
+ for opt in ${noshare_opts}; do
+ addJava "$opt"
+ done
+else
+ case "$sbt_version" in
+ "0.7."* | "0.10."* | "0.11."* | "0.12."*)
+ [[ -n "$sbt_dir" ]] || {
+ sbt_dir="$HOME/.sbt/$sbt_version"
+ vlog "Using $sbt_dir as sbt dir, -sbt-dir to override."
+ }
+ ;;
+ esac
+
+ if [[ -n "$sbt_dir" ]]; then
+ addJava "-Dsbt.global.base=$sbt_dir"
+ fi
+fi
+
+if [[ -r "$jvm_opts_file" ]]; then
+ vlog "Using jvm options defined in file $jvm_opts_file"
+ while read -r opt; do extra_jvm_opts+=("$opt"); done < <(readConfigFile "$jvm_opts_file")
+elif [[ -n "$JVM_OPTS" && ! ("$JVM_OPTS" =~ ^@.*) ]]; then
+ vlog "Using jvm options defined in \$JVM_OPTS variable"
+ IFS=" " read -r -a extra_jvm_opts <<<"$JVM_OPTS"
+else
+ vlog "Using default jvm options"
+ IFS=" " read -r -a extra_jvm_opts <<<"$( default_jvm_opts)"
+fi
+
+# traceLevel is 0.12+
+[[ -n "$trace_level" ]] && setTraceLevel
+
+execRunner "$java_cmd" \
+ "${extra_jvm_opts[@]}" \
+ "${java_args[@]}" \
+ -jar "$sbt_jar" \
+ "${sbt_commands[@]}" \
+ "${residual_args[@]}"
[logging-log4j-scala] 02/04: Switch to semantic versioning: `13.0.0-SNAPSHOT`
Posted by vy...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
vy pushed a commit to branch facelift
in repository https://gitbox.apache.org/repos/asf/logging-log4j-scala.git
commit a5e02d4003ee9794a3d501099a7ef018005d5269
Author: Volkan Yazıcı <vo...@yazi.ci>
AuthorDate: Fri Sep 15 08:57:32 2023 +0200
Switch to semantic versioning: `13.0.0-SNAPSHOT`
---
version.sbt | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/version.sbt b/version.sbt
index 2e486f1..b64de7a 100644
--- a/version.sbt
+++ b/version.sbt
@@ -1 +1 @@
-version in ThisBuild := "12.2-SNAPSHOT"
+ThisBuild / version := "13.0.0-SNAPSHOT"
[logging-log4j-scala] 03/04: Simplify `build.sbt`
Posted by vy...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
vy pushed a commit to branch facelift
in repository https://gitbox.apache.org/repos/asf/logging-log4j-scala.git
commit 86638c3be61f4c6f10f909e2b0d74249ad47496c
Author: Volkan Yazıcı <vo...@yazi.ci>
AuthorDate: Fri Sep 15 08:57:48 2023 +0200
Simplify `build.sbt`
---
build.sbt | 86 ++++++++-------------------------------------------------------
1 file changed, 10 insertions(+), 76 deletions(-)
diff --git a/build.sbt b/build.sbt
index e118595..f73b49b 100644
--- a/build.sbt
+++ b/build.sbt
@@ -23,27 +23,28 @@ lazy val metadataSettings = Seq(
projectInfo := ModuleInfo(
nameFormal = "Apache Log4j Scala API",
description = "Scala logging API facade for Log4j",
- homepage = Some(url("https://logging.apache.org/log4j/scala/")),
+ homepage = Some(url("https://github.com/apache/logging-log4j-scala")),
startYear = Some(2016),
licenses = Vector("Apache License, Version 2.0" -> url("https://www.apache.org/licenses/LICENSE-2.0.txt")),
organizationName = "Apache Software Foundation",
organizationHomepage = Some(url("https://www.apache.org/")),
scmInfo = Some(ScmInfo(
- url("https://gitbox.apache.org/repos/asf?p=logging-log4j-scala.git;a=summary"),
- "scm:git:https://gitbox.apache.org/repos/asf/logging-log4j-scala.git",
- "scm:git:https://gitbox.apache.org/repos/asf/logging-log4j-scala.git"
+ url("https://github.com/apache/logging-log4j-scala.git"),
+ "scm:git:git@github.com:apache/logging-log4j-scala.git",
+ "scm:git:git@github.com:apache/logging-log4j-scala.git"
)),
developers = Vector(
Developer("mikes", "Mikael Ståldal", "mikes@apache.org", null),
Developer("mattsicker", "Matt Sicker", "mattsicker@apache.org", null),
- Developer("ggregory", "Gary Gregory", "ggregory@apache.org", null)
+ Developer("ggregory", "Gary Gregory", "ggregory@apache.org", null),
+ Developer("vy", "Volkan Yazıcı", "vy@apache.org", null)
)
),
pomExtra := {
<parent>
<groupId>org.apache.logging</groupId>
<artifactId>logging-parent</artifactId>
- <version>2</version>
+ <version>10.0.0</version>
</parent>
}
)
@@ -54,29 +55,9 @@ lazy val compileSettings = Seq(
crossScalaVersions := Seq(scala210, scala211, scala212, scala213, scala3)
)
-lazy val publishSettings = Seq(
- publishMavenStyle := true,
- Test / publishArtifact := false,
- publishTo := {
- if (isSnapshot.value) {
- Some("Apache Snapshots" at "https://repository.apache.org/content/repositories/snapshots")
- } else {
- Some("Apache Releases" at "https://repository.apache.org/service/local/staging/deploy/maven2")
- }
- },
- credentials ++= {
- for {
- username <- sys.env.get("NEXUS_USR")
- password <- sys.env.get("NEXUS_PSW")
- } yield Credentials("Sonatype Nexus Repository Manager", "repository.apache.org", username, password)
- }.toList,
- // FIXME: https://github.com/sbt/sbt/issues/3519
- updateOptions := updateOptions.value.withGigahorse(false)
-)
-
lazy val licensePackagingSettings =
for (task <- Seq(packageBin, packageSrc, packageDoc)) yield
- mappings in (Compile, task) ++= Seq(
+ Compile / task / mappings ++= Seq(
(baseDirectory.value / "LICENSE.txt", "META-INF/LICENSE"),
(baseDirectory.value / "NOTICE.txt", "META-INF/NOTICE")
)
@@ -108,6 +89,7 @@ lazy val testSourceSettings = Seq(
CrossVersion.partialVersion(scalaVersion.value) match {
case Some((3, _)) => file(dir.getPath ++ "-3")
case Some((2, _)) => file(dir.getPath ++ "-2")
+ case _ => sys.error(s"unexpected `scalaVersion.value`: ${scalaVersion.value}")
}
}
},
@@ -122,42 +104,6 @@ lazy val testSourceSettings = Seq(
}
)
-lazy val releaseSettings = Seq(
- releaseCrossBuild := true,
- releasePublishArtifactsAction := PgpKeys.publishSigned.value,
- releaseProcess := {
- import ReleaseTransformations._
- Seq(
- checkSnapshotDependencies,
- inquireVersions,
- runClean,
- releaseStepTask(Compile / auditCheck),
- runTest,
- setReleaseVersion,
- commitReleaseVersion,
- tagRelease,
- releaseStepTask(packageSite),
- publishArtifacts,
- setNextVersion,
- commitNextVersion,
- pushChanges
- )
- }
-)
-
-lazy val siteSettings = Seq(
- apiURL := Some(url(s"https://logging.apache.org/log4j/log4j-scala-${version.value}/")),
- SiteScaladoc / siteSubdirName := s"api/${scalaBinaryVersion.value}",
- Asciidoc / managedSources += {
- (Compile / auditReport).value
- (Compile / target).value / "rat.adoc"
- },
- makeSite / mappings ++= Seq(
- (baseDirectory.value / "LICENSE.txt", "LICENSE"),
- (baseDirectory.value / "NOTICE.txt", "NOTICE")
- )
-)
-
lazy val apiDependencies = Seq(
libraryDependencies ++= scalaReflect(scalaVersion.value).toSeq ++ Seq(
osgiCoreApi,
@@ -180,32 +126,20 @@ lazy val bundleSettings = osgiSettings ++ Seq(
lazy val root = (project in file("."))
.settings(name := "log4j-api-scala")
- .enablePlugins(AsciidocPlugin, SiteScaladocPlugin, SbtOsgi, Distributions)
+ .enablePlugins(SbtOsgi)
.settings(metadataSettings: _*)
.settings(compileSettings: _*)
- .settings(publishSettings: _*)
.settings(licensePackagingSettings: _*)
.settings(sourceSettings: _*)
.settings(testSourceSettings: _*)
- .settings(releaseSettings: _*)
- .settings(siteSettings: _*)
.settings(apiDependencies: _*)
.settings(bundleSettings: _*)
-lazy val nopublish = Seq(
- publish := {},
- publishLocal := {},
- publishM2 := {},
- publish / skip := true
-)
-
lazy val sample = (project in file("sample"))
.settings(metadataSettings: _*)
.settings(compileSettings: _*)
- .settings(nopublish: _*)
.settings(
name := "log4j-api-scala-sample",
libraryDependencies := Seq(log4jApi, log4jCore)
)
.dependsOn(root)
-