Rename Scala modules
Project: http://git-wip-us.apache.org/repos/asf/logging-log4j2/repo Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j2/commit/2414d229 Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j2/tree/2414d229 Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j2/diff/2414d229 Branch: refs/heads/LOG4J-1181 Commit: 2414d229c2fe6198a64905c53de7a6f1330b6ff2 Parents: 2618cee Author: Mikael Ståldal <[email protected]> Authored: Mon Nov 2 16:42:28 2015 +0100 Committer: Mikael Ståldal <[email protected]> Committed: Mon Nov 2 16:42:28 2015 +0100 ---------------------------------------------------------------------- log4j-api-scala_2.10/.gitignore | 3 + log4j-api-scala_2.10/pom.xml | 188 +++++++++++++ .../org/apache/logging/log4j/scala/Logger.scala | 252 +++++++++++++++++ .../logging/log4j/scala/LoggerMacro.scala | 230 ++++++++++++++++ .../apache/logging/log4j/scala/Logging.scala | 26 ++ .../apache/logging/log4j/scala/LoggerTest.scala | 267 +++++++++++++++++++ log4j-api-scala_2.11/pom.xml | 188 +++++++++++++ .../org/apache/logging/log4j/scala/Logger.scala | 252 +++++++++++++++++ .../logging/log4j/scala/LoggerMacro.scala | 230 ++++++++++++++++ .../apache/logging/log4j/scala/Logging.scala | 26 ++ .../apache/logging/log4j/scala/LoggerTest.scala | 267 +++++++++++++++++++ log4j-scala_2.10/.gitignore | 3 - log4j-scala_2.10/pom.xml | 188 ------------- .../org/apache/logging/log4j/scala/Logger.scala | 252 ----------------- .../logging/log4j/scala/LoggerMacro.scala | 230 ---------------- .../apache/logging/log4j/scala/Logging.scala | 26 -- .../apache/logging/log4j/scala/LoggerTest.scala | 267 ------------------- log4j-scala_2.11/pom.xml | 188 ------------- .../org/apache/logging/log4j/scala/Logger.scala | 252 ----------------- .../logging/log4j/scala/LoggerMacro.scala | 230 ---------------- .../apache/logging/log4j/scala/Logging.scala | 26 -- .../apache/logging/log4j/scala/LoggerTest.scala | 267 ------------------- pom.xml | 4 +- 23 files changed, 1931 insertions(+), 1931 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.10/.gitignore ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/.gitignore b/log4j-api-scala_2.10/.gitignore new file mode 100644 index 0000000..ddd6d6d --- /dev/null +++ b/log4j-api-scala_2.10/.gitignore @@ -0,0 +1,3 @@ +/.settings/ +/.classpath +/.project http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.10/pom.xml ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/pom.xml b/log4j-api-scala_2.10/pom.xml new file mode 100644 index 0000000..11921cb --- /dev/null +++ b/log4j-api-scala_2.10/pom.xml @@ -0,0 +1,188 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + Licensed to the Apache Software Foundation (ASF) under one or more + contributor license agreements. See the NOTICE file distributed with + this work for additional information regarding copyright ownership. + The ASF licenses this file to You under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with + the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +--> +<project xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"; xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd";> + <modelVersion>4.0.0</modelVersion> + <parent> + <groupId>org.apache.logging.log4j</groupId> + <artifactId>log4j</artifactId> + <version>2.5-SNAPSHOT</version> + <relativePath>../</relativePath> + </parent> + <artifactId>log4j-api-scala_2.10</artifactId> + <packaging>jar</packaging> + <name>Scala warpper for Log4j API</name> + <description>Scala warpper for Log4j API</description> + <properties> + <log4jParentDir>${basedir}/..</log4jParentDir> + <projectDir>/scala_2.10</projectDir> + <scala.version>2.10.6</scala.version> + </properties> + <dependencies> + <dependency> + <groupId>org.apache.logging.log4j</groupId> + <artifactId>log4j-api</artifactId> + </dependency> + <dependency> + <groupId>org.scala-lang</groupId> + <artifactId>scala-library</artifactId> + <version>${scala.version}</version> + </dependency> + <dependency> + <groupId>org.scala-lang</groupId> + <artifactId>scala-reflect</artifactId> + <version>${scala.version}</version> + </dependency> + <dependency> + <groupId>org.apache.logging.log4j</groupId> + <artifactId>log4j-api</artifactId> + <type>test-jar</type> + <scope>test</scope> + </dependency> + <dependency> + <groupId>junit</groupId> + <artifactId>junit</artifactId> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.scalatest</groupId> + <artifactId>scalatest_2.10</artifactId> + <version>2.2.5</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.mockito</groupId> + <artifactId>mockito-core</artifactId> + <version>1.10.19</version> + <scope>test</scope> + </dependency> + </dependencies> + <build> + <sourceDirectory>src/main/scala</sourceDirectory> + <testSourceDirectory>src/test/scala</testSourceDirectory> + <plugins> + <plugin> + <groupId>net.alchim31.maven</groupId> + <artifactId>scala-maven-plugin</artifactId> + <version>3.2.2</version> + <executions> + <execution> + <goals> + <goal>compile</goal> + <goal>testCompile</goal> + </goals> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-surefire-plugin</artifactId> + </plugin> + <!-- Include the standard NOTICE and LICENSE --> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-remote-resources-plugin</artifactId> + <executions> + <execution> + <goals> + <goal>process</goal> + </goals> + <configuration> + <skip>false</skip> + </configuration> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.felix</groupId> + <artifactId>maven-bundle-plugin</artifactId> + </plugin> + </plugins> + </build> + <reporting> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-changes-plugin</artifactId> + <version>${changes.plugin.version}</version> + <reportSets> + <reportSet> + <reports> + <report>changes-report</report> + </reports> + </reportSet> + </reportSets> + <configuration> + <issueLinkTemplate>%URL%/show_bug.cgi?id=%ISSUE%</issueLinkTemplate> + <useJql>true</useJql> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-checkstyle-plugin</artifactId> + <version>${checkstyle.plugin.version}</version> + <configuration> + <!--<propertiesLocation>${vfs.parent.dir}/checkstyle.properties</propertiesLocation> --> + <configLocation>${log4jParentDir}/checkstyle.xml</configLocation> + <suppressionsLocation>${log4jParentDir}/checkstyle-suppressions.xml</suppressionsLocation> + <enableRulesSummary>false</enableRulesSummary> + <propertyExpansion>basedir=${basedir}</propertyExpansion> + <propertyExpansion>licensedir=${log4jParentDir}/checkstyle-header.txt</propertyExpansion> + </configuration> + </plugin> + <plugin> + <groupId>org.codehaus.mojo</groupId> + <artifactId>findbugs-maven-plugin</artifactId> + <version>${findbugs.plugin.version}</version> + <configuration> + <fork>true</fork> + <jvmArgs>-Duser.language=en</jvmArgs> + <threshold>Normal</threshold> + <effort>Default</effort> + <excludeFilterFile>${log4jParentDir}/findbugs-exclude-filter.xml</excludeFilterFile> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-jxr-plugin</artifactId> + <version>${jxr.plugin.version}</version> + <reportSets> + <reportSet> + <id>non-aggregate</id> + <reports> + <report>jxr</report> + </reports> + </reportSet> + <reportSet> + <id>aggregate</id> + <reports> + <report>aggregate</report> + </reports> + </reportSet> + </reportSets> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-pmd-plugin</artifactId> + <version>${pmd.plugin.version}</version> + <configuration> + <targetJdk>${maven.compile.target}</targetJdk> + </configuration> + </plugin> + </plugins> + </reporting> +</project> http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala new file mode 100644 index 0000000..ad35a7a --- /dev/null +++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala @@ -0,0 +1,252 @@ +/* + * 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.{MessageFactory, Message} +import org.apache.logging.log4j.spi.ExtendedLogger +import org.apache.logging.log4j.{Level, Marker} + +import scala.language.experimental.macros + +class Logger(val delegate: ExtendedLogger) { + + private final val FQCN = classOf[Logger].getName + + def fatal(marker: Marker, message: Message): Unit = + macro LoggerMacro.fatalMarkerMsg + + def fatal(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.fatalMarkerMsgThrowable + + def fatal(marker: Marker, message: String): Unit = + macro LoggerMacro.fatalMarkerString + + def fatal(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.fatalMarkerStringThrowable + + def fatal(message: Message): Unit = + macro LoggerMacro.fatalMsg + + def fatal(message: String): Unit = + macro LoggerMacro.fatalString + + def fatal(message: Message, cause: Throwable): Unit = + macro LoggerMacro.fatalMsgThrowable + + def fatal(message: String, cause: Throwable): Unit = + macro LoggerMacro.fatalStringThrowable + + def error(marker: Marker, message: Message): Unit = + macro LoggerMacro.errorMarkerMsg + + def error(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.errorMarkerMsgThrowable + + def error(marker: Marker, message: String): Unit = + macro LoggerMacro.errorMarkerString + + def error(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.errorMarkerStringThrowable + + def error(message: Message): Unit = + macro LoggerMacro.errorMsg + + def error(message: String): Unit = + macro LoggerMacro.errorString + + def error(message: Message, cause: Throwable): Unit = + macro LoggerMacro.errorMsgThrowable + + def error(message: String, cause: Throwable): Unit = + macro LoggerMacro.errorStringThrowable + + def warn(marker: Marker, message: Message): Unit = + macro LoggerMacro.warnMarkerMsg + + def warn(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.warnMarkerMsgThrowable + + def warn(marker: Marker, message: String): Unit = + macro LoggerMacro.warnMarkerString + + def warn(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.warnMarkerStringThrowable + + def warn(message: Message): Unit = + macro LoggerMacro.warnMsg + + def warn(message: String): Unit = + macro LoggerMacro.warnString + + def warn(message: Message, cause: Throwable): Unit = + macro LoggerMacro.warnMsgThrowable + + def warn(message: String, cause: Throwable): Unit = + macro LoggerMacro.warnStringThrowable + + def info(marker: Marker, message: Message): Unit = + macro LoggerMacro.infoMarkerMsg + + def info(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.infoMarkerMsgThrowable + + def info(marker: Marker, message: String): Unit = + macro LoggerMacro.infoMarkerString + + def info(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.infoMarkerStringThrowable + + def info(message: Message): Unit = + macro LoggerMacro.infoMsg + + def info(message: String): Unit = + macro LoggerMacro.infoString + + def info(message: Message, cause: Throwable): Unit = + macro LoggerMacro.infoMsgThrowable + + def info(message: String, cause: Throwable): Unit = + macro LoggerMacro.infoStringThrowable + + def debug(marker: Marker, message: Message): Unit = + macro LoggerMacro.debugMarkerMsg + + def debug(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.debugMarkerMsgThrowable + + def debug(marker: Marker, message: String): Unit = + macro LoggerMacro.debugMarkerString + + def debug(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.debugMarkerStringThrowable + + def debug(message: Message): Unit = + macro LoggerMacro.debugMsg + + def debug(message: String): Unit = + macro LoggerMacro.debugString + + def debug(message: Message, cause: Throwable): Unit = + macro LoggerMacro.debugMsgThrowable + + def debug(message: String, cause: Throwable): Unit = + macro LoggerMacro.debugStringThrowable + + def trace(marker: Marker, message: Message): Unit = + macro LoggerMacro.traceMarkerMsg + + def trace(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.traceMarkerMsgThrowable + + def trace(marker: Marker, message: String): Unit = + macro LoggerMacro.traceMarkerString + + def trace(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.traceMarkerStringThrowable + + def trace(message: Message): Unit = + macro LoggerMacro.traceMsg + + def trace(message: String): Unit = + macro LoggerMacro.traceString + + def trace(message: Message, cause: Throwable): Unit = + macro LoggerMacro.traceMsgThrowable + + def trace(message: String, cause: Throwable): Unit = + macro LoggerMacro.traceStringThrowable + + def log(level: Level, marker: Marker, message: Message): Unit = + macro LoggerMacro.logMarkerMsg + + def log(level: Level, marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.logMarkerMsgThrowable + + def log(level: Level, marker: Marker, message: String): Unit = + macro LoggerMacro.logMarkerString + + def log(level: Level, marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.logMarkerStringThrowable + + def log(level: Level, message: Message): Unit = + macro LoggerMacro.logMsg + + def log(level: Level, message: String): Unit = + macro LoggerMacro.logString + + def log(level: Level, message: Message, cause: Throwable): Unit = + macro LoggerMacro.logMsgThrowable + + def log(level: Level, message: String, cause: Throwable): Unit = + macro LoggerMacro.logStringThrowable + + def isEnabled(level: Level): Boolean = delegate.isEnabled(level) + + def isEnabled(level: Level, marker: Marker): Boolean = delegate.isEnabled(level, marker) + + def entry(params: AnyRef*): Unit = + delegate.entry(params) // TODO would be useful to have this as a macro to avoid varargs array creation + + def entry(): Unit = delegate.entry() + + def exit[R](result: R): R = delegate.exit(result) + + def exit(): Unit = delegate.exit() + + def throwing[T <: Throwable](t: T): T = delegate.throwing(t) + + def throwing[T <: Throwable](level: Level, t: T): T = delegate.throwing(level, t) + + def catching(t: Throwable): Unit = delegate.catching(t) + + def catching(level: Level, t: Throwable): Unit = delegate.catching(level, t) + + def level: Level = delegate.getLevel + + def name: String = delegate.getName + + def messageFactory: MessageFactory = delegate.getMessageFactory + + /** 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(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: String, cause: Throwable): Unit = { + delegate.logMessage(FQCN, level, marker, delegate.getMessageFactory.newMessage(message), cause) + } + +} http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala new file mode 100644 index 0000000..f2de50e --- /dev/null +++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala @@ -0,0 +1,230 @@ +/* + * 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 + +private object LoggerMacro { + + type LoggerContext = Context { type PrefixType = Logger } + + def fatalMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.WARN), marker, message) + + def fatalMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + + def fatalMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.FATAL), marker, message) + + def fatalMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + + def fatalMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.FATAL), message) + + def fatalMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.FATAL), message, cause) + + def fatalString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.FATAL), message) + + def fatalStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(c)(c.universe.reify(Level.FATAL), message, cause) + + def errorMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.ERROR), marker, message) + + def errorMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) + + def errorMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.ERROR), marker, message) + + def errorMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) + + def errorMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.ERROR), message) + + def errorMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.ERROR), message, cause) + + def errorString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.ERROR), message) + + def errorStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(c)(c.universe.reify(Level.ERROR), message, cause) + + def warnMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.WARN), marker, message) + + def warnMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) + + def warnMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.WARN), marker, message) + + def warnMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) + + def warnMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.WARN), message) + + def warnMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.WARN), message, cause) + + def warnString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.WARN), message) + + def warnStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(c)(c.universe.reify(Level.WARN), message, cause) + + def infoMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.INFO), marker, message) + + def infoMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) + + def infoMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.INFO), marker, message) + + def infoMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) + + def infoMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.INFO), message) + + def infoMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.INFO), message, cause) + + def infoString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.INFO), message) + + def infoStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(c)(c.universe.reify(Level.INFO), message, cause) + + def debugMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.DEBUG), marker, message) + + def debugMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) + + def debugMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.DEBUG), marker, message) + + def debugMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) + + def debugMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.DEBUG), message) + + def debugMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) + + def debugString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.DEBUG), message) + + def debugStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) + + def traceMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.TRACE), marker, message) + + def traceMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) + + def traceMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.TRACE), marker, message) + + def traceMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) + + def traceMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.TRACE), message) + + def traceMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.TRACE), message, cause) + + def traceString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.TRACE), message) + + def traceStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(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 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 logMarkerString(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[String]) = + 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 logMarkerStringThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[String], 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 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 logString(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[String]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice)) { + c.prefix.splice.logMessage(level.splice, null, message.splice, null) + } + ) + + def logStringThrowable(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[String], cause: c.Expr[Throwable]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice)) { + c.prefix.splice.logMessage(level.splice, null, message.splice, cause.splice) + } + ) + +} http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala new file mode 100644 index 0000000..b292f91 --- /dev/null +++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala @@ -0,0 +1,26 @@ +/* + * 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.LogManager + +trait Logging { + + protected lazy val logger: Logger = + new Logger(LogManager.getContext(getClass.getClassLoader, false).getLogger(getClass.getName)) + +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala new file mode 100644 index 0000000..aea687a --- /dev/null +++ b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala @@ -0,0 +1,267 @@ +/* + * 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.{SimpleMessage, Message, ParameterizedMessageFactory} +import org.apache.logging.log4j.spi.ExtendedLogger +import org.apache.logging.log4j.{MarkerManager, Level, Marker} +import org.junit.runner.RunWith +import org.mockito.Matchers.{any, anyString, eq => eqv} +import org.mockito.Mockito._ +import org.scalatest.junit.JUnitRunner +import org.scalatest.mock.MockitoSugar +import org.scalatest.{FunSuite, Matchers} + +@RunWith(classOf[JUnitRunner]) +class LoggerTest extends FunSuite with Matchers with MockitoSugar { + + val stringMsg = "string msg" + val msg = new SimpleMessage("simple msg") + val cause = new RuntimeException("cause") + val marker = MarkerManager.getMarker("marker") + + test("fatal enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.FATAL)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.fatal(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.FATAL), eqv(null), any[Message], eqv(null)) + } + + test("fatal disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.FATAL)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.fatal(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("error enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.ERROR)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.error(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.ERROR), eqv(null), any[Message], eqv(null)) + } + + test("error disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.ERROR)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.error(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("warn enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.WARN)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.warn(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.WARN), eqv(null), any[Message], eqv(null)) + } + + test("warn disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.WARN)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.warn(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("info enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.info(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) + } + + test("info disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.info(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("debug enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.DEBUG)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.debug(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.DEBUG), eqv(null), any[Message], eqv(null)) + } + + test("debug disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.DEBUG)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.debug(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("trace enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.TRACE)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.trace(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.TRACE), eqv(null), any[Message], eqv(null)) + } + + test("trace disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.TRACE)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.trace(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) + } + + test("log disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with String message and cause") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, stringMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) + } + + test("log disabled with String message and cause") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, stringMsg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Message message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, msg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(null)) + } + + test("log disabled with Message message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, msg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Message message and cause") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, msg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause)) + } + + test("log disabled with Message message and cause") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, msg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with String message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) + } + + test("log disabled with String message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with String message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) + } + + test("log disabled with String message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Message message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null)) + } + + test("log disabled with Message message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Message message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause)) + } + + test("log disabled with Message message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + def buildMockLogger: ExtendedLogger = { + val mockLogger = mock[ExtendedLogger] + when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory) + mockLogger + } + +} http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.11/pom.xml ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.11/pom.xml b/log4j-api-scala_2.11/pom.xml new file mode 100644 index 0000000..399dfae --- /dev/null +++ b/log4j-api-scala_2.11/pom.xml @@ -0,0 +1,188 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + Licensed to the Apache Software Foundation (ASF) under one or more + contributor license agreements. See the NOTICE file distributed with + this work for additional information regarding copyright ownership. + The ASF licenses this file to You under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with + the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +--> +<project xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"; xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd";> + <modelVersion>4.0.0</modelVersion> + <parent> + <groupId>org.apache.logging.log4j</groupId> + <artifactId>log4j</artifactId> + <version>2.5-SNAPSHOT</version> + <relativePath>../</relativePath> + </parent> + <artifactId>log4j-api-scala_2.11</artifactId> + <packaging>jar</packaging> + <name>Scala warpper for Log4j API</name> + <description>Scala warpper for Log4j API</description> + <properties> + <log4jParentDir>${basedir}/..</log4jParentDir> + <projectDir>/scala_2.11</projectDir> + <scala.version>2.11.7</scala.version> + </properties> + <dependencies> + <dependency> + <groupId>org.apache.logging.log4j</groupId> + <artifactId>log4j-api</artifactId> + </dependency> + <dependency> + <groupId>org.scala-lang</groupId> + <artifactId>scala-library</artifactId> + <version>${scala.version}</version> + </dependency> + <dependency> + <groupId>org.scala-lang</groupId> + <artifactId>scala-reflect</artifactId> + <version>${scala.version}</version> + </dependency> + <dependency> + <groupId>org.apache.logging.log4j</groupId> + <artifactId>log4j-api</artifactId> + <type>test-jar</type> + <scope>test</scope> + </dependency> + <dependency> + <groupId>junit</groupId> + <artifactId>junit</artifactId> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.scalatest</groupId> + <artifactId>scalatest_2.11</artifactId> + <version>2.2.5</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.mockito</groupId> + <artifactId>mockito-core</artifactId> + <version>1.10.19</version> + <scope>test</scope> + </dependency> + </dependencies> + <build> + <sourceDirectory>src/main/scala</sourceDirectory> + <testSourceDirectory>src/test/scala</testSourceDirectory> + <plugins> + <plugin> + <groupId>net.alchim31.maven</groupId> + <artifactId>scala-maven-plugin</artifactId> + <version>3.2.2</version> + <executions> + <execution> + <goals> + <goal>compile</goal> + <goal>testCompile</goal> + </goals> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-surefire-plugin</artifactId> + </plugin> + <!-- Include the standard NOTICE and LICENSE --> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-remote-resources-plugin</artifactId> + <executions> + <execution> + <goals> + <goal>process</goal> + </goals> + <configuration> + <skip>false</skip> + </configuration> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.felix</groupId> + <artifactId>maven-bundle-plugin</artifactId> + </plugin> + </plugins> + </build> + <reporting> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-changes-plugin</artifactId> + <version>${changes.plugin.version}</version> + <reportSets> + <reportSet> + <reports> + <report>changes-report</report> + </reports> + </reportSet> + </reportSets> + <configuration> + <issueLinkTemplate>%URL%/show_bug.cgi?id=%ISSUE%</issueLinkTemplate> + <useJql>true</useJql> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-checkstyle-plugin</artifactId> + <version>${checkstyle.plugin.version}</version> + <configuration> + <!--<propertiesLocation>${vfs.parent.dir}/checkstyle.properties</propertiesLocation> --> + <configLocation>${log4jParentDir}/checkstyle.xml</configLocation> + <suppressionsLocation>${log4jParentDir}/checkstyle-suppressions.xml</suppressionsLocation> + <enableRulesSummary>false</enableRulesSummary> + <propertyExpansion>basedir=${basedir}</propertyExpansion> + <propertyExpansion>licensedir=${log4jParentDir}/checkstyle-header.txt</propertyExpansion> + </configuration> + </plugin> + <plugin> + <groupId>org.codehaus.mojo</groupId> + <artifactId>findbugs-maven-plugin</artifactId> + <version>${findbugs.plugin.version}</version> + <configuration> + <fork>true</fork> + <jvmArgs>-Duser.language=en</jvmArgs> + <threshold>Normal</threshold> + <effort>Default</effort> + <excludeFilterFile>${log4jParentDir}/findbugs-exclude-filter.xml</excludeFilterFile> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-jxr-plugin</artifactId> + <version>${jxr.plugin.version}</version> + <reportSets> + <reportSet> + <id>non-aggregate</id> + <reports> + <report>jxr</report> + </reports> + </reportSet> + <reportSet> + <id>aggregate</id> + <reports> + <report>aggregate</report> + </reports> + </reportSet> + </reportSets> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-pmd-plugin</artifactId> + <version>${pmd.plugin.version}</version> + <configuration> + <targetJdk>${maven.compile.target}</targetJdk> + </configuration> + </plugin> + </plugins> + </reporting> +</project> http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala new file mode 100644 index 0000000..ad35a7a --- /dev/null +++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala @@ -0,0 +1,252 @@ +/* + * 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.{MessageFactory, Message} +import org.apache.logging.log4j.spi.ExtendedLogger +import org.apache.logging.log4j.{Level, Marker} + +import scala.language.experimental.macros + +class Logger(val delegate: ExtendedLogger) { + + private final val FQCN = classOf[Logger].getName + + def fatal(marker: Marker, message: Message): Unit = + macro LoggerMacro.fatalMarkerMsg + + def fatal(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.fatalMarkerMsgThrowable + + def fatal(marker: Marker, message: String): Unit = + macro LoggerMacro.fatalMarkerString + + def fatal(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.fatalMarkerStringThrowable + + def fatal(message: Message): Unit = + macro LoggerMacro.fatalMsg + + def fatal(message: String): Unit = + macro LoggerMacro.fatalString + + def fatal(message: Message, cause: Throwable): Unit = + macro LoggerMacro.fatalMsgThrowable + + def fatal(message: String, cause: Throwable): Unit = + macro LoggerMacro.fatalStringThrowable + + def error(marker: Marker, message: Message): Unit = + macro LoggerMacro.errorMarkerMsg + + def error(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.errorMarkerMsgThrowable + + def error(marker: Marker, message: String): Unit = + macro LoggerMacro.errorMarkerString + + def error(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.errorMarkerStringThrowable + + def error(message: Message): Unit = + macro LoggerMacro.errorMsg + + def error(message: String): Unit = + macro LoggerMacro.errorString + + def error(message: Message, cause: Throwable): Unit = + macro LoggerMacro.errorMsgThrowable + + def error(message: String, cause: Throwable): Unit = + macro LoggerMacro.errorStringThrowable + + def warn(marker: Marker, message: Message): Unit = + macro LoggerMacro.warnMarkerMsg + + def warn(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.warnMarkerMsgThrowable + + def warn(marker: Marker, message: String): Unit = + macro LoggerMacro.warnMarkerString + + def warn(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.warnMarkerStringThrowable + + def warn(message: Message): Unit = + macro LoggerMacro.warnMsg + + def warn(message: String): Unit = + macro LoggerMacro.warnString + + def warn(message: Message, cause: Throwable): Unit = + macro LoggerMacro.warnMsgThrowable + + def warn(message: String, cause: Throwable): Unit = + macro LoggerMacro.warnStringThrowable + + def info(marker: Marker, message: Message): Unit = + macro LoggerMacro.infoMarkerMsg + + def info(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.infoMarkerMsgThrowable + + def info(marker: Marker, message: String): Unit = + macro LoggerMacro.infoMarkerString + + def info(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.infoMarkerStringThrowable + + def info(message: Message): Unit = + macro LoggerMacro.infoMsg + + def info(message: String): Unit = + macro LoggerMacro.infoString + + def info(message: Message, cause: Throwable): Unit = + macro LoggerMacro.infoMsgThrowable + + def info(message: String, cause: Throwable): Unit = + macro LoggerMacro.infoStringThrowable + + def debug(marker: Marker, message: Message): Unit = + macro LoggerMacro.debugMarkerMsg + + def debug(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.debugMarkerMsgThrowable + + def debug(marker: Marker, message: String): Unit = + macro LoggerMacro.debugMarkerString + + def debug(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.debugMarkerStringThrowable + + def debug(message: Message): Unit = + macro LoggerMacro.debugMsg + + def debug(message: String): Unit = + macro LoggerMacro.debugString + + def debug(message: Message, cause: Throwable): Unit = + macro LoggerMacro.debugMsgThrowable + + def debug(message: String, cause: Throwable): Unit = + macro LoggerMacro.debugStringThrowable + + def trace(marker: Marker, message: Message): Unit = + macro LoggerMacro.traceMarkerMsg + + def trace(marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.traceMarkerMsgThrowable + + def trace(marker: Marker, message: String): Unit = + macro LoggerMacro.traceMarkerString + + def trace(marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.traceMarkerStringThrowable + + def trace(message: Message): Unit = + macro LoggerMacro.traceMsg + + def trace(message: String): Unit = + macro LoggerMacro.traceString + + def trace(message: Message, cause: Throwable): Unit = + macro LoggerMacro.traceMsgThrowable + + def trace(message: String, cause: Throwable): Unit = + macro LoggerMacro.traceStringThrowable + + def log(level: Level, marker: Marker, message: Message): Unit = + macro LoggerMacro.logMarkerMsg + + def log(level: Level, marker: Marker, message: Message, cause: Throwable): Unit = + macro LoggerMacro.logMarkerMsgThrowable + + def log(level: Level, marker: Marker, message: String): Unit = + macro LoggerMacro.logMarkerString + + def log(level: Level, marker: Marker, message: String, cause: Throwable): Unit = + macro LoggerMacro.logMarkerStringThrowable + + def log(level: Level, message: Message): Unit = + macro LoggerMacro.logMsg + + def log(level: Level, message: String): Unit = + macro LoggerMacro.logString + + def log(level: Level, message: Message, cause: Throwable): Unit = + macro LoggerMacro.logMsgThrowable + + def log(level: Level, message: String, cause: Throwable): Unit = + macro LoggerMacro.logStringThrowable + + def isEnabled(level: Level): Boolean = delegate.isEnabled(level) + + def isEnabled(level: Level, marker: Marker): Boolean = delegate.isEnabled(level, marker) + + def entry(params: AnyRef*): Unit = + delegate.entry(params) // TODO would be useful to have this as a macro to avoid varargs array creation + + def entry(): Unit = delegate.entry() + + def exit[R](result: R): R = delegate.exit(result) + + def exit(): Unit = delegate.exit() + + def throwing[T <: Throwable](t: T): T = delegate.throwing(t) + + def throwing[T <: Throwable](level: Level, t: T): T = delegate.throwing(level, t) + + def catching(t: Throwable): Unit = delegate.catching(t) + + def catching(level: Level, t: Throwable): Unit = delegate.catching(level, t) + + def level: Level = delegate.getLevel + + def name: String = delegate.getName + + def messageFactory: MessageFactory = delegate.getMessageFactory + + /** 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(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: String, cause: Throwable): Unit = { + delegate.logMessage(FQCN, level, marker, delegate.getMessageFactory.newMessage(message), cause) + } + +} http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala new file mode 100644 index 0000000..5541c8b --- /dev/null +++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala @@ -0,0 +1,230 @@ +/* + * 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.Context + +private object LoggerMacro { + + type LoggerContext = Context { type PrefixType = Logger } + + def fatalMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.WARN), marker, message) + + def fatalMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + + def fatalMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.FATAL), marker, message) + + def fatalMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.FATAL), marker, message, cause) + + def fatalMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.FATAL), message) + + def fatalMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.FATAL), message, cause) + + def fatalString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.FATAL), message) + + def fatalStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(c)(c.universe.reify(Level.FATAL), message, cause) + + def errorMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.ERROR), marker, message) + + def errorMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) + + def errorMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.ERROR), marker, message) + + def errorMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.ERROR), marker, message, cause) + + def errorMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.ERROR), message) + + def errorMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.ERROR), message, cause) + + def errorString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.ERROR), message) + + def errorStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(c)(c.universe.reify(Level.ERROR), message, cause) + + def warnMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.WARN), marker, message) + + def warnMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) + + def warnMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.WARN), marker, message) + + def warnMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.WARN), marker, message, cause) + + def warnMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.WARN), message) + + def warnMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.WARN), message, cause) + + def warnString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.WARN), message) + + def warnStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(c)(c.universe.reify(Level.WARN), message, cause) + + def infoMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.INFO), marker, message) + + def infoMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) + + def infoMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.INFO), marker, message) + + def infoMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.INFO), marker, message, cause) + + def infoMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.INFO), message) + + def infoMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.INFO), message, cause) + + def infoString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.INFO), message) + + def infoStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(c)(c.universe.reify(Level.INFO), message, cause) + + def debugMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.DEBUG), marker, message) + + def debugMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) + + def debugMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.DEBUG), marker, message) + + def debugMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.DEBUG), marker, message, cause) + + def debugMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.DEBUG), message) + + def debugMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) + + def debugString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.DEBUG), message) + + def debugStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(c)(c.universe.reify(Level.DEBUG), message, cause) + + def traceMarkerMsg(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message]) = + logMarkerMsg(c)(c.universe.reify(Level.TRACE), marker, message) + + def traceMarkerMsgThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMarkerMsgThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) + + def traceMarkerString(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String]) = + logMarkerString(c)(c.universe.reify(Level.TRACE), marker, message) + + def traceMarkerStringThrowable(c: LoggerContext)(marker: c.Expr[Marker], message: c.Expr[String], cause: c.Expr[Throwable]) = + logMarkerStringThrowable(c)(c.universe.reify(Level.TRACE), marker, message, cause) + + def traceMsg(c: LoggerContext)(message: c.Expr[Message]) = + logMsg(c)(c.universe.reify(Level.TRACE), message) + + def traceMsgThrowable(c: LoggerContext)(message: c.Expr[Message], cause: c.Expr[Throwable]) = + logMsgThrowable(c)(c.universe.reify(Level.TRACE), message, cause) + + def traceString(c: LoggerContext)(message: c.Expr[String]) = + logString(c)(c.universe.reify(Level.TRACE), message) + + def traceStringThrowable(c: LoggerContext)(message: c.Expr[String], cause: c.Expr[Throwable]) = + logStringThrowable(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 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 logMarkerString(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[String]) = + 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 logMarkerStringThrowable(c: LoggerContext)(level: c.Expr[Level], marker: c.Expr[Marker], message: c.Expr[String], 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 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 logString(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[String]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice)) { + c.prefix.splice.logMessage(level.splice, null, message.splice, null) + } + ) + + def logStringThrowable(c: LoggerContext)(level: c.Expr[Level], message: c.Expr[String], cause: c.Expr[Throwable]) = + c.universe.reify( + if (c.prefix.splice.delegate.isEnabled(level.splice)) { + c.prefix.splice.logMessage(level.splice, null, message.splice, cause.splice) + } + ) + +} http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logging.scala ---------------------------------------------------------------------- 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 100644 index 0000000..b292f91 --- /dev/null +++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logging.scala @@ -0,0 +1,26 @@ +/* + * 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.LogManager + +trait Logging { + + protected lazy val logger: Logger = + new Logger(LogManager.getContext(getClass.getClassLoader, false).getLogger(getClass.getName)) + +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala new file mode 100644 index 0000000..aea687a --- /dev/null +++ b/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala @@ -0,0 +1,267 @@ +/* + * 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.{SimpleMessage, Message, ParameterizedMessageFactory} +import org.apache.logging.log4j.spi.ExtendedLogger +import org.apache.logging.log4j.{MarkerManager, Level, Marker} +import org.junit.runner.RunWith +import org.mockito.Matchers.{any, anyString, eq => eqv} +import org.mockito.Mockito._ +import org.scalatest.junit.JUnitRunner +import org.scalatest.mock.MockitoSugar +import org.scalatest.{FunSuite, Matchers} + +@RunWith(classOf[JUnitRunner]) +class LoggerTest extends FunSuite with Matchers with MockitoSugar { + + val stringMsg = "string msg" + val msg = new SimpleMessage("simple msg") + val cause = new RuntimeException("cause") + val marker = MarkerManager.getMarker("marker") + + test("fatal enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.FATAL)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.fatal(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.FATAL), eqv(null), any[Message], eqv(null)) + } + + test("fatal disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.FATAL)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.fatal(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("error enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.ERROR)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.error(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.ERROR), eqv(null), any[Message], eqv(null)) + } + + test("error disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.ERROR)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.error(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("warn enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.WARN)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.warn(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.WARN), eqv(null), any[Message], eqv(null)) + } + + test("warn disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.WARN)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.warn(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("info enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.info(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) + } + + test("info disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.info(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("debug enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.DEBUG)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.debug(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.DEBUG), eqv(null), any[Message], eqv(null)) + } + + test("debug disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.DEBUG)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.debug(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("trace enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.TRACE)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.trace(stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.TRACE), eqv(null), any[Message], eqv(null)) + } + + test("trace disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.TRACE)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.trace(stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) + } + + test("log disabled with String message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with String message and cause") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, stringMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) + } + + test("log disabled with String message and cause") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, stringMsg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Message message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, msg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(null)) + } + + test("log disabled with Message message") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, msg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Message message and cause") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, msg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause)) + } + + test("log disabled with Message message and cause") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, msg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with String message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) + } + + test("log disabled with String message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with String message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) + } + + test("log disabled with String message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, stringMsg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Message message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null)) + } + + test("log disabled with Message message and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + test("log enabled with Message message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg, cause) + verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause)) + } + + test("log disabled with Message message and cause and Marker") { + val mockLogger = buildMockLogger + when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) + val logger = new Logger(mockLogger) + logger.log(Level.INFO, marker, msg, cause) + verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) + } + + def buildMockLogger: ExtendedLogger = { + val mockLogger = mock[ExtendedLogger] + when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory) + mockLogger + } + +} http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/2414d229/log4j-scala_2.10/.gitignore ---------------------------------------------------------------------- diff --git a/log4j-scala_2.10/.gitignore b/log4j-scala_2.10/.gitignore deleted file mode 100644 index ddd6d6d..0000000 --- a/log4j-scala_2.10/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -/.settings/ -/.classpath -/.project
