*/
package org.onap.dcae.collectors.veshv.utils.logging
+import ch.qos.logback.classic.LoggerContext
import kotlin.reflect.KClass
import org.slf4j.LoggerFactory
import org.slf4j.MDC
constructor(clazz: KClass<out Any>) : this(LoggerFactory.getLogger(clazz.java))
constructor(name: String) : this(LoggerFactory.getLogger(name))
- private val errorLogger = if (logger.isErrorEnabled) ErrorLevelLogger(logger) else OffLevelLogger
- private val warnLogger = if (logger.isWarnEnabled) WarnLevelLogger(logger) else OffLevelLogger
- private val infoLogger = if (logger.isInfoEnabled) InfoLevelLogger(logger) else OffLevelLogger
- private val debugLogger = if (logger.isDebugEnabled) DebugLevelLogger(logger) else OffLevelLogger
- private val traceLogger = if (logger.isTraceEnabled) TraceLevelLogger(logger) else OffLevelLogger
+ private val errorLogger by lazy {
+ if (logger.isErrorEnabled) ErrorLevelLogger(logger) else OffLevelLogger
+ }
+ private val warnLogger by lazy {
+ if (logger.isWarnEnabled) WarnLevelLogger(logger) else OffLevelLogger
+ }
+ private val infoLogger by lazy {
+ if (logger.isInfoEnabled) InfoLevelLogger(logger) else OffLevelLogger
+ }
+ private val debugLogger by lazy {
+ if (logger.isDebugEnabled) DebugLevelLogger(logger) else OffLevelLogger
+ }
+ private val traceLogger by lazy {
+ if (logger.isTraceEnabled) TraceLevelLogger(logger) else OffLevelLogger
+ }
// ERROR
fun withError(block: AtLevelLogger.() -> Unit) = errorLogger.block()
fun withError(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
- errorLogger.withMdc(mdc, block)
+ errorLogger.withMdc(mdc, block)
fun error(message: () -> String) = errorLogger.run {
log(message())
}
fun error(mdc: MappedDiagnosticContext, message: () -> String) =
- errorLogger.withMdc(mdc) { log(message()) }
+ errorLogger.withMdc(mdc) { log(message()) }
+
+ fun error(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
+ errorLogger.withMdc(mdc) { log(marker, message()) }
+
+ fun error(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String, t: Throwable) =
+ errorLogger.withMdc(mdc) { log(marker, message(), t) }
// WARN
fun withWarn(block: AtLevelLogger.() -> Unit) = warnLogger.block()
fun withWarn(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
- warnLogger.withMdc(mdc, block)
+ warnLogger.withMdc(mdc, block)
fun warn(message: () -> String) = warnLogger.run {
log(message())
}
fun warn(mdc: MappedDiagnosticContext, message: () -> String) =
- warnLogger.withMdc(mdc) { log(message()) }
+ warnLogger.withMdc(mdc) { log(message()) }
+
+ fun warn(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
+ warnLogger.withMdc(mdc) { log(marker, message()) }
+ fun warn(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String, t: Throwable) =
+ warnLogger.withMdc(mdc) { log(marker, message(), t) }
// INFO
fun withInfo(block: AtLevelLogger.() -> Unit) = infoLogger.block()
fun withInfo(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
- infoLogger.withMdc(mdc, block)
+ infoLogger.withMdc(mdc, block)
fun info(message: () -> String) = infoLogger.run {
log(message())
}
fun info(mdc: MappedDiagnosticContext, message: () -> String) =
- infoLogger.withMdc(mdc) { log(message()) }
+ infoLogger.withMdc(mdc) { log(message()) }
+
+ fun info(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
+ infoLogger.withMdc(mdc) { log(marker, message()) }
// DEBUG
fun withDebug(block: AtLevelLogger.() -> Unit) = debugLogger.block()
fun withDebug(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
- debugLogger.withMdc(mdc, block)
+ debugLogger.withMdc(mdc, block)
fun debug(message: () -> String) = debugLogger.run {
log(message())
}
fun debug(mdc: MappedDiagnosticContext, message: () -> String) =
- debugLogger.withMdc(mdc) { log(message()) }
+ debugLogger.withMdc(mdc) { log(message()) }
+ fun debug(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
+ debugLogger.withMdc(mdc) { log(marker, message()) }
// TRACE
fun withTrace(block: AtLevelLogger.() -> Unit) = traceLogger.block()
fun withTrace(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
- traceLogger.withMdc(mdc, block)
+ traceLogger.withMdc(mdc, block)
fun trace(message: () -> String) = traceLogger.run {
log(message())
}
fun trace(mdc: MappedDiagnosticContext, message: () -> String) =
- traceLogger.withMdc(mdc) { log(message()) }
+ traceLogger.withMdc(mdc) { log(message()) }
+ fun trace(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
+ traceLogger.withMdc(mdc) { log(marker, message()) }
+
+ companion object {
+ fun setLogLevel(packageName: String, level: LogLevel) {
+ val loggerContext = LoggerFactory.getILoggerFactory() as LoggerContext
+ loggerContext.getLogger(packageName).level = level()
+ }
+ }
}
abstract class AtLevelLogger {
abstract fun log(message: String)
abstract fun log(message: String, t: Throwable)
+ abstract fun log(marker: Marker, message: String)
+ abstract fun log(marker: Marker, message: String, t: Throwable)
+
open val enabled: Boolean
get() = true
}
}
}
+
+ protected fun withAdditionalMdc(mdc: Map<String, String>, block: () -> Unit) {
+ if (mdc.isEmpty()) {
+ block()
+ } else {
+ try {
+ mdc.forEach(MDC::put)
+ block()
+ } finally {
+ mdc.keys.forEach(MDC::remove)
+ }
+ }
+ }
}
object OffLevelLogger : AtLevelLogger() {
override fun log(message: String, t: Throwable) {
// do not log anything
}
+
+ override fun log(marker: Marker, message: String) {
+ // do not log anything
+ }
+
+ override fun log(marker: Marker, message: String, t: Throwable) {
+ // do no log anything
+ }
}
+@Suppress("SuboptimalLoggerUsage")
class ErrorLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
override fun log(message: String) {
logger.error(message)
override fun log(message: String, t: Throwable) {
logger.error(message, t)
}
+
+ override fun log(marker: Marker, message: String) =
+ withAdditionalMdc(marker.mdc) {
+ logger.error(marker.slf4jMarker, message)
+ }
+
+ override fun log(marker: Marker, message: String, t: Throwable) =
+ withAdditionalMdc(marker.mdc) {
+ logger.error(marker.slf4jMarker, message, t)
+ }
}
+@Suppress("SuboptimalLoggerUsage")
class WarnLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
override fun log(message: String) {
logger.warn(message)
override fun log(message: String, t: Throwable) {
logger.warn(message, t)
}
+
+ override fun log(marker: Marker, message: String) =
+ withAdditionalMdc(marker.mdc) {
+ logger.warn(marker.slf4jMarker, message)
+ }
+
+ override fun log(marker: Marker, message: String, t: Throwable) =
+ withAdditionalMdc(marker.mdc) {
+ logger.warn(marker.slf4jMarker, message, t)
+ }
}
+@Suppress("SuboptimalLoggerUsage")
class InfoLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
override fun log(message: String) {
logger.info(message)
override fun log(message: String, t: Throwable) {
logger.info(message, t)
}
+
+ override fun log(marker: Marker, message: String) =
+ withAdditionalMdc(marker.mdc) {
+ logger.info(marker.slf4jMarker, message)
+ }
+
+ override fun log(marker: Marker, message: String, t: Throwable) =
+ withAdditionalMdc(marker.mdc) {
+ logger.info(marker.slf4jMarker, message, t)
+ }
}
+@Suppress("SuboptimalLoggerUsage")
class DebugLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
override fun log(message: String) {
logger.debug(message)
override fun log(message: String, t: Throwable) {
logger.debug(message, t)
}
+
+ override fun log(marker: Marker, message: String) =
+ withAdditionalMdc(marker.mdc) {
+ logger.debug(marker.slf4jMarker, message)
+ }
+
+ override fun log(marker: Marker, message: String, t: Throwable) =
+ withAdditionalMdc(marker.mdc) {
+ logger.debug(marker.slf4jMarker, message, t)
+ }
}
+@Suppress("SuboptimalLoggerUsage")
class TraceLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
override fun log(message: String) {
logger.trace(message)
override fun log(message: String, t: Throwable) {
logger.trace(message, t)
}
+
+ override fun log(marker: Marker, message: String) =
+ withAdditionalMdc(marker.mdc) {
+ logger.trace(marker.slf4jMarker, message)
+ }
+
+ override fun log(marker: Marker, message: String, t: Throwable) =
+ withAdditionalMdc(marker.mdc) {
+ logger.trace(marker.slf4jMarker, message, t)
+ }
}