From 508d59ea5e2865a5bfc6d380527b1ab91e0fddd5 Mon Sep 17 00:00:00 2001 From: John St John Date: Mon, 25 Sep 2017 15:22:20 -0700 Subject: Pull in slickmdc --- .../driver/core/database/MdcAsyncExecutor.scala | 46 ++++++++++++++++++++++ .../driver/core/database/MdcExecutionContext.scala | 28 +++++++++++++ 2 files changed, 74 insertions(+) create mode 100644 src/main/scala/xyz/driver/core/database/MdcAsyncExecutor.scala create mode 100644 src/main/scala/xyz/driver/core/database/MdcExecutionContext.scala diff --git a/src/main/scala/xyz/driver/core/database/MdcAsyncExecutor.scala b/src/main/scala/xyz/driver/core/database/MdcAsyncExecutor.scala new file mode 100644 index 0000000..ac8456e --- /dev/null +++ b/src/main/scala/xyz/driver/core/database/MdcAsyncExecutor.scala @@ -0,0 +1,46 @@ +package xyz.driver.core.database + +import java.util.concurrent._ +import java.util.concurrent.atomic.AtomicInteger + +import scala.concurrent._ +import com.typesafe.scalalogging.StrictLogging +import slick.util.AsyncExecutor + +/** Taken from the original Slick AsyncExecutor and simplified + * @see https://github.com/slick/slick/blob/3.1/slick/src/main/scala/slick/util/AsyncExecutor.scala + */ +object MdcAsyncExecutor extends StrictLogging { + + /** Create an AsyncExecutor with a fixed-size thread pool. + * + * @param name The name for the thread pool. + * @param numThreads The number of threads in the pool. + */ + def apply(name: String, numThreads: Int): AsyncExecutor = { + new AsyncExecutor { + val tf = new DaemonThreadFactory(name + "-") + + lazy val executionContext = { + new MdcExecutionContext(ExecutionContext.fromExecutor(Executors.newFixedThreadPool(numThreads, tf))) + } + + def close(): Unit = {} + } + } + + def default(name: String = "AsyncExecutor.default"): AsyncExecutor = apply(name, 20) + + private class DaemonThreadFactory(namePrefix: String) extends ThreadFactory { + private[this] val group = + Option(System.getSecurityManager).fold(Thread.currentThread.getThreadGroup)(_.getThreadGroup) + private[this] val threadNumber = new AtomicInteger(1) + + def newThread(r: Runnable): Thread = { + val t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement, 0) + if (!t.isDaemon) t.setDaemon(true) + if (t.getPriority != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY) + t + } + } +} diff --git a/src/main/scala/xyz/driver/core/database/MdcExecutionContext.scala b/src/main/scala/xyz/driver/core/database/MdcExecutionContext.scala new file mode 100644 index 0000000..f08f16c --- /dev/null +++ b/src/main/scala/xyz/driver/core/database/MdcExecutionContext.scala @@ -0,0 +1,28 @@ +package xyz.driver.core.database + +import org.slf4j.MDC +import scala.concurrent.ExecutionContext + +/** + * Execution context proxy for propagating SLF4J diagnostic context from caller thread to execution thread. + */ +class MdcExecutionContext(executionContext: ExecutionContext) extends ExecutionContext { + override def execute(runnable: Runnable): Unit = { + val callerMdc = MDC.getCopyOfContextMap + executionContext.execute(new Runnable { + def run(): Unit = { + // copy caller thread diagnostic context to execution thread + // scalastyle:off + if (callerMdc != null) MDC.setContextMap(callerMdc) + try { + runnable.run() + } finally { + // the thread might be reused, so we clean up for the next use + MDC.clear() + } + } + }) + } + + override def reportFailure(cause: Throwable): Unit = executionContext.reportFailure(cause) +} -- cgit v1.2.3 From 8d975a4d3681d0ba41bd8272f572a78de62e7f89 Mon Sep 17 00:00:00 2001 From: Stewart Stewart Date: Mon, 25 Sep 2017 18:51:53 -0700 Subject: Add MdcExecutionContext to logging pacagke --- .../driver/core/database/MdcAsyncExecutor.scala | 9 +++- .../driver/core/database/MdcExecutionContext.scala | 28 ---------- src/main/scala/xyz/driver/core/logging.scala | 63 ---------------------- .../xyz/driver/core/logging/DriverLayout.scala | 58 ++++++++++++++++++++ .../driver/core/logging/MdcExecutionContext.scala | 32 +++++++++++ .../scala/xyz/driver/core/logging/package.scala | 7 +++ 6 files changed, 105 insertions(+), 92 deletions(-) delete mode 100644 src/main/scala/xyz/driver/core/database/MdcExecutionContext.scala delete mode 100644 src/main/scala/xyz/driver/core/logging.scala create mode 100644 src/main/scala/xyz/driver/core/logging/DriverLayout.scala create mode 100644 src/main/scala/xyz/driver/core/logging/MdcExecutionContext.scala create mode 100644 src/main/scala/xyz/driver/core/logging/package.scala diff --git a/src/main/scala/xyz/driver/core/database/MdcAsyncExecutor.scala b/src/main/scala/xyz/driver/core/database/MdcAsyncExecutor.scala index ac8456e..5939efb 100644 --- a/src/main/scala/xyz/driver/core/database/MdcAsyncExecutor.scala +++ b/src/main/scala/xyz/driver/core/database/MdcAsyncExecutor.scala @@ -1,4 +1,9 @@ -package xyz.driver.core.database +/** Code ported from "de.geekonaut" %% "slickmdc" % "1.0.0" + * License: @see https://github.com/AVGP/slickmdc/blob/master/LICENSE + * Blog post: @see http://50linesofco.de/post/2016-07-01-slick-and-slf4j-mdc-logging-in-scala.html + */ +package xyz.driver.core +package database import java.util.concurrent._ import java.util.concurrent.atomic.AtomicInteger @@ -7,6 +12,8 @@ import scala.concurrent._ import com.typesafe.scalalogging.StrictLogging import slick.util.AsyncExecutor +import logging.MdcExecutionContext + /** Taken from the original Slick AsyncExecutor and simplified * @see https://github.com/slick/slick/blob/3.1/slick/src/main/scala/slick/util/AsyncExecutor.scala */ diff --git a/src/main/scala/xyz/driver/core/database/MdcExecutionContext.scala b/src/main/scala/xyz/driver/core/database/MdcExecutionContext.scala deleted file mode 100644 index f08f16c..0000000 --- a/src/main/scala/xyz/driver/core/database/MdcExecutionContext.scala +++ /dev/null @@ -1,28 +0,0 @@ -package xyz.driver.core.database - -import org.slf4j.MDC -import scala.concurrent.ExecutionContext - -/** - * Execution context proxy for propagating SLF4J diagnostic context from caller thread to execution thread. - */ -class MdcExecutionContext(executionContext: ExecutionContext) extends ExecutionContext { - override def execute(runnable: Runnable): Unit = { - val callerMdc = MDC.getCopyOfContextMap - executionContext.execute(new Runnable { - def run(): Unit = { - // copy caller thread diagnostic context to execution thread - // scalastyle:off - if (callerMdc != null) MDC.setContextMap(callerMdc) - try { - runnable.run() - } finally { - // the thread might be reused, so we clean up for the next use - MDC.clear() - } - } - }) - } - - override def reportFailure(cause: Throwable): Unit = executionContext.reportFailure(cause) -} diff --git a/src/main/scala/xyz/driver/core/logging.scala b/src/main/scala/xyz/driver/core/logging.scala deleted file mode 100644 index 9a5805d..0000000 --- a/src/main/scala/xyz/driver/core/logging.scala +++ /dev/null @@ -1,63 +0,0 @@ -package xyz.driver.core - -import java.text.SimpleDateFormat -import java.util.Date - -import ch.qos.logback.classic.spi.ILoggingEvent -import ch.qos.logback.core.LayoutBase -import org.apache.commons.lang3.StringUtils -import org.slf4j.helpers.NOPLogger - -object logging { - - val NoLogger = com.typesafe.scalalogging.Logger(NOPLogger.NOP_LOGGER) - - class DriverLayout extends LayoutBase[ILoggingEvent] { - import scala.collection.JavaConverters._ - - private val FieldSeparator = "=" - private val DateFormatString = "MM/dd/yyyy HH:mm:ss" - private val newline = System.getProperty("line.separator") - private val IgnoredClassesInStack = Set("org.apache.catalina", "org.apache.coyote", "sun.reflect", "javax.servlet") - - override def doLayout(loggingEvent: ILoggingEvent): String = { - - val date = new SimpleDateFormat(DateFormatString).format(new Date(loggingEvent.getTimeStamp)) - val level = StringUtils.rightPad(loggingEvent.getLevel.toString, 5) - - val message = new StringBuilder(s"$date [$level] - ${loggingEvent.getMessage}$newline") - - logContext(message, loggingEvent) - - Option(loggingEvent.getCallerData) foreach { stacktrace => - val stacktraceLength = stacktrace.length - - if (stacktraceLength > 0) { - val location = stacktrace.head - - val _ = message - .append(s"Location: ${location.getClassName}.${location.getMethodName}:${location.getLineNumber}$newline") - .append(s"Exception: ${location.toString}$newline") - - if (stacktraceLength > 1) { - message.append(stacktrace.tail.filterNot { e => - IgnoredClassesInStack.forall(ignored => !e.getClassName.startsWith(ignored)) - } map { - _.toString - } mkString newline) - } - } - } - - message.toString - } - - private def logContext(message: StringBuilder, loggingEvent: ILoggingEvent) = { - Option(loggingEvent.getMDCPropertyMap).map(_.asScala).filter(_.nonEmpty).foreach { context => - message.append( - context map { case (key, value) => s"$key$FieldSeparator$value" } mkString ("Context: ", " ", newline) - ) - } - } - } -} diff --git a/src/main/scala/xyz/driver/core/logging/DriverLayout.scala b/src/main/scala/xyz/driver/core/logging/DriverLayout.scala new file mode 100644 index 0000000..5e6c7df --- /dev/null +++ b/src/main/scala/xyz/driver/core/logging/DriverLayout.scala @@ -0,0 +1,58 @@ +package xyz.driver.core +package logging + +import java.text.SimpleDateFormat +import java.util.Date + +import ch.qos.logback.classic.spi.ILoggingEvent +import ch.qos.logback.core.LayoutBase +import org.apache.commons.lang3.StringUtils + +class DriverLayout extends LayoutBase[ILoggingEvent] { + import scala.collection.JavaConverters._ + + private val FieldSeparator = "=" + private val DateFormatString = "MM/dd/yyyy HH:mm:ss" + private val newline = System.getProperty("line.separator") + private val IgnoredClassesInStack = Set("org.apache.catalina", "org.apache.coyote", "sun.reflect", "javax.servlet") + + override def doLayout(loggingEvent: ILoggingEvent): String = { + + val date = new SimpleDateFormat(DateFormatString).format(new Date(loggingEvent.getTimeStamp)) + val level = StringUtils.rightPad(loggingEvent.getLevel.toString, 5) + + val message = new StringBuilder(s"$date [$level] - ${loggingEvent.getMessage}$newline") + + logContext(message, loggingEvent) + + Option(loggingEvent.getCallerData) foreach { stacktrace => + val stacktraceLength = stacktrace.length + + if (stacktraceLength > 0) { + val location = stacktrace.head + + val _ = message + .append(s"Location: ${location.getClassName}.${location.getMethodName}:${location.getLineNumber}$newline") + .append(s"Exception: ${location.toString}$newline") + + if (stacktraceLength > 1) { + message.append(stacktrace.tail.filterNot { e => + IgnoredClassesInStack.forall(ignored => !e.getClassName.startsWith(ignored)) + } map { + _.toString + } mkString newline) + } + } + } + + message.toString + } + + private def logContext(message: StringBuilder, loggingEvent: ILoggingEvent) = { + Option(loggingEvent.getMDCPropertyMap).map(_.asScala).filter(_.nonEmpty).foreach { context => + message.append( + context map { case (key, value) => s"$key$FieldSeparator$value" } mkString ("Context: ", " ", newline) + ) + } + } +} diff --git a/src/main/scala/xyz/driver/core/logging/MdcExecutionContext.scala b/src/main/scala/xyz/driver/core/logging/MdcExecutionContext.scala new file mode 100644 index 0000000..9f8db3e --- /dev/null +++ b/src/main/scala/xyz/driver/core/logging/MdcExecutionContext.scala @@ -0,0 +1,32 @@ +/** Code ported from "de.geekonaut" %% "slickmdc" % "1.0.0" + * License: @see https://github.com/AVGP/slickmdc/blob/master/LICENSE + * Blog post: @see http://50linesofco.de/post/2016-07-01-slick-and-slf4j-mdc-logging-in-scala.html + */ +package xyz.driver.core.logging + +import org.slf4j.MDC +import scala.concurrent.ExecutionContext + +/** + * Execution context proxy for propagating SLF4J diagnostic context from caller thread to execution thread. + */ +class MdcExecutionContext(executionContext: ExecutionContext) extends ExecutionContext { + override def execute(runnable: Runnable): Unit = { + val callerMdc = MDC.getCopyOfContextMap + executionContext.execute(new Runnable { + def run(): Unit = { + // copy caller thread diagnostic context to execution thread + // scalastyle:off + if (callerMdc != null) MDC.setContextMap(callerMdc) + try { + runnable.run() + } finally { + // the thread might be reused, so we clean up for the next use + MDC.clear() + } + } + }) + } + + override def reportFailure(cause: Throwable): Unit = executionContext.reportFailure(cause) +} diff --git a/src/main/scala/xyz/driver/core/logging/package.scala b/src/main/scala/xyz/driver/core/logging/package.scala new file mode 100644 index 0000000..2b6fc11 --- /dev/null +++ b/src/main/scala/xyz/driver/core/logging/package.scala @@ -0,0 +1,7 @@ +package xyz.driver.core + +import org.slf4j.helpers.NOPLogger + +package object logging { + val NoLogger = com.typesafe.scalalogging.Logger(NOPLogger.NOP_LOGGER) +} -- cgit v1.2.3