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 import org.slf4j.Marker
  27
  28 typealias MappedDiagnosticContext = () -> Map<String, String>
  29
  30 @Suppress("TooManyFunctions", "SuboptimalLoggerUsage")
  31 class Logger(logger: org.slf4j.Logger) {
  32     constructor(clazz: KClass<out Any>) : this(LoggerFactory.getLogger(clazz.java))
  33     constructor(name: String) : this(LoggerFactory.getLogger(name))
  34
  35     private val errorLogger by lazy {
  36         if (logger.isErrorEnabled) ErrorLevelLogger(logger) else OffLevelLogger
  37     }
  38     private val warnLogger by lazy {
  39         if (logger.isWarnEnabled) WarnLevelLogger(logger) else OffLevelLogger
  40     }
  41     private val infoLogger by lazy {
  42         if (logger.isInfoEnabled) InfoLevelLogger(logger) else OffLevelLogger
  43     }
  44     private val debugLogger by lazy {
  45         if (logger.isDebugEnabled) DebugLevelLogger(logger) else OffLevelLogger
  46     }
  47     private val traceLogger by lazy {
  48         if (logger.isTraceEnabled) TraceLevelLogger(logger) else OffLevelLogger
  49     }
  50
  51     // ERROR
  52
  53     fun withError(block: AtLevelLogger.() -> Unit) = errorLogger.block()
  54
  55     fun withError(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
  56             errorLogger.withMdc(mdc, block)
  57
  58     fun error(message: () -> String) = errorLogger.run {
  59         log(message())
  60     }
  61
  62     fun error(mdc: MappedDiagnosticContext, message: () -> String) =
  63             errorLogger.withMdc(mdc) { log(message()) }
  64
  65     // WARN
  66
  67     fun withWarn(block: AtLevelLogger.() -> Unit) = warnLogger.block()
  68
  69     fun withWarn(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
  70             warnLogger.withMdc(mdc, block)
  71
  72     fun warn(message: () -> String) = warnLogger.run {
  73         log(message())
  74     }
  75
  76     fun warn(mdc: MappedDiagnosticContext, message: () -> String) =
  77             warnLogger.withMdc(mdc) { log(message()) }
  78
  79     // INFO
  80
  81     fun withInfo(block: AtLevelLogger.() -> Unit) = infoLogger.block()
  82
  83     fun withInfo(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
  84             infoLogger.withMdc(mdc, block)
  85
  86     fun info(message: () -> String) = infoLogger.run {
  87         log(message())
  88     }
  89
  90     fun info(mdc: MappedDiagnosticContext, message: () -> String) =
  91             infoLogger.withMdc(mdc) { log(message()) }
  92
  93     // DEBUG
  94
  95     fun withDebug(block: AtLevelLogger.() -> Unit) = debugLogger.block()
  96
  97     fun withDebug(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
  98             debugLogger.withMdc(mdc, block)
  99
 100     fun debug(message: () -> String) = debugLogger.run {
 101         log(message())
 102     }
 103
 104     fun debug(mdc: MappedDiagnosticContext, message: () -> String) =
 105             debugLogger.withMdc(mdc) { log(message()) }
 106
 107     // TRACE
 108
 109     fun withTrace(block: AtLevelLogger.() -> Unit) = traceLogger.block()
 110
 111     fun withTrace(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) =
 112             traceLogger.withMdc(mdc, block)
 113
 114     fun trace(message: () -> String) = traceLogger.run {
 115         log(message())
 116     }
 117
 118     fun trace(mdc: MappedDiagnosticContext, message: () -> String) =
 119             traceLogger.withMdc(mdc) { log(message()) }
 120
 121     companion object {
 122         fun setLogLevel(packageName: String, level: LogLevel) {
 123             val loggerContext = LoggerFactory.getILoggerFactory() as LoggerContext
 124             loggerContext.getLogger(packageName).level = level()
 125         }
 126     }
 127 }
 128
 129 abstract class AtLevelLogger {
 130     abstract fun log(message: String)
 131     abstract fun log(message: String, t: Throwable)
 132     abstract fun log(marker: Marker, message: String)
 133     abstract fun log(marker: Marker, message: String, t: Throwable)
 134
 135     open val enabled: Boolean
 136         get() = true
 137
 138     inline fun withMdc(mdc: MappedDiagnosticContext, block: AtLevelLogger.() -> Unit) {
 139         if (enabled) {
 140             try {
 141                 MDC.setContextMap(mdc())
 142                 block()
 143             } finally {
 144                 MDC.clear()
 145             }
 146         }
 147     }
 148 }
 149
 150 object OffLevelLogger : AtLevelLogger() {
 151     override val enabled = false
 152
 153     override fun log(message: String) {
 154         // do not log anything
 155     }
 156
 157     override fun log(message: String, t: Throwable) {
 158         // do not log anything
 159     }
 160
 161     override fun log(marker: Marker, message: String) {
 162         // do not log anything
 163     }
 164
 165     override fun log(marker: Marker, message: String, t: Throwable) {
 166         // do no log anything
 167     }
 168 }
 169
 170 @Suppress("SuboptimalLoggerUsage")
 171 class ErrorLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 172     override fun log(message: String) {
 173         logger.error(message)
 174     }
 175
 176     override fun log(message: String, t: Throwable) {
 177         logger.error(message, t)
 178     }
 179
 180     override fun log(marker: Marker, message: String) =
 181             logger.error(marker, message)
 182
 183     override fun log(marker: Marker, message: String, t: Throwable) =
 184             logger.error(marker, message, t)
 185 }
 186
 187 @Suppress("SuboptimalLoggerUsage")
 188 class WarnLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 189     override fun log(message: String) {
 190         logger.warn(message)
 191     }
 192
 193     override fun log(message: String, t: Throwable) {
 194         logger.warn(message, t)
 195     }
 196
 197     override fun log(marker: Marker, message: String) =
 198             logger.warn(marker, message)
 199
 200     override fun log(marker: Marker, message: String, t: Throwable) =
 201             logger.warn(marker, message, t)
 202 }
 203
 204 @Suppress("SuboptimalLoggerUsage")
 205 class InfoLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 206     override fun log(message: String) {
 207         logger.info(message)
 208     }
 209
 210     override fun log(message: String, t: Throwable) {
 211         logger.info(message, t)
 212     }
 213
 214     override fun log(marker: Marker, message: String) =
 215             logger.info(marker, message)
 216
 217     override fun log(marker: Marker, message: String, t: Throwable) =
 218             logger.info(marker, message, t)
 219 }
 220
 221 @Suppress("SuboptimalLoggerUsage")
 222 class DebugLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 223     override fun log(message: String) {
 224         logger.debug(message)
 225     }
 226
 227     override fun log(message: String, t: Throwable) {
 228         logger.debug(message, t)
 229     }
 230
 231     override fun log(marker: Marker, message: String) =
 232             logger.debug(marker, message)
 233
 234     override fun log(marker: Marker, message: String, t: Throwable) =
 235             logger.debug(marker, message, t)
 236 }
 237
 238 @Suppress("SuboptimalLoggerUsage")
 239 class TraceLevelLogger(private val logger: org.slf4j.Logger) : AtLevelLogger() {
 240     override fun log(message: String) {
 241         logger.trace(message)
 242     }
 243
 244     override fun log(message: String, t: Throwable) {
 245         logger.trace(message, t)
 246     }
 247
 248     override fun log(marker: Marker, message: String) =
 249             logger.trace(marker, message)
 250
 251     override fun log(marker: Marker, message: String, t: Throwable) =
 252             logger.trace(marker, message, t)
 253 }