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     fun error(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String, t: Throwable) =
  68         errorLogger.withMdc(mdc) { log(marker, message(), t) }
  69
  70     // WARN
  71
  72     fun withWarn(block: AtLevelLogger.() -> Unit) = warnLogger.block()
  73
  74     fun withWarn(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
  75         warnLogger.withMdc(mdc, block)
  76
  77     fun warn(message: () -> String) = warnLogger.run {
  78         log(message())
  79     }
  80
  81     fun warn(mdc: MappedDiagnosticContext, message: () -> String) =
  82         warnLogger.withMdc(mdc) { log(message()) }
  83
  84     fun warn(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
  85         warnLogger.withMdc(mdc) { log(marker, message()) }
  86
  87     fun warn(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String, t: Throwable) =
  88         warnLogger.withMdc(mdc) { log(marker, message(), t) }
  89
  90     // INFO
  91
  92     fun withInfo(block: AtLevelLogger.() -> Unit) = infoLogger.block()
  93
  94     fun withInfo(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
  95         infoLogger.withMdc(mdc, block)
  96
  97     fun info(message: () -> String) = infoLogger.run {
  98         log(message())
  99     }
 100
 101     fun info(mdc: MappedDiagnosticContext, message: () -> String) =
 102         infoLogger.withMdc(mdc) { log(message()) }
 103
 104     fun info(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
 105         infoLogger.withMdc(mdc) { log(marker, message()) }
 106
 107     // DEBUG
 108
 109     fun withDebug(block: AtLevelLogger.() -> Unit) = debugLogger.block()
 110
 111     fun withDebug(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
 112         debugLogger.withMdc(mdc, block)
 113
 114     fun debug(message: () -> String) = debugLogger.run {
 115         log(message())
 116     }
 117
 118     fun debug(mdc: MappedDiagnosticContext, message: () -> String) =
 119         debugLogger.withMdc(mdc) { log(message()) }
 120
 121     fun debug(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
 122         debugLogger.withMdc(mdc) { log(marker, message()) }
 123
 124     // TRACE
 125
 126     fun withTrace(block: AtLevelLogger.() -> Unit) = traceLogger.block()
 127
 128     fun withTrace(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
 129         traceLogger.withMdc(mdc, block)
 130
 131     fun trace(message: () -> String) = traceLogger.run {
 132         log(message())
 133     }
 134
 135     fun trace(mdc: MappedDiagnosticContext, message: () -> String) =
 136         traceLogger.withMdc(mdc) { log(message()) }
 137
 138     fun trace(mdc: MappedDiagnosticContext, marker: Marker, message: () -> String) =
 139         traceLogger.withMdc(mdc) { log(marker, message()) }
 140
 141     companion object {
 142         fun setLogLevel(packageName: String, level: LogLevel) {
 143             val loggerContext = LoggerFactory.getILoggerFactory() as LoggerContext
 144             loggerContext.getLogger(packageName).level = level()
 145         }
 146     }
 147 }
 148
 149 abstract class AtLevelLogger {
 150     abstract fun log(message: String)
 151     abstract fun log(message: String, t: Throwable)
 152     abstract fun log(marker: Marker, message: String)
 153     abstract fun log(marker: Marker, message: String, t: Throwable)
 154
 155     open val enabled: Boolean
 156         get() = true
 157
 158     inline fun withMdc(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) {
 159         if (enabled) {
 160             try {
 161                 MDC.setContextMap(mdc())
 162                 block()
 163             } finally {
 164                 MDC.clear()
 165             }
 166         }
 167     }
 168
 169     protected fun withAdditionalMdc(mdc: Map<String, String>, block: () -> Unit) {
 170         if (mdc.isEmpty()) {
 171             block()
 172         } else {
 173             try {
 174                 mdc.forEach(MDC::put)
 175                 block()
 176             } finally {
 177                 mdc.keys.forEach(MDC::remove)
 178             }
 179         }
 180     }
 181 }
 182
 183 object OffLevelLogger : AtLevelLogger() {
 184     override val enabled = false
 185
 186     override fun log(message: String) {
 187         // do not log anything
 188     }
 189
 190     override fun log(message: String, t: Throwable) {
 191         // do not log anything
 192     }
 193
 194     override fun log(marker: Marker, message: String) {
 195         // do not log anything
 196     }
 197
 198     override fun log(marker: Marker, message: String, t: Throwable) {
 199         // do no log anything
 200     }
 201 }
 202
 203 @Suppress("SuboptimalLoggerUsage")
 204 class ErrorLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 205     override fun log(message: String) {
 206         logger.error(message)
 207     }
 208
 209     override fun log(message: String, t: Throwable) {
 210         logger.error(message, t)
 211     }
 212
 213     override fun log(marker: Marker, message: String) =
 214         withAdditionalMdc(marker.mdc) {
 215             logger.error(marker.slf4jMarker, message)
 216         }
 217
 218     override fun log(marker: Marker, message: String, t: Throwable) =
 219         withAdditionalMdc(marker.mdc) {
 220             logger.error(marker.slf4jMarker, message, t)
 221         }
 222 }
 223
 224 @Suppress("SuboptimalLoggerUsage")
 225 class WarnLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 226     override fun log(message: String) {
 227         logger.warn(message)
 228     }
 229
 230     override fun log(message: String, t: Throwable) {
 231         logger.warn(message, t)
 232     }
 233
 234     override fun log(marker: Marker, message: String) =
 235         withAdditionalMdc(marker.mdc) {
 236             logger.warn(marker.slf4jMarker, message)
 237         }
 238
 239     override fun log(marker: Marker, message: String, t: Throwable) =
 240         withAdditionalMdc(marker.mdc) {
 241             logger.warn(marker.slf4jMarker, message, t)
 242         }
 243 }
 244
 245 @Suppress("SuboptimalLoggerUsage")
 246 class InfoLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 247     override fun log(message: String) {
 248         logger.info(message)
 249     }
 250
 251     override fun log(message: String, t: Throwable) {
 252         logger.info(message, t)
 253     }
 254
 255     override fun log(marker: Marker, message: String) =
 256         withAdditionalMdc(marker.mdc) {
 257             logger.info(marker.slf4jMarker, message)
 258         }
 259
 260     override fun log(marker: Marker, message: String, t: Throwable) =
 261         withAdditionalMdc(marker.mdc) {
 262             logger.info(marker.slf4jMarker, message, t)
 263         }
 264 }
 265
 266 @Suppress("SuboptimalLoggerUsage")
 267 class DebugLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 268     override fun log(message: String) {
 269         logger.debug(message)
 270     }
 271
 272     override fun log(message: String, t: Throwable) {
 273         logger.debug(message, t)
 274     }
 275
 276     override fun log(marker: Marker, message: String) =
 277         withAdditionalMdc(marker.mdc) {
 278             logger.debug(marker.slf4jMarker, message)
 279         }
 280
 281     override fun log(marker: Marker, message: String, t: Throwable) =
 282         withAdditionalMdc(marker.mdc) {
 283             logger.debug(marker.slf4jMarker, message, t)
 284         }
 285 }
 286
 287 @Suppress("SuboptimalLoggerUsage")
 288 class TraceLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 289     override fun log(message: String) {
 290         logger.trace(message)
 291     }
 292
 293     override fun log(message: String, t: Throwable) {
 294         logger.trace(message, t)
 295     }
 296
 297     override fun log(marker: Marker, message: String) =
 298         withAdditionalMdc(marker.mdc) {
 299             logger.trace(marker.slf4jMarker, message)
 300         }
 301
 302     override fun log(marker: Marker, message: String, t: Throwable) =
 303         withAdditionalMdc(marker.mdc) {
 304             logger.trace(marker.slf4jMarker, message, t)
 305         }
 306 }