http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/72fe94f7/api/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala ---------------------------------------------------------------------- diff --git a/api/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/api/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala deleted file mode 100644 index bd12742..0000000 --- a/api/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala +++ /dev/null @@ -1,552 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache license, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the license for the specific language governing permissions and - * limitations under the license. - */ -package org.apache.logging.log4j.scala - -import org.apache.logging.log4j.message.{DefaultFlowMessageFactory, Message, ParameterizedMessage, ParameterizedMessageFactory} -import org.apache.logging.log4j.spi.{AbstractLogger, ExtendedLogger} -import org.apache.logging.log4j.{Level, Marker, MarkerManager} -import org.junit.runner.RunWith -import org.mockito.Matchers.{any, anyString, eq => eqv} -import org.mockito.Mockito._ -import org.scalatest.junit.JUnitRunner -import org.scalatest.mockito.MockitoSugar -import org.scalatest.{FunSuite, Matchers} - -import scala.language.reflectiveCalls // needed for Mockito mocking - -case class Custom(i: Int) - -trait Manager { - def fetchValue(): Int -} - -@RunWith(classOf[JUnitRunner]) -class LoggerTest extends FunSuite with Matchers with MockitoSugar { - - val msg = new ParameterizedMessage("msg {}", 17) - val entryMsg = new DefaultFlowMessageFactory().newEntryMessage(msg) - val cseqMsg: CharSequence = new StringBuilder().append("cseq msg") - val objectMsg = Custom(17) - val cause = new RuntimeException("cause") - val marker = MarkerManager.getMarker("marker") - val result = "foo" - - def fixture = - new { - val mockLogger = { - val mockLogger = mock[ExtendedLogger] - when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory) - mockLogger - } - val manager = { - val mockManager = mock[Manager] - when(mockManager.fetchValue()).thenReturn(4711) - mockManager - } - } - - test("fatal enabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.fatal(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger).logMessage(anyString(), eqv(Level.FATAL), eqv(null), any[Message], eqv(null)) - verify(f.manager).fetchValue() - } - - test("fatal disabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger.fatal(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - verify(f.manager, never).fetchValue() - } - - test("error enabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.error(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger).logMessage(anyString(), eqv(Level.ERROR), eqv(null), any[Message], eqv(null)) - verify(f.manager).fetchValue() - } - - test("error disabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger.error(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - verify(f.manager, never).fetchValue() - } - - test("warn enabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.warn(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger).logMessage(anyString(), eqv(Level.WARN), eqv(null), any[Message], eqv(null)) - verify(f.manager).fetchValue() - } - - test("warn disabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger.warn(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - verify(f.manager, never).fetchValue() - } - - test("info enabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.info(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) - verify(f.manager).fetchValue() - } - - test("info disabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger.info(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - verify(f.manager, never).fetchValue() - } - - test("debug enabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.debug(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger).logMessage(anyString(), eqv(Level.DEBUG), eqv(null), any[Message], eqv(null)) - verify(f.manager).fetchValue() - } - - test("debug disabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger.debug(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - verify(f.manager, never).fetchValue() - } - - test("trace enabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.trace(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger).logMessage(anyString(), eqv(Level.TRACE), eqv(null), any[Message], eqv(null)) - verify(f.manager).fetchValue() - } - - test("trace disabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger.trace(s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - verify(f.manager, never).fetchValue() - } - - - test("log enabled with Message message and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, msg) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null)) - } - - test("log disabled with Message message and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, msg) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with String message and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) - verify(f.manager).fetchValue() - } - - test("log disabled with String message and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - verify(f.manager, never).fetchValue() - } - - test("log enabled with CharSequence message and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, cseqMsg) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) - } - - test("log disabled with CharSequence message and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, cseqMsg) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with Object message and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, objectMsg) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null)) - } - - test("log disabled with Object message and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, objectMsg) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with Message message and cause and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, msg, cause) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause)) - } - - test("log disabled with Message message and cause and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, msg, cause) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with String message and cause and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}", cause) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) - verify(f.manager).fetchValue() - } - - test("log disabled with String message and cause and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}", cause) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - verify(f.manager, never).fetchValue() - } - - test("log enabled with CharSequence message and cause and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, cseqMsg, cause) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) - } - - test("log disabled with CharSequence message and cause and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, cseqMsg, cause) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with Object message and cause and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, objectMsg, cause) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause)) - } - - test("log disabled with Object message and cause and Marker") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, marker, objectMsg, cause) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with Message message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, msg) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(null)) - } - - test("log disabled with Message message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, msg) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) - verify(f.manager).fetchValue() - } - - test("log disabled with String message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}") - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - verify(f.manager, never).fetchValue() - } - - test("log enabled with CharSequence message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, cseqMsg) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) - } - - test("log disabled with CharSequence message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, cseqMsg) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with Object message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, objectMsg) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null)) - } - - test("log disabled with Object message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, objectMsg) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with Message message and cause") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, msg, cause) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause)) - } - - test("log disabled with Message message and cause") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, msg, cause) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with String message and cause") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}", cause) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) - verify(f.manager).fetchValue() - } - - test("log disabled with String message and cause") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}", cause) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - verify(f.manager, never).fetchValue() - } - - test("log enabled with CharSequence message and cause") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, cseqMsg, cause) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) - } - - test("log disabled with CharSequence message and cause") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, cseqMsg, cause) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - test("log enabled with Object message and cause") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger(Level.INFO, objectMsg, cause) - verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause)) - } - - test("log disabled with Object message and cause") { - val f = fixture - when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger(Level.INFO, objectMsg, cause) - verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable]) - } - - - test("traceEntry") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.traceEntry() - verify(f.mockLogger).traceEntry() - } - - test("traceEntry enabled with params") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.traceEntry("foo", "bar") - verify(f.mockLogger).traceEntry(null: String, "foo", "bar") - } - - test("traceEntry disabled with params") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger.traceEntry("foo", "bar") - verify(f.mockLogger, never).traceEntry(anyString(), anyString(), anyString()) - } - - test("traceEntry enabled with message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.traceEntry(msg) - verify(f.mockLogger).traceEntry(eqv(msg)) - } - - test("traceEntry disabled with message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger.traceEntry(msg) - verify(f.mockLogger, never).traceEntry(any[Message]) - } - - test("traceExit") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.traceExit() - verify(f.mockLogger).traceExit() - } - - test("traceExit with result") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.traceExit(result) - verify(f.mockLogger).traceExit(result) - } - - test("traceExit with entrymessage") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.traceExit(entryMsg) - verify(f.mockLogger).traceExit(entryMsg) - } - - test("traceExit with entrymessage and result") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.traceExit(entryMsg, result) - verify(f.mockLogger).traceExit(entryMsg, result) - } - - test("traceExit enabled with message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) - val logger = Logger(f.mockLogger) - logger.traceExit(msg, result) - verify(f.mockLogger).traceExit(eqv(msg), eqv(result)) - } - - test("traceExit disabled with message") { - val f = fixture - when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false) - val logger = Logger(f.mockLogger) - logger.traceExit(msg, result) - verify(f.mockLogger, never).traceExit(any[Message], any[AnyRef]) - } - - test("throwing") { - val f = fixture - val logger = Logger(f.mockLogger) - logger.throwing(cause) - verify(f.mockLogger).throwing(eqv(cause)) - } - - test("throwing with level") { - val f = fixture - val logger = Logger(f.mockLogger) - logger.throwing(Level.INFO, cause) - verify(f.mockLogger).throwing(eqv(Level.INFO), eqv(cause)) - } - - test("catching") { - val f = fixture - val logger = Logger(f.mockLogger) - logger.catching(cause) - verify(f.mockLogger).catching(eqv(cause)) - } - - test("catching with level") { - val f = fixture - val logger = Logger(f.mockLogger) - logger.catching(Level.INFO, cause) - verify(f.mockLogger).catching(eqv(Level.INFO), eqv(cause)) - } - -}
http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/72fe94f7/api/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala ---------------------------------------------------------------------- diff --git a/api/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala b/api/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala deleted file mode 100644 index 80ca940..0000000 --- a/api/src/test/scala/org/apache/logging/log4j/scala/LoggingContextTest.scala +++ /dev/null @@ -1,115 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache license, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the license for the specific language governing permissions and - * limitations under the license. - */ -package org.apache.logging.log4j.scala - -import org.junit.runner.RunWith -import org.scalatest.junit.JUnitRunner -import org.scalatest.{FunSuite, Matchers} - -import scala.collection.mutable - -@RunWith(classOf[JUnitRunner]) -class LoggingContextTest extends FunSuite with Matchers { - - test("put single, contains, get") { - LoggingContext += "key" -> "value" - - LoggingContext.contains("key") shouldBe true - LoggingContext.get("key") shouldBe Some("value") - LoggingContext.contains("bogus") shouldBe false - LoggingContext.get("bogus") shouldBe None - } - - test("put multiple 1") { - LoggingContext += ("key1" -> "value1", "key2" -> "value2") - - LoggingContext.get("key1") shouldBe Some("value1") - LoggingContext.get("key2") shouldBe Some("value2") - } - - test("put multiple 2") { - LoggingContext ++= Seq("key1" -> "value1", "key2" -> "value2") - - LoggingContext.get("key1") shouldBe Some("value1") - LoggingContext.get("key2") shouldBe Some("value2") - } - - test("remove single") { - LoggingContext += ("key1" -> "value1") - LoggingContext += ("key2" -> "value2") - LoggingContext += ("key3" -> "value3") - - LoggingContext -= "key1" - - LoggingContext.get("key1") shouldBe None - LoggingContext.get("key2") shouldBe Some("value2") - LoggingContext.get("key3") shouldBe Some("value3") - } - - test("remove multiple 1") { - LoggingContext += ("key1" -> "value1") - LoggingContext += ("key2" -> "value2") - LoggingContext += ("key3" -> "value3") - - LoggingContext -= ("key1", "key2") - - LoggingContext.get("key1") shouldBe None - LoggingContext.get("key2") shouldBe None - LoggingContext.get("key3") shouldBe Some("value3") - } - - test("remove multiple 2") { - LoggingContext += ("key1" -> "value1") - LoggingContext += ("key2" -> "value2") - LoggingContext += ("key3" -> "value3") - - LoggingContext --= Seq("key1", "key2") - - LoggingContext.get("key1") shouldBe None - LoggingContext.get("key2") shouldBe None - LoggingContext.get("key3") shouldBe Some("value3") - } - - test("clear, size, isEmpty") { - LoggingContext += ("key" -> "value") - - LoggingContext.clear() - - LoggingContext.contains("key") shouldBe false - LoggingContext.size shouldBe 0 - LoggingContext.isEmpty shouldBe true - } - - test("iterator") { - LoggingContext += ("key1" -> "value1") - LoggingContext += ("key2" -> "value2") - - LoggingContext.iterator.toSet shouldBe Set("key1" -> "value1", "key2" -> "value2") - } - - test("foreach") { - LoggingContext += ("key1" -> "value1") - LoggingContext += ("key2" -> "value2") - - val result = mutable.Set.empty[(String, String)] - - LoggingContext.foreach { result += _ } - - result shouldBe Set("key1" -> "value1", "key2" -> "value2") - } - -} http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/72fe94f7/build.sbt ---------------------------------------------------------------------- diff --git a/build.sbt b/build.sbt index c95f3d3..5cc1c21 100644 --- a/build.sbt +++ b/build.sbt @@ -1,64 +1,104 @@ import Dependencies._ -name := "Log4j Scala API" -organization in ThisBuild := "org.apache.logging.log4j" -organizationName in ThisBuild := "Apache Software Foundation" -organizationHomepage in ThisBuild := Some(url("https://www.apache.org/";)) -homepage in ThisBuild := Some(url("https://logging.apache.org/log4j/scala/";)) -licenses in ThisBuild := Seq("Apache License, Version 2.0" -> url("https://www.apache.org/licenses/LICENSE-2.0.txt";)) -scmInfo in ThisBuild := Some(ScmInfo( - url("https://git-wip-us.apache.org/repos/asf?p=logging-log4j-scala.git;a=summary";), - "scm:git:http://git-wip-us.apache.org/repos/asf/logging-log4j-scala.git";, - "scm:git:https://git-wip-us.apache.org/repos/asf/logging-log4j-scala.git"; -)) +lazy val metadataSettings = Seq( + organization := "org.apache.logging.log4j", + organizationName := "Apache Software Foundation", + organizationHomepage := Some(url("https://www.apache.org/";)), + homepage := Some(url("https://logging.apache.org/log4j/scala/";)), + licenses := Seq("Apache License, Version 2.0" -> url("https://www.apache.org/licenses/LICENSE-2.0.txt";)), + scmInfo := Some(ScmInfo( + url("https://git-wip-us.apache.org/repos/asf?p=logging-log4j-scala.git;a=summary";), + "scm:git:http://git-wip-us.apache.org/repos/asf/logging-log4j-scala.git";, + "scm:git:https://git-wip-us.apache.org/repos/asf/logging-log4j-scala.git"; + )), + pomExtra := { + <parent> + <groupId>org.apache.logging</groupId> + <artifactId>logging-parent</artifactId> + <version>2</version> + </parent> + <developers> + <developer> + <id>mikes</id> + <name>Mikael Ståldal</name> + </developer> + <developer> + <id>mattsicker</id> + <name>Matt Sicker</name> + </developer> + <developer> + <id>ggregory</id> + <name>Gary Gregory</name> + </developer> + </developers> + } +) -lazy val commonSettings = Seq( - scalacOptions := Seq("-feature", "-unchecked", "-deprecation") +lazy val compileSettings = Seq( + scalacOptions := Seq("-feature", "-unchecked", "-deprecation"), + scalaVersion := scala211, + crossScalaVersions := Seq(scala210, scala211, scala212, scala213) ) lazy val publishSettings = Seq( publishMavenStyle := true, publishArtifact in Test := false, publishTo := { - if (version.value.endsWith("-SNAPSHOT")) { + if (isSnapshot.value) { Some("Apache Snapshots" at "https://repository.apache.org/content/repositories/snapshots";) } else { Some("Apache Releases" at "https://repository.apache.org/service/local/staging/deploy/maven2";) } - } + }, + credentials += Credentials(Path.userHome / ".ivy2" / ".credentials"), +// managedResources +// resourceGenerators in Compile += inlineTask(Seq(file("LICENSE.txt"), file("NOTICE.txt"))) ) lazy val releaseSettings = Seq( releaseCrossBuild := true ) -lazy val api = (project in file("api")) - .settings(commonSettings: _*) +lazy val apiDependencies = Seq( + libraryDependencies ++= Seq( + "org.scala-lang" % "scala-reflect" % scalaVersion.value, + "org.apache.logging.log4j" % "log4j-api" % log4j, + "org.apache.logging.log4j" % "log4j-api" % log4j % Test classifier "tests", + "junit" % "junit" % junit % Test, + "org.scalatest" %% "scalatest" % scalatest % Test, + "org.mockito" % "mockito-core" % mockito % Test + ) +) + +lazy val apiInputFiles = Seq( + sources in Compile := { + val filteredFiles = { + for ((_, minor) <- CrossVersion.partialVersion(scalaVersion.value) if minor == 10) + yield ((baseDirectory.value / "src" / "main" / "scala") ** "*Macro.scala").get + }.getOrElse(Seq()) + (sources in Compile).value.filterNot(filteredFiles.contains) + } +) + +lazy val root = (project in file(".")) + .settings(name := "log4j-api-scala") + .settings(metadataSettings: _*) + .settings(compileSettings: _*) .settings(publishSettings: _*) .settings(releaseSettings: _*) - .settings( - name := "log4j-api-scala", - scalaVersion := scala211, - crossScalaVersions := Seq(scala210, scala211, scala212, scala213), - libraryDependencies ++= Seq( - "org.scala-lang" % "scala-reflect" % scalaVersion.value, - "org.apache.logging.log4j" % "log4j-api" % log4j, - "org.apache.logging.log4j" % "log4j-api" % log4j % Test classifier "tests", - "junit" % "junit" % junit % Test, - "org.scalatest" %% "scalatest" % scalatest % Test, - "org.mockito" % "mockito-core" % mockito % Test - ), - excludeFilter in Compile := new FileFilter { - // override LoggerMacro for Scala 2.10 - override def accept(pathname: File): Boolean = { - val Some((_, minor)) = CrossVersion.partialVersion(scalaVersion.value) - minor == 10 && pathname.getName == "LoggerMacro.scala" && pathname.getParent.endsWith("src/main/scala/org/apache/logging/log4j/scala") - } - } - ) + .settings(apiDependencies: _*) + .settings(apiInputFiles: _*) + +//lazy val nopublish = Seq( +// publish := {}, +// publishLocal := {}, +// publishM2 := {}, +// skip in publish := true +//) //lazy val sample = (project in file("sample")) -// .settings(commonSettings) +// .settings(metadataSettings: _*) +// .settings(nopublish: _*) // .settings( // name := "log4j-api-scala-sample", // scalaVersion := scala212, @@ -67,26 +107,5 @@ lazy val api = (project in file("api")) // "org.apache.logging.log4j" % "log4j-core" % log4j % Runtime // ) // ) -// .dependsOn(api) +// .dependsOn(root) -pomExtra in ThisBuild := { - <parent> - <groupId>org.apache.logging</groupId> - <artifactId>logging-parent</artifactId> - <version>2</version> - </parent> - <developers> - <developer> - <id>mikes</id> - <name>Mikael Ståldal</name> - </developer> - <developer> - <id>mattsicker</id> - <name>Matt Sicker</name> - </developer> - <developer> - <id>ggregory</id> - <name>Gary Gregory</name> - </developer> - </developers> -} http://git-wip-us.apache.org/repos/asf/logging-log4j-scala/blob/72fe94f7/src/main/scala-2.10/org/apache/logging/log4j/scala/LoggerMacro.scala ---------------------------------------------------------------------- diff --git a/src/main/scala-2.10/org/apache/logging/log4j/scala/LoggerMacro.scala b/src/main/scala-2.10/org/apache/logging/log4j/scala/LoggerMacro.scala new file mode 100644 index 0000000..24b3c8c --- /dev/null +++ b/src/main/scala-2.10/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/72fe94f7/src/main/scala/org/apache/logging/log4j/scala/Logger.scala ---------------------------------------------------------------------- diff --git a/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/src/main/scala/org/apache/logging/log4j/scala/Logger.scala new file mode 100644 index 0000000..b42cd5a --- /dev/null +++ b/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) + } + +}
