sources/hv-collector-utils/src/main/kotlin/org/onap/dcae/collectors/veshv/utils/logging/Logger.kt

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * dcaegen2-collectors-veshv
   4  * ================================================================================
   5  * Copyright (C) 2018 NOKIA
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.onap.dcae.collectors.veshv.utils.logging
  21
  22 import ch.qos.logback.classic.LoggerContext
  23 import kotlin.reflect.KClass
  24 import org.slf4j.LoggerFactory
  25 import org.slf4j.MDC
  26
  27 typealias MappedDiagnosticContext = () -> Map<String, String>
  28
  29 @Suppress("TooManyFunctions", "SuboptimalLoggerUsage")
  30 class Logger(logger: org.slf4j.Logger) {
  31     constructor(clazz: KClass<out Any>) : this(LoggerFactory.getLogger(clazz.java))
  32     constructor(name: String) : this(LoggerFactory.getLogger(name))
  33
  34     private val errorLogger by lazy {
  35         if (logger.isErrorEnabled) ErrorLevelLogger(logger) else OffLevelLogger
  36     }
  37     private val warnLogger by lazy {
  38         if (logger.isWarnEnabled) WarnLevelLogger(logger) else OffLevelLogger
  39     }
  40     private val infoLogger by lazy {
  41         if (logger.isInfoEnabled) InfoLevelLogger(logger) else OffLevelLogger
  42     }
  43     private val debugLogger by lazy {
  44         if (logger.isDebugEnabled) DebugLevelLogger(logger) else OffLevelLogger
  45     }
  46     private val traceLogger by lazy {
  47         if (logger.isTraceEnabled) TraceLevelLogger(logger) else OffLevelLogger
  48     }
  49
  50     // ERROR
  51
  52     fun withError(block: AtLevelLogger.() -> Unit) = errorLogger.block()
  53
  54     fun withError(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
  55         errorLogger.withMdc(mdc, block)
  56
  57     fun error(message: () -> String) = errorLogger.run {
  58         log(message())
  59     }
  60
  61     fun error(mdc: MappedDiagnosticContext, message: () -> String) =
  62         errorLogger.withMdc(mdc) { log(message()) }
  63
  64     fun error(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
  65         errorLogger.withMdc(mdc) { log(marker, message()) }
  66
  67     // WARN
  68
  69     fun withWarn(block: AtLevelLogger.() -> Unit) = warnLogger.block()
  70
  71     fun withWarn(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
  72         warnLogger.withMdc(mdc, block)
  73
  74     fun warn(message: () -> String) = warnLogger.run {
  75         log(message())
  76     }
  77
  78     fun warn(mdc: MappedDiagnosticContext, message: () -> String) =
  79         warnLogger.withMdc(mdc) { log(message()) }
  80
  81     fun warn(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
  82         warnLogger.withMdc(mdc) { log(marker, message()) }
  83
  84     // INFO
  85
  86     fun withInfo(block: AtLevelLogger.() -> Unit) = infoLogger.block()
  87
  88     fun withInfo(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
  89         infoLogger.withMdc(mdc, block)
  90
  91     fun info(message: () -> String) = infoLogger.run {
  92         log(message())
  93     }
  94
  95     fun info(mdc: MappedDiagnosticContext, message: () -> String) =
  96         infoLogger.withMdc(mdc) { log(message()) }
  97
  98     fun info(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
  99         infoLogger.withMdc(mdc) { log(marker, message()) }
 100
 101     // DEBUG
 102
 103     fun withDebug(block: AtLevelLogger.() -> Unit) = debugLogger.block()
 104
 105     fun withDebug(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
 106         debugLogger.withMdc(mdc, block)
 107
 108     fun debug(message: () -> String) = debugLogger.run {
 109         log(message())
 110     }
 111
 112     fun debug(mdc: MappedDiagnosticContext, message: () -> String) =
 113         debugLogger.withMdc(mdc) { log(message()) }
 114
 115     fun debug(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
 116         debugLogger.withMdc(mdc) { log(marker, message()) }
 117
 118     // TRACE
 119
 120     fun withTrace(block: AtLevelLogger.() -> Unit) = traceLogger.block()
 121
 122     fun withTrace(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
 123         traceLogger.withMdc(mdc, block)
 124
 125     fun trace(message: () -> String) = traceLogger.run {
 126         log(message())
 127     }
 128
 129     fun trace(mdc: MappedDiagnosticContext, message: () -> String) =
 130         traceLogger.withMdc(mdc) { log(message()) }
 131
 132     fun trace(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
 133         traceLogger.withMdc(mdc) { log(marker, message()) }
 134
 135     companion object {
 136         fun setLogLevel(packageName: String, level: LogLevel) {
 137             val loggerContext = LoggerFactory.getILoggerFactory() as LoggerContext
 138             loggerContext.getLogger(packageName).level = level()
 139         }
 140     }
 141 }
 142
 143 abstract class AtLevelLogger {
 144     abstract fun log(message: String)
 145     abstract fun log(message: String, t: Throwable)
 146     abstract fun log(marker: Marker, message: String)
 147
 148     open val enabled: Boolean
 149         get() = true
 150
 151     inline fun withMdc(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) {
 152         if (enabled) {
 153             try {
 154                 MDC.setContextMap(mdc())
 155                 block()
 156             } finally {
 157                 MDC.clear()
 158             }
 159         }
 160     }
 161
 162     protected fun withAdditionalMdc(mdc: Map<String, String>, block: () -> Unit) {
 163         if (mdc.isEmpty()) {
 164             block()
 165         } else {
 166             try {
 167                 mdc.forEach(MDC::put)
 168                 block()
 169             } finally {
 170                 mdc.keys.forEach(MDC::remove)
 171             }
 172         }
 173     }
 174 }
 175
 176 object OffLevelLogger : AtLevelLogger() {
 177     override val enabled = false
 178
 179     override fun log(message: String) {
 180         // do not log anything
 181     }
 182
 183     override fun log(message: String, t: Throwable) {
 184         // do not log anything
 185     }
 186
 187     override fun log(marker: Marker, message: String) {
 188         // do not log anything
 189     }
 190 }
 191
 192 @Suppress("SuboptimalLoggerUsage")
 193 class ErrorLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 194     override fun log(message: String) {
 195         logger.error(message)
 196     }
 197
 198     override fun log(message: String, t: Throwable) {
 199         logger.error(message, t)
 200     }
 201
 202     override fun log(marker: Marker, message: String) =
 203         withAdditionalMdc(marker.mdc) {
 204             logger.error(marker.slf4jMarker, message)
 205         }
 206 }
 207
 208 @Suppress("SuboptimalLoggerUsage")
 209 class WarnLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 210     override fun log(message: String) {
 211         logger.warn(message)
 212     }
 213
 214     override fun log(message: String, t: Throwable) {
 215         logger.warn(message, t)
 216     }
 217
 218     override fun log(marker: Marker, message: String) =
 219         withAdditionalMdc(marker.mdc) {
 220             logger.warn(marker.slf4jMarker, message)
 221         }
 222 }
 223
 224 @Suppress("SuboptimalLoggerUsage")
 225 class InfoLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 226     override fun log(message: String) {
 227         logger.info(message)
 228     }
 229
 230     override fun log(message: String, t: Throwable) {
 231         logger.info(message, t)
 232     }
 233
 234     override fun log(marker: Marker, message: String) =
 235         withAdditionalMdc(marker.mdc) {
 236             logger.info(marker.slf4jMarker, message)
 237         }
 238 }
 239
 240 @Suppress("SuboptimalLoggerUsage")
 241 class DebugLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 242     override fun log(message: String) {
 243         logger.debug(message)
 244     }
 245
 246     override fun log(message: String, t: Throwable) {
 247         logger.debug(message, t)
 248     }
 249
 250     override fun log(marker: Marker, message: String) =
 251         withAdditionalMdc(marker.mdc) {
 252             logger.debug(marker.slf4jMarker, message)
 253         }
 254 }
 255
 256 @Suppress("SuboptimalLoggerUsage")
 257 class TraceLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 258     override fun log(message: String) {
 259         logger.trace(message)
 260     }
 261
 262     override fun log(message: String, t: Throwable) {
 263         logger.trace(message, t)
 264     }
 265
 266     override fun log(marker: Marker, message: String) =
 267         withAdditionalMdc(marker.mdc) {
 268             logger.trace(marker.slf4jMarker, message)
 269         }
 270 }