You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by mi...@apache.org on 2016/11/08 12:20:24 UTC
[3/4] logging-log4j-scala git commit: Initial project setup
Initial project setup
Project: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/repo
Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/commit/92caaa55
Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/tree/92caaa55
Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/diff/92caaa55
Branch: refs/heads/master
Commit: 92caaa55d56054c928c3a44335859a5dd9c0b6b9
Parents:
Author: Mikael St�ldal <mi...@magine.com>
Authored: Tue Nov 8 11:48:32 2016 +0100
Committer: Mikael St�ldal <mi...@magine.com>
Committed: Tue Nov 8 11:48:32 2016 +0100
----------------------------------------------------------------------
.gitignore | 12 +
LICENSE.txt | 202 +++++++
NOTICE.txt | 5 +
README.md | 18 +
log4j-api-scala_2.10/pom.xml | 157 +++++
.../org/apache/logging/log4j/scala/Logger.scala | 592 +++++++++++++++++++
.../logging/log4j/scala/LoggerMacro.scala | 425 +++++++++++++
.../apache/logging/log4j/scala/Logging.scala | 30 +
.../apache/logging/log4j/scala/LoggerTest.scala | 552 +++++++++++++++++
log4j-api-scala_2.11/pom.xml | 157 +++++
.../org/apache/logging/log4j/scala/Logger.scala | 592 +++++++++++++++++++
.../logging/log4j/scala/LoggerMacro.scala | 425 +++++++++++++
.../apache/logging/log4j/scala/Logging.scala | 30 +
.../apache/logging/log4j/scala/LoggerTest.scala | 552 +++++++++++++++++
log4j-api-scala_2.12/pom.xml | 157 +++++
.../org/apache/logging/log4j/scala/Logger.scala | 592 +++++++++++++++++++
.../logging/log4j/scala/LoggerMacro.scala | 425 +++++++++++++
.../apache/logging/log4j/scala/Logging.scala | 30 +
.../apache/logging/log4j/scala/LoggerTest.scala | 552 +++++++++++++++++
pom.xml | 42 ++
20 files changed, 5547 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/92caaa55/.gitignore
----------------------------------------------------------------------
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..3d542f9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,12 @@
+.project
+.idea
+**/*.iml
+**/target
+target/
+.settings
+.classpath
+.cache-main
+.cache-tests
+velocity.log
+felix-cache/
+bin/
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/92caaa55/LICENSE.txt
----------------------------------------------------------------------
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..6279e52
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright 1999-2005 The Apache Software Foundation
+
+ Licensed 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.
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/92caaa55/NOTICE.txt
----------------------------------------------------------------------
diff --git a/NOTICE.txt b/NOTICE.txt
new file mode 100644
index 0000000..3b3bcf3
--- /dev/null
+++ b/NOTICE.txt
@@ -0,0 +1,5 @@
+Apache Log4j
+Copyright 2016 Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/92caaa55/README.md
----------------------------------------------------------------------
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..0e1e55f
--- /dev/null
+++ b/README.md
@@ -0,0 +1,18 @@
+# [Apache Log4j 2 Scala API](http://logging.apache.org/log4j/2.x/)
+
+## License
+
+Apache Log4j 2 is distributed under the [Apache License, version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html).
+
+## Download
+
+[How to download Log4j](http://logging.apache.org/log4j/2.x/download.html),
+and [how to use it from SBT, Maven, Ivy and Gradle](http://logging.apache.org/log4j/2.x/maven-artifacts.html).
+
+## Issue Tracking
+
+Issues, bugs, and feature requests should be submitted to the
+[JIRA issue tracking system for this project](https://issues.apache.org/jira/browse/LOG4J2).
+
+Pull request on GitHub are welcome, but please open a ticket in the JIRA issue tracker first, and mention the
+JIRA issue in the Pull Request.
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/92caaa55/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..b009850
--- /dev/null
+++ b/log4j-api-scala_2.10/pom.xml
@@ -0,0 +1,157 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-scala</artifactId>
+ <version>2.7.1-SNAPSHOT</version>
+ <relativePath>../</relativePath>
+ </parent>
+ <artifactId>log4j-api-scala_2.10</artifactId>
+ <packaging>jar</packaging>
+ <name>Scala 2.10 wrapper for Log4j API</name>
+ <description>Scala wrapper for Log4j API</description>
+ <properties>
+ <log4jParentDir>${basedir}/..</log4jParentDir>
+ <projectDir>/scala_2.10</projectDir>
+ <scala.version>2.10.6</scala.version>
+ <scala.maven.plugin.version>3.2.2</scala.maven.plugin.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>3.0.0</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <version>1.10.19</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+ <build>
+ <sourceDirectory>src/main/scala</sourceDirectory>
+ <testSourceDirectory>src/test/scala</testSourceDirectory>
+ <plugins>
+ <plugin>
+ <groupId>net.alchim31.maven</groupId>
+ <artifactId>scala-maven-plugin</artifactId>
+ <version>${scala.maven.plugin.version}</version>
+ <executions>
+ <execution>
+ <goals>
+ <goal>compile</goal>
+ <goal>testCompile</goal>
+ </goals>
+ </execution>
+ </executions>
+ <configuration>
+ <args>
+ <arg>-feature</arg>
+ <arg>-unchecked</arg>
+ <arg>-deprecation</arg>
+ </args>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ </plugin>
+ <!-- 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-pmd-plugin</artifactId>
+ <version>${pmd.plugin.version}</version>
+ <configuration>
+ <targetJdk>${maven.compile.target}</targetJdk>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>net.alchim31.maven</groupId>
+ <artifactId>scala-maven-plugin</artifactId>
+ <version>${scala.maven.plugin.version}</version>
+ </plugin>
+ </plugins>
+ </reporting>
+</project>
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/92caaa55/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..b42cd5a
--- /dev/null
+++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala
@@ -0,0 +1,592 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.scala
+
+import org.apache.logging.log4j.message.{EntryMessage, Message, MessageFactory2}
+import org.apache.logging.log4j.spi.ExtendedLogger
+import org.apache.logging.log4j.{Level, LogManager, Marker}
+
+import scala.language.experimental.macros
+
+/**
+ * Factory for [[Logger]]s.
+ *
+ * The [[Logging]] trait provides a simple way to get a properly named logger into a class.
+ */
+object Logger {
+
+ final val FQCN = getClass.getName
+
+ /**
+ * Create a properly named [[Logger]] for a given class.
+ *
+ * @param clazz the class
+ */
+ def apply(clazz: Class[_]): Logger = Logger(LogManager.getContext(clazz.getClassLoader, false).getLogger(clazz.getName))
+
+ /**
+ * Create a [[Logger]] wrapping the given Log4j logger.
+ *
+ * @param delegate the Log4j logger to wrap
+ */
+ def apply(delegate: ExtendedLogger): Logger = new Logger(delegate)
+
+}
+
+/**
+ * Scala wrapper for the Log4j `Logger` interface.
+ *
+ * Frequently the purpose of logging is to provide information about what is happening in the system,
+ * which requires including information about the objects being manipulated. In Scala, you can use
+ * [[http://docs.scala-lang.org/overviews/core/string-interpolation.html string interpolation]]
+ * to achieve this:
+ *
+ * {{{
+ * logger.debug(s"Logging in user ${user.getName} with birthday ${user.calcBirthday}")
+ * }}}
+ *
+ * Since this wrapper is implemented with macros, the String construction and method invocations
+ * will only occur when debug logging is enabled.
+ */
+class Logger private(val delegate: ExtendedLogger) extends AnyVal {
+
+ def fatal(marker: Marker, message: Message): Unit =
+ macro LoggerMacro.fatalMarkerMsg
+
+ def fatal(marker: Marker, message: CharSequence): Unit =
+ macro LoggerMacro.fatalMarkerCseq
+
+ def fatal(marker: Marker, message: AnyRef): Unit =
+ macro LoggerMacro.fatalMarkerObject
+
+ def fatal(marker: Marker, message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.fatalMarkerMsgThrowable
+
+ def fatal(marker: Marker, message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.fatalMarkerCseqThrowable
+
+ def fatal(marker: Marker, message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.fatalMarkerObjectThrowable
+
+ def fatal(message: Message): Unit =
+ macro LoggerMacro.fatalMsg
+
+ def fatal(message: CharSequence): Unit =
+ macro LoggerMacro.fatalCseq
+
+ def fatal(message: AnyRef): Unit =
+ macro LoggerMacro.fatalObject
+
+ def fatal(message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.fatalMsgThrowable
+
+ def fatal(message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.fatalCseqThrowable
+
+ def fatal(message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.fatalObjectThrowable
+
+
+ def error(marker: Marker, message: Message): Unit =
+ macro LoggerMacro.errorMarkerMsg
+
+ def error(marker: Marker, message: CharSequence): Unit =
+ macro LoggerMacro.errorMarkerCseq
+
+ def error(marker: Marker, message: AnyRef): Unit =
+ macro LoggerMacro.errorMarkerObject
+
+ def error(marker: Marker, message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.errorMarkerMsgThrowable
+
+ def error(marker: Marker, message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.errorMarkerCseqThrowable
+
+ def error(marker: Marker, message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.errorMarkerObjectThrowable
+
+ def error(message: Message): Unit =
+ macro LoggerMacro.errorMsg
+
+ def error(message: CharSequence): Unit =
+ macro LoggerMacro.errorCseq
+
+ def error(message: AnyRef): Unit =
+ macro LoggerMacro.errorObject
+
+ def error(message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.errorMsgThrowable
+
+ def error(message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.errorCseqThrowable
+
+ def error(message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.errorObjectThrowable
+
+
+ def warn(marker: Marker, message: Message): Unit =
+ macro LoggerMacro.warnMarkerMsg
+
+ def warn(marker: Marker, message: CharSequence): Unit =
+ macro LoggerMacro.warnMarkerCseq
+
+ def warn(marker: Marker, message: AnyRef): Unit =
+ macro LoggerMacro.warnMarkerObject
+
+ def warn(marker: Marker, message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.warnMarkerMsgThrowable
+
+ def warn(marker: Marker, message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.warnMarkerCseqThrowable
+
+ def warn(marker: Marker, message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.warnMarkerObjectThrowable
+
+ def warn(message: Message): Unit =
+ macro LoggerMacro.warnMsg
+
+ def warn(message: CharSequence): Unit =
+ macro LoggerMacro.warnCseq
+
+ def warn(message: AnyRef): Unit =
+ macro LoggerMacro.warnObject
+
+ def warn(message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.warnMsgThrowable
+
+ def warn(message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.warnCseqThrowable
+
+ def warn(message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.warnObjectThrowable
+
+
+ def info(marker: Marker, message: Message): Unit =
+ macro LoggerMacro.infoMarkerMsg
+
+ def info(marker: Marker, message: CharSequence): Unit =
+ macro LoggerMacro.infoMarkerCseq
+
+ def info(marker: Marker, message: AnyRef): Unit =
+ macro LoggerMacro.infoMarkerObject
+
+ def info(marker: Marker, message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.infoMarkerMsgThrowable
+
+ def info(marker: Marker, message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.infoMarkerCseqThrowable
+
+ def info(marker: Marker, message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.infoMarkerObjectThrowable
+
+ def info(message: Message): Unit =
+ macro LoggerMacro.infoMsg
+
+ def info(message: CharSequence): Unit =
+ macro LoggerMacro.infoCseq
+
+ def info(message: AnyRef): Unit =
+ macro LoggerMacro.infoObject
+
+ def info(message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.infoMsgThrowable
+
+ def info(message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.infoCseqThrowable
+
+ def info(message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.infoObjectThrowable
+
+
+ def debug(marker: Marker, message: Message): Unit =
+ macro LoggerMacro.debugMarkerMsg
+
+ def debug(marker: Marker, message: CharSequence): Unit =
+ macro LoggerMacro.debugMarkerCseq
+
+ def debug(marker: Marker, message: AnyRef): Unit =
+ macro LoggerMacro.debugMarkerObject
+
+ def debug(marker: Marker, message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.debugMarkerMsgThrowable
+
+ def debug(marker: Marker, message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.debugMarkerCseqThrowable
+
+ def debug(marker: Marker, message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.debugMarkerObjectThrowable
+
+ def debug(message: Message): Unit =
+ macro LoggerMacro.debugMsg
+
+ def debug(message: CharSequence): Unit =
+ macro LoggerMacro.debugCseq
+
+ def debug(message: AnyRef): Unit =
+ macro LoggerMacro.debugObject
+
+ def debug(message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.debugMsgThrowable
+
+ def debug(message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.debugCseqThrowable
+
+ def debug(message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.debugObjectThrowable
+
+
+ def trace(marker: Marker, message: Message): Unit =
+ macro LoggerMacro.traceMarkerMsg
+
+ def trace(marker: Marker, message: CharSequence): Unit =
+ macro LoggerMacro.traceMarkerCseq
+
+ def trace(marker: Marker, message: AnyRef): Unit =
+ macro LoggerMacro.traceMarkerObject
+
+ def trace(marker: Marker, message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.traceMarkerMsgThrowable
+
+ def trace(marker: Marker, message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.traceMarkerCseqThrowable
+
+ def trace(marker: Marker, message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.traceMarkerObjectThrowable
+
+ def trace(message: Message): Unit =
+ macro LoggerMacro.traceMsg
+
+ def trace(message: CharSequence): Unit =
+ macro LoggerMacro.traceCseq
+
+ def trace(message: AnyRef): Unit =
+ macro LoggerMacro.traceObject
+
+ def trace(message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.traceMsgThrowable
+
+ def trace(message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.traceCseqThrowable
+
+ def trace(message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.traceObjectThrowable
+
+
+ /**
+ * Logs a `Message` with the specific `Marker` at the given `Level`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ */
+ def apply(level: Level, marker: Marker, message: Message): Unit =
+ macro LoggerMacro.logMarkerMsg
+
+ /**
+ * Logs a string with the specific `Marker` at the given `Level`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ */
+ def apply(level: Level, marker: Marker, message: CharSequence): Unit =
+ macro LoggerMacro.logMarkerCseq
+
+ /**
+ * Logs an object with the specific `Marker` at the given `Level`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ */
+ def apply(level: Level, marker: Marker, message: AnyRef): Unit =
+ macro LoggerMacro.logMarkerObject
+
+ /**
+ * Logs a `Message` with the specific `Marker` at the given `Level` including the stack trace
+ * of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ * @param cause the cause
+ */
+ def apply(level: Level, marker: Marker, message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.logMarkerMsgThrowable
+
+ /**
+ * Logs a string with the specific `Marker` at the given `Level` including the stack trace
+ * of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ * @param cause the cause
+ */
+ def apply(level: Level, marker: Marker, message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.logMarkerCseqThrowable
+
+ /**
+ * Logs an object with the specific `Marker` at the given `Level` including the stack trace
+ * of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param marker the marker data specific to this log statement
+ * @param message the message to be logged
+ * @param cause the cause
+ */
+ def apply(level: Level, marker: Marker, message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.logMarkerObjectThrowable
+
+ /**
+ * Logs a `Message` at the given `Level`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ */
+ def apply(level: Level, message: Message): Unit =
+ macro LoggerMacro.logMsg
+
+ /**
+ * Logs a string at the given `Level`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ */
+ def apply(level: Level, message: CharSequence): Unit =
+ macro LoggerMacro.logCseq
+
+ /**
+ * Logs an object at the given `Level`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ */
+ def apply(level: Level, message: AnyRef): Unit =
+ macro LoggerMacro.logObject
+
+ /**
+ * Logs a `Message` at the given `Level` including the stack trace of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ * @param cause a `Throwable`
+ */
+ def apply(level: Level, message: Message, cause: Throwable): Unit =
+ macro LoggerMacro.logMsgThrowable
+
+ /**
+ * Logs a string at the given `Level` including the stack trace of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ * @param cause a `Throwable`
+ */
+ def apply(level: Level, message: CharSequence, cause: Throwable): Unit =
+ macro LoggerMacro.logCseqThrowable
+
+ /**
+ * Logs an object at the given `Level` including the stack trace of the given `Throwable`.
+ *
+ * @param level the logging level
+ * @param message the message to be logged
+ * @param cause a `Throwable`
+ */
+ def apply(level: Level, message: AnyRef, cause: Throwable): Unit =
+ macro LoggerMacro.logObjectThrowable
+
+
+ /**
+ * Logs entry to a method. Used when the method in question has no parameters or when the parameters should not be
+ * logged.
+ *
+ * @return The built `EntryMessage`
+ */
+ def traceEntry(): EntryMessage =
+ macro LoggerMacro.traceEntry
+
+ /**
+ * Logs entry to a method along with its parameters.
+ *
+ * {{{
+ * def doSomething(foo: String, bar: Int): Unit = {
+ * logger.traceEntry(foo, bar)
+ * // do something
+ * }
+ * }}}
+ *
+ * @param params the parameters to the method.
+ * @return The built `EntryMessage`
+ */
+ def traceEntry(params: AnyRef*): EntryMessage =
+ macro LoggerMacro.traceEntryParams
+
+ /**
+ * Logs entry to a method using a `Message` to describe the parameters.
+ *
+ * {{{
+ * def doSomething(foo: Request): Unit = {
+ * logger.traceEntry(JsonMessage(foo))
+ * // do something
+ * }
+ * }}}
+ *
+ * @param message the message
+ * @return The built `EntryMessage`
+ */
+ def traceEntry(message: Message): EntryMessage =
+ macro LoggerMacro.traceEntryMessage
+
+ /**
+ * Logs exit from a method with no result.
+ */
+ def traceExit(): Unit =
+ macro LoggerMacro.traceExit
+
+ /**
+ * Logs exiting from a method with result.
+ *
+ * @param result The result being returned from the method call
+ * @return `result`
+ */
+ def traceExit[R](result: R): R =
+ macro LoggerMacro.traceExitResult[R]
+
+ /**
+ * Logs exiting from a method with no result.
+ *
+ * @param entryMessage the `EntryMessage` returned from one of the `traceEntry` methods
+ */
+ def traceExit(entryMessage: EntryMessage): Unit =
+ macro LoggerMacro.traceExitEntryMessage
+
+ /**
+ * Logs exiting from a method with result.
+ *
+ * {{{
+ * def doSomething(foo: String, bar: Int): Int = {
+ * val entryMessage = logger.traceEntry(foo, bar)
+ * // do something
+ * traceExit(entryMessage, value)
+ * }
+ * }}}
+ *
+ * @param entryMessage the `EntryMessage` returned from one of the `traceEntry` methods
+ * @param result The result being returned from the method call
+ * @return `result`
+ */
+ def traceExit[R](entryMessage: EntryMessage, result: R): R =
+ macro LoggerMacro.traceExitEntryMessageResult[R]
+
+ /**
+ * Logs exiting from a method with result. Allows custom formatting of the result.
+ *
+ * @param message the Message containing the formatted result
+ * @param result The result being returned from the method call.
+ * @return `result`
+ */
+ def traceExit[R](message: Message, result: R): R =
+ macro LoggerMacro.traceExitMessageResult[R]
+
+ /**
+ * Logs an exception or error to be thrown.
+ *
+ * {{{
+ * throw logger.throwing(myException)
+ * }}}
+ *
+ * @param t the Throwable
+ * @return `t`
+ */
+ def throwing[T <: Throwable](t: T): T =
+ macro LoggerMacro.throwing[T]
+
+ /**
+ * Logs an exception or error to be thrown to a specific logging level.
+ *
+ * {{{
+ * throw logger.throwing(Level.DEBUG, myException)
+ * }}}
+ *
+ * @param level the logging Level.
+ * @param t the Throwable
+ * @return `t`
+ */
+ def throwing[T <: Throwable](level: Level, t: T): T =
+ macro LoggerMacro.throwingLevel[T]
+
+ /**
+ * Logs an exception or error that has been caught.
+ *
+ * @param t the Throwable.
+ */
+ def catching(t: Throwable): Unit =
+ macro LoggerMacro.catching
+
+ /**
+ * Logs an exception or error that has been caught to a specific logging level.
+ *
+ * @param level The logging Level.
+ * @param t The Throwable.
+ */
+ def catching(level: Level, t: Throwable): Unit =
+ macro LoggerMacro.catchingLevel
+
+
+ /** Always logs a message at the specified level. It is the responsibility of the caller to ensure the specified
+ * level is enabled.
+ *
+ * Should normally not be used directly from application code, but needs to be public for access by macros.
+ *
+ * @param level log level
+ * @param marker marker or `null`
+ * @param message message
+ * @param cause cause or `null`
+ */
+ def logMessage(level: Level, marker: Marker, message: Message, cause: Throwable): Unit = {
+ delegate.logMessage(Logger.FQCN, level, marker, message, cause)
+ }
+
+ /** Always logs a message at the specified level. It is the responsibility of the caller to ensure the specified
+ * level is enabled.
+ *
+ * Should normally not be used directly from application code, but needs to be public for access by macros.
+ *
+ * @param level log level
+ * @param marker marker or `null`
+ * @param message message
+ * @param cause cause or `null`
+ */
+ def logMessage(level: Level, marker: Marker, message: CharSequence, cause: Throwable): Unit = {
+ delegate.logMessage(Logger.FQCN, level, marker, delegate.getMessageFactory.asInstanceOf[MessageFactory2].newMessage(message), cause)
+ }
+
+ /** Always logs a message at the specified level. It is the responsibility of the caller to ensure the specified
+ * level is enabled.
+ *
+ * Should normally not be used directly from application code, but needs to be public for access by macros.
+ *
+ * @param level log level
+ * @param marker marker or `null`
+ * @param message message
+ * @param cause cause or `null`
+ */
+ def logMessage(level: Level, marker: Marker, message: AnyRef, cause: Throwable): Unit = {
+ delegate.logMessage(Logger.FQCN, level, marker, delegate.getMessageFactory.asInstanceOf[MessageFactory2].newMessage(message), cause)
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/92caaa55/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..24b3c8c
--- /dev/null
+++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala
@@ -0,0 +1,425 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.scala
+
+import org.apache.logging.log4j.message.{EntryMessage, Message}
+import org.apache.logging.log4j.spi.AbstractLogger
+import org.apache.logging.log4j.{Level, Marker}
+
+import scala.language.experimental.macros
+import scala.reflect.macros.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)
+ }
+ )
+
+
+ def traceEntry(c: LoggerContext)(): c.Expr[EntryMessage] =
+ c.universe.reify(
+ c.prefix.splice.delegate.traceEntry()
+ )
+
+ def traceEntryParams(c: LoggerContext)(params: c.Expr[AnyRef]*): c.Expr[EntryMessage] = {
+ import c.universe._
+ val isEnabled = Apply(
+ Select(Select(c.prefix.tree, newTermName("delegate")), newTermName("isEnabled")),
+ List(
+ reify(Level.TRACE).tree,
+ reify(AbstractLogger.ENTRY_MARKER).tree,
+ reify(null: AnyRef).tree,
+ reify(null).tree
+ )
+ )
+
+ val log = Apply(
+ Select(Select(c.prefix.tree, newTermName("delegate")), newTermName("traceEntry")),
+ reify(null: String).tree :: (params map (_.tree)).toList
+ )
+ c.Expr[EntryMessage](If(isEnabled, log, reify(null).tree))
+ }
+
+
+ def traceEntryMessage(c: LoggerContext)(message: c.Expr[Message]): c.Expr[EntryMessage] =
+ c.universe.reify(
+ if (c.prefix.splice.delegate.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null: AnyRef, null)) {
+ c.prefix.splice.delegate.traceEntry(message.splice) // TODO should not do ifEnabled check
+ } else {
+ null
+ }
+ )
+
+ def traceExit(c: LoggerContext)(): c.Expr[Unit] =
+ c.universe.reify(
+ c.prefix.splice.delegate.traceExit()
+ )
+
+ def traceExitResult[R: c.WeakTypeTag](c: LoggerContext)(result: c.Expr[R]): c.Expr[R] =
+ c.universe.reify(
+ c.prefix.splice.delegate.traceExit(result.splice)
+ )
+
+ def traceExitEntryMessage(c: LoggerContext)(entryMessage: c.Expr[EntryMessage]): c.Expr[Unit] =
+ c.universe.reify(
+ c.prefix.splice.delegate.traceExit(entryMessage.splice)
+ )
+
+ def traceExitEntryMessageResult[R: c.WeakTypeTag](c: LoggerContext)(entryMessage: c.Expr[EntryMessage], result: c.Expr[R]): c.Expr[R] =
+ c.universe.reify(
+ c.prefix.splice.delegate.traceExit(entryMessage.splice, result.splice)
+ )
+
+ def traceExitMessageResult[R: c.WeakTypeTag](c: LoggerContext)(message: c.Expr[Message], result: c.Expr[R]): c.Expr[R] =
+ c.universe.reify(
+ {
+ if (message.splice != null && c.prefix.splice.delegate.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, message.splice, null)) {
+ c.prefix.splice.delegate.traceExit(message.splice, result.splice) // TODO should not do ifEnabled check
+ }
+ result.splice
+ }
+ )
+
+ def throwing[T <: Throwable: c.WeakTypeTag](c: LoggerContext)(t: c.Expr[T]): c.Expr[T] =
+ c.universe.reify(
+ c.prefix.splice.delegate.throwing(t.splice)
+ )
+
+ def throwingLevel[T <: Throwable: c.WeakTypeTag](c: LoggerContext)(level: c.Expr[Level], t: c.Expr[T]): c.Expr[T] =
+ c.universe.reify(
+ c.prefix.splice.delegate.throwing(level.splice, t.splice)
+ )
+
+ def catching(c: LoggerContext)(t: c.Expr[Throwable]): c.Expr[Unit] =
+ c.universe.reify(
+ c.prefix.splice.delegate.catching(t.splice)
+ )
+
+ def catchingLevel(c: LoggerContext)(level: c.Expr[Level], t: c.Expr[Throwable]): c.Expr[Unit] =
+ c.universe.reify(
+ c.prefix.splice.delegate.catching(level.splice, t.splice)
+ )
+
+}
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/92caaa55/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..b017de7
--- /dev/null
+++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logging.scala
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.scala
+
+/**
+ * Mix in this trait into classes from which you want to log,
+ * give you a `logger` value with a [[Logger]] named according to the class.
+ */
+trait Logging {
+
+ /**
+ * A [[Logger]] named according to the class.
+ */
+ protected val logger: Logger = Logger(getClass)
+
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/92caaa55/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..bd12742
--- /dev/null
+++ b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala
@@ -0,0 +1,552 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.scala
+
+import org.apache.logging.log4j.message.{DefaultFlowMessageFactory, Message, ParameterizedMessage, ParameterizedMessageFactory}
+import org.apache.logging.log4j.spi.{AbstractLogger, ExtendedLogger}
+import org.apache.logging.log4j.{Level, Marker, MarkerManager}
+import org.junit.runner.RunWith
+import org.mockito.Matchers.{any, anyString, eq => eqv}
+import org.mockito.Mockito._
+import org.scalatest.junit.JUnitRunner
+import org.scalatest.mockito.MockitoSugar
+import org.scalatest.{FunSuite, Matchers}
+
+import scala.language.reflectiveCalls // needed for Mockito mocking
+
+case class Custom(i: Int)
+
+trait Manager {
+ def fetchValue(): Int
+}
+
+@RunWith(classOf[JUnitRunner])
+class LoggerTest extends FunSuite with Matchers with MockitoSugar {
+
+ val msg = new ParameterizedMessage("msg {}", 17)
+ val entryMsg = new DefaultFlowMessageFactory().newEntryMessage(msg)
+ val cseqMsg: CharSequence = new StringBuilder().append("cseq msg")
+ val objectMsg = Custom(17)
+ val cause = new RuntimeException("cause")
+ val marker = MarkerManager.getMarker("marker")
+ val result = "foo"
+
+ def fixture =
+ new {
+ val mockLogger = {
+ val mockLogger = mock[ExtendedLogger]
+ when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory)
+ mockLogger
+ }
+ val manager = {
+ val mockManager = mock[Manager]
+ when(mockManager.fetchValue()).thenReturn(4711)
+ mockManager
+ }
+ }
+
+ test("fatal enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.FATAL), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("fatal disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("error enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.error(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.ERROR), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("error disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.error(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("warn enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.WARN), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("warn disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("info enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.info(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("info disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.info(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("debug enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.DEBUG), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("debug disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("trace enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.TRACE), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("trace disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+
+ test("log enabled with Message message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, msg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null))
+ }
+
+ test("log disabled with Message message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, msg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with String message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("log disabled with String message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("log enabled with CharSequence message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, cseqMsg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ }
+
+ test("log disabled with CharSequence message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, cseqMsg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Object message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, objectMsg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ }
+
+ test("log disabled with Object message and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, objectMsg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Message message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, msg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause))
+ }
+
+ test("log disabled with Message message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, msg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with String message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ verify(f.manager).fetchValue()
+ }
+
+ test("log disabled with String message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("log enabled with CharSequence message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, cseqMsg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ }
+
+ test("log disabled with CharSequence message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, cseqMsg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Object message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, objectMsg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ }
+
+ test("log disabled with Object message and cause and Marker") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, marker, objectMsg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Message message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, msg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(null))
+ }
+
+ test("log disabled with Message message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, msg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
+ }
+
+ test("log disabled with String message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("log enabled with CharSequence message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, cseqMsg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ }
+
+ test("log disabled with CharSequence message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, cseqMsg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Object message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, objectMsg)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ }
+
+ test("log disabled with Object message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, objectMsg)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Message message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, msg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause))
+ }
+
+ test("log disabled with Message message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, msg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with String message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ verify(f.manager).fetchValue()
+ }
+
+ test("log disabled with String message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
+ }
+
+ test("log enabled with CharSequence message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, cseqMsg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ }
+
+ test("log disabled with CharSequence message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, cseqMsg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+ test("log enabled with Object message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, objectMsg, cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ }
+
+ test("log disabled with Object message and cause") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger(Level.INFO, objectMsg, cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ }
+
+
+ test("traceEntry") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceEntry()
+ verify(f.mockLogger).traceEntry()
+ }
+
+ test("traceEntry enabled with params") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceEntry("foo", "bar")
+ verify(f.mockLogger).traceEntry(null: String, "foo", "bar")
+ }
+
+ test("traceEntry disabled with params") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.traceEntry("foo", "bar")
+ verify(f.mockLogger, never).traceEntry(anyString(), anyString(), anyString())
+ }
+
+ test("traceEntry enabled with message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceEntry(msg)
+ verify(f.mockLogger).traceEntry(eqv(msg))
+ }
+
+ test("traceEntry disabled with message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.traceEntry(msg)
+ verify(f.mockLogger, never).traceEntry(any[Message])
+ }
+
+ test("traceExit") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit()
+ verify(f.mockLogger).traceExit()
+ }
+
+ test("traceExit with result") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit(result)
+ verify(f.mockLogger).traceExit(result)
+ }
+
+ test("traceExit with entrymessage") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit(entryMsg)
+ verify(f.mockLogger).traceExit(entryMsg)
+ }
+
+ test("traceExit with entrymessage and result") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit(entryMsg, result)
+ verify(f.mockLogger).traceExit(entryMsg, result)
+ }
+
+ test("traceExit enabled with message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit(msg, result)
+ verify(f.mockLogger).traceExit(eqv(msg), eqv(result))
+ }
+
+ test("traceExit disabled with message") {
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false)
+ val logger = Logger(f.mockLogger)
+ logger.traceExit(msg, result)
+ verify(f.mockLogger, never).traceExit(any[Message], any[AnyRef])
+ }
+
+ test("throwing") {
+ val f = fixture
+ val logger = Logger(f.mockLogger)
+ logger.throwing(cause)
+ verify(f.mockLogger).throwing(eqv(cause))
+ }
+
+ test("throwing with level") {
+ val f = fixture
+ val logger = Logger(f.mockLogger)
+ logger.throwing(Level.INFO, cause)
+ verify(f.mockLogger).throwing(eqv(Level.INFO), eqv(cause))
+ }
+
+ test("catching") {
+ val f = fixture
+ val logger = Logger(f.mockLogger)
+ logger.catching(cause)
+ verify(f.mockLogger).catching(eqv(cause))
+ }
+
+ test("catching with level") {
+ val f = fixture
+ val logger = Logger(f.mockLogger)
+ logger.catching(Level.INFO, cause)
+ verify(f.mockLogger).catching(eqv(Level.INFO), eqv(cause))
+ }
+
+}