Get rid of arrow-effects usage

[dcaegen2/collectors/hv-ves.git] / sources / hv-collector-utils / src / main / kotlin / org / onap / dcae / collectors / veshv / utils / logging / Logger.kt

diff --git a/sources/hv-collector-utils/src/main/kotlin/org/onap/dcae/collectors/veshv/utils/logging/Logger.kt b/sources/hv-collector-utils/src/main/kotlin/org/onap/dcae/collectors/veshv/utils/logging/Logger.kt
index 2fb4880..7fcc73a 100644 (file)
--- a/sources/hv-collector-utils/src/main/kotlin/org/onap/dcae/collectors/veshv/utils/logging/Logger.kt
+++ b/sources/hv-collector-utils/src/main/kotlin/org/onap/dcae/collectors/veshv/utils/logging/Logger.kt
@@ -19,6 +19,7 @@
  */
 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
@@ -30,89 +31,127 @@ class Logger(logger: org.slf4j.Logger) {
     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
 
@@ -126,6 +165,19 @@ abstract class AtLevelLogger {
             }
         }
     }
+
+    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() {
@@ -138,8 +190,17 @@ 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)
@@ -148,8 +209,19 @@ class ErrorLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
     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)
@@ -158,8 +230,19 @@ class WarnLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
     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)
@@ -168,8 +251,19 @@ class InfoLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
     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)
@@ -178,8 +272,19 @@ class DebugLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
     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)
@@ -188,4 +293,14 @@ class TraceLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
     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)
+        }
 }