Kotlin extensions to SLF4J Logger with MDC support

LoggerExtensions.kt

import org.slf4j.Logger
import org.slf4j.MDC
import org.slf4j.Marker
import org.slf4j.helpers.MessageFormatter

typealias LazyPair = () -> Pair<String, String>

// <editor-fold desc="Logger.trace Extensions">
inline fun Logger.trace(msg: () -> Any?) {
    this.trace(msg.invoke().toString())
}

inline fun Logger.trace(ex: Throwable?, msg: () -> Any?) {
    this.trace(msg.invoke().toString(), ex)
}

inline fun Logger.trace(vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.trace(msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.trace(mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.trace(msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.trace(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.trace(msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.trace(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.trace(msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.trace(marker: Marker?, msg: () -> Any?) {
    this.trace(marker, msg.invoke().toString())
}

inline fun Logger.trace(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
    this.trace(marker, msg.invoke().toString(), ex)
}

inline fun Logger.trace(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.trace(marker, msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.trace(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.trace(marker, msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.trace(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.trace(marker, msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.trace(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.trace(marker, msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}


// </editor-fold>

// <editor-fold desc="Logger.tracex Extensions">
inline fun Logger.tracex(msg: () -> Any?) {
    if (this.isTraceEnabled) {
        this.trace(msg.invoke().toString())
    }
}

inline fun Logger.tracex(ex: Throwable?, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        this.trace(msg.invoke().toString(), ex)
    }
}

inline fun Logger.tracex(vararg mdc: LazyPair, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.trace(msg.invoke().toString())
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.tracex(mdc: List<LazyPair>, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.trace(msg.invoke().toString())
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.tracex(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.trace(msg.invoke().toString(), ex)
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.tracex(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.trace(msg.invoke().toString(), ex)
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.tracex(marker: Marker?, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        this.trace(marker, msg.invoke().toString())
    }
}

inline fun Logger.tracex(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        this.trace(marker, msg.invoke().toString(), ex)
    }
}

inline fun Logger.tracex(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.trace(marker, msg.invoke().toString())
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.tracex(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.trace(marker, msg.invoke().toString())
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.tracex(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.trace(marker, msg.invoke().toString(), ex)
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.tracex(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    if (this.isTraceEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.trace(marker, msg.invoke().toString(), ex)
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}
// </editor-fold>

// <editor-fold desc="Logger.debug Extensions">
inline fun Logger.debug(msg: () -> Any?) {
    this.debug(msg.invoke().toString())
}

inline fun Logger.debug(ex: Throwable?, msg: () -> Any?) {
    this.debug(msg.invoke().toString(), ex)
}

inline fun Logger.debug(vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.debug(msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.debug(mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.debug(msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.debug(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.debug(msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.debug(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.debug(msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.debug(marker: Marker?, msg: () -> Any?) {
    this.debug(marker, msg.invoke().toString())
}

inline fun Logger.debug(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
    this.debug(marker, msg.invoke().toString(), ex)
}

inline fun Logger.debug(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.debug(marker, msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.debug(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.debug(marker, msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.debug(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.debug(marker, msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.debug(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.debug(marker, msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}
// </editor-fold>

// <editor-fold desc="Logger.debugx Extensions">
inline fun Logger.debugx(msg: () -> Any?) {
    if (this.isDebugEnabled) {
        this.debug(msg.invoke().toString())
    }
}

inline fun Logger.debugx(ex: Throwable?, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        this.debug(msg.invoke().toString(), ex)
    }
}

inline fun Logger.debugx(vararg mdc: LazyPair, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.debug(msg.invoke().toString())
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.debugx(mdc: List<LazyPair>, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.debug(msg.invoke().toString())
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.debugx(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.debug(msg.invoke().toString(), ex)
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.debugx(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.debug(msg.invoke().toString(), ex)
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.debugx(marker: Marker?, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        this.debug(marker, msg.invoke().toString())
    }
}

inline fun Logger.debugx(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        this.debug(marker, msg.invoke().toString(), ex)
    }
}

inline fun Logger.debugx(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.debug(marker, msg.invoke().toString())
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.debugx(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.debug(marker, msg.invoke().toString())
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.debugx(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.debug(marker, msg.invoke().toString(), ex)
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}

inline fun Logger.debugx(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    if (this.isDebugEnabled) {
        val pairs = mdc.map { it.invoke() }
        pairs.forEach { (k, v) -> MDC.put(k, v) }
        this.debug(marker, msg.invoke().toString(), ex)
        pairs.forEach { (k, _) -> MDC.remove(k) }
    }
}
// </editor-fold>

// <editor-fold desc="Logger.info Extensions">
inline fun Logger.info(msg: () -> Any?) {
    this.info(msg.invoke().toString())
}

inline fun Logger.info(ex: Throwable?, msg: () -> Any?) {
    this.info(msg.invoke().toString(), ex)
}

inline fun Logger.info(vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.info(msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.info(mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.info(msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.info(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.info(msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.info(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.info(msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.info(marker: Marker?, msg: () -> Any?) {
    this.info(marker, msg.invoke().toString())
}

inline fun Logger.info(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
    this.info(marker, msg.invoke().toString(), ex)
}

inline fun Logger.info(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.info(marker, msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.info(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.info(marker, msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.info(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.info(marker, msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.info(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.info(marker, msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}
// </editor-fold>

// <editor-fold desc="Logger.warn Extensions">
inline fun Logger.warn(msg: () -> Any?) {
    this.warn(msg.invoke().toString())
}

inline fun Logger.warn(ex: Throwable?, msg: () -> Any?) {
    this.warn(msg.invoke().toString(), ex)
}

inline fun Logger.warn(vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.warn(msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.warn(mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.warn(msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.warn(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.warn(msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.warn(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.warn(msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.warn(marker: Marker?, msg: () -> Any?) {
    this.warn(marker, msg.invoke().toString())
}

inline fun Logger.warn(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
    this.warn(marker, msg.invoke().toString(), ex)
}

inline fun Logger.warn(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.warn(marker, msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.warn(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.warn(marker, msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.warn(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.warn(marker, msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.warn(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.warn(marker, msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}
// </editor-fold>

// <editor-fold desc="Logger.error Extensions">
inline fun Logger.error(msg: () -> Any?) {
    this.error(msg.invoke().toString())
}

inline fun Logger.error(ex: Throwable?, msg: () -> Any?) {
    this.error(msg.invoke().toString(), ex)
}

inline fun Logger.error(vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.error(msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.error(mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.error(msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.error(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.error(msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.error(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.error(msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.error(marker: Marker?, msg: () -> Any?) {
    this.error(marker, msg.invoke().toString())
}

inline fun Logger.error(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
    this.error(marker, msg.invoke().toString(), ex)
}

inline fun Logger.error(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.error(marker, msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.error(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.error(marker, msg.invoke().toString())
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.error(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.error(marker, msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}

inline fun Logger.error(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
    val pairs = mdc.map { it.invoke() }
    pairs.forEach { (k, v) -> MDC.put(k, v) }
    this.error(marker, msg.invoke().toString(), ex)
    pairs.forEach { (k, _) -> MDC.remove(k) }
}
// </editor-fold>

/**
 * Convert this [Logger] into a [FixedContextLogger].
 */
fun Logger.toFixedContextLogger(vararg mdc: Pair<String, String>): FixedContextLogger {
    return FixedContextLogger(this, *mdc)
}

/**
 * A [FixedContextLogger] logs every message with the provided `mdc` pairs in
 * addition to any other pairs passed into each logging call.
 */
class FixedContextLogger(val logger: Logger, vararg mdc: Pair<String, String>) : Logger by logger {

    private val pairs: List<LazyPair> = mdc.map { { it } }

    // <editor-fold desc="FixedContextLogger trace Functions">
    fun trace(msg: () -> Any?) {
        logger.trace(pairs, msg)
    }

    fun trace(ex: Throwable?, msg: () -> Any?) {
        logger.trace(ex, pairs, msg)
    }

    fun trace(vararg mdc: LazyPair, msg: () -> Any?) {
        logger.trace(pairs + mdc.toList(), msg)
    }

    fun trace(mdc: List<LazyPair>, msg: () -> Any?) {
        logger.trace(pairs + mdc, msg)
    }

    fun trace(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.trace(ex, pairs + mdc.toList(), msg)
    }

    fun trace(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.trace(ex, pairs + mdc, msg)
    }

    fun trace(marker: Marker?, msg: () -> Any?) {
        logger.trace(marker, pairs, msg)
    }

    fun trace(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
        logger.trace(marker, ex, pairs, msg)
    }

    fun trace(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.trace(marker, pairs + mdc.toList(), msg)
    }

    fun trace(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.trace(marker, pairs + mdc, msg)
    }

    fun trace(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.trace(marker, ex, pairs + mdc.toList(), msg)
    }

    fun trace(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.trace(marker, ex, pairs + mdc, msg)
    }
    // </editor-fold>

    // <editor-fold desc="FixedContextLogger tracex Functions">
    fun tracex(msg: () -> Any?) {
        logger.tracex(pairs, msg)
    }

    fun tracex(ex: Throwable?, msg: () -> Any?) {
        logger.tracex(ex, pairs, msg)
    }

    fun tracex(vararg mdc: LazyPair, msg: () -> Any?) {
        logger.tracex(pairs + mdc.toList(), msg)
    }

    fun tracex(mdc: List<LazyPair>, msg: () -> Any?) {
        logger.tracex(pairs + mdc, msg)
    }

    fun tracex(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.tracex(ex, pairs + mdc.toList(), msg)
    }

    fun tracex(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.tracex(ex, pairs + mdc, msg)
    }

    fun tracex(marker: Marker?, msg: () -> Any?) {
        logger.tracex(marker, pairs, msg)
    }

    fun tracex(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
        logger.tracex(marker, ex, pairs, msg)
    }

    fun tracex(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.tracex(marker, pairs + mdc.toList(), msg)
    }

    fun tracex(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.tracex(marker, pairs + mdc, msg)
    }

    fun tracex(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.tracex(marker, ex, pairs + mdc.toList(), msg)
    }

    fun tracex(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.tracex(marker, ex, pairs + mdc, msg)
    }
    // </editor-fold>

    // <editor-fold desc="org.slf4j.Logger trace Overrides">
    override fun trace(msg: String?) {
        trace { msg }
    }

    override fun trace(format: String?, arg: Any?) {
        trace { MessageFormatter.format(format, arg).message }
    }

    override fun trace(format: String?, arg1: Any?, arg2: Any?) {
        trace { MessageFormatter.format(format, arg1, arg2).message }
    }

    override fun trace(format: String?, vararg arguments: Any?) {
        trace { MessageFormatter.arrayFormat(format, arguments).message }
    }

    override fun trace(msg: String?, t: Throwable?) {
        trace(t) { msg }
    }

    override fun trace(marker: Marker?, msg: String?) {
        trace(marker) { msg }
    }

    override fun trace(marker: Marker?, format: String?, arg: Any?) {
        trace(marker) { MessageFormatter.format(format, arg).message }
    }

    override fun trace(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
        trace(marker) { MessageFormatter.format(format, arg1, arg2).message }
    }

    override fun trace(marker: Marker?, format: String?, vararg arguments: Any?) {
        trace(marker) { MessageFormatter.arrayFormat(format, arguments).message }
    }

    override fun trace(marker: Marker?, msg: String?, t: Throwable?) {
        trace(marker, t) { msg }
    }
    // </editor-fold>

    // <editor-fold desc="FixedContextLogger debug Functions">
    fun debug(msg: () -> Any?) {
        logger.debug(pairs, msg)
    }

    fun debug(ex: Throwable?, msg: () -> Any?) {
        logger.debug(ex, pairs, msg)
    }

    fun debug(vararg mdc: LazyPair, msg: () -> Any?) {
        logger.debug(pairs + mdc.toList(), msg)
    }

    fun debug(mdc: List<LazyPair>, msg: () -> Any?) {
        logger.debug(pairs + mdc, msg)
    }

    fun debug(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.debug(ex, pairs + mdc.toList(), msg)
    }

    fun debug(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.debug(ex, pairs + mdc, msg)
    }

    fun debug(marker: Marker?, msg: () -> Any?) {
        logger.debug(marker, pairs, msg)
    }

    fun debug(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
        logger.debug(marker, ex, pairs, msg)
    }

    fun debug(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.debug(marker, pairs + mdc.toList(), msg)
    }

    fun debug(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.debug(marker, pairs + mdc, msg)
    }

    fun debug(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.debug(marker, ex, pairs + mdc.toList(), msg)
    }

    fun debug(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.debug(marker, ex, pairs + mdc, msg)
    }
    // </editor-fold>

    // <editor-fold desc="FixedContextLogger debugx Functions">
    fun debugx(msg: () -> Any?) {
        logger.debugx(pairs, msg)
    }

    fun debugx(ex: Throwable?, msg: () -> Any?) {
        logger.debugx(ex, pairs, msg)
    }

    fun debugx(vararg mdc: LazyPair, msg: () -> Any?) {
        logger.debugx(pairs + mdc.toList(), msg)
    }

    fun debugx(mdc: List<LazyPair>, msg: () -> Any?) {
        logger.debugx(pairs + mdc, msg)
    }

    fun debugx(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.debugx(ex, pairs + mdc.toList(), msg)
    }

    fun debugx(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.debugx(ex, pairs + mdc, msg)
    }

    fun debugx(marker: Marker?, msg: () -> Any?) {
        logger.debugx(marker, pairs, msg)
    }

    fun debugx(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
        logger.debugx(marker, ex, pairs, msg)
    }

    fun debugx(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.debugx(marker, pairs + mdc.toList(), msg)
    }

    fun debugx(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.debugx(marker, pairs + mdc, msg)
    }

    fun debugx(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.debugx(marker, ex, pairs + mdc.toList(), msg)
    }

    fun debugx(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.debugx(marker, ex, pairs + mdc, msg)
    }
    // </editor-fold>

    // <editor-fold desc="org.slf4j.Logger debug Overrides">
    override fun debug(msg: String?) {
        debug { msg }
    }

    override fun debug(format: String?, arg: Any?) {
        debug { MessageFormatter.format(format, arg).message }
    }

    override fun debug(format: String?, arg1: Any?, arg2: Any?) {
        debug { MessageFormatter.format(format, arg1, arg2).message }
    }

    override fun debug(format: String?, vararg arguments: Any?) {
        debug { MessageFormatter.arrayFormat(format, arguments).message }
    }

    override fun debug(msg: String?, t: Throwable?) {
        debug(t) { msg }
    }

    override fun debug(marker: Marker?, msg: String?) {
        debug(marker) { msg }
    }

    override fun debug(marker: Marker?, format: String?, arg: Any?) {
        debug(marker) { MessageFormatter.format(format, arg).message }
    }

    override fun debug(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
        debug(marker) { MessageFormatter.format(format, arg1, arg2).message }
    }

    override fun debug(marker: Marker?, format: String?, vararg arguments: Any?) {
        debug(marker) { MessageFormatter.arrayFormat(format, arguments).message }
    }

    override fun debug(marker: Marker?, msg: String?, t: Throwable?) {
        debug(marker, t) { msg }
    }
    // </editor-fold>

    // <editor-fold desc="FixedContextLogger info Functions">
    fun info(msg: () -> Any?) {
        logger.info(pairs, msg)
    }

    fun info(ex: Throwable?, msg: () -> Any?) {
        logger.info(ex, pairs, msg)
    }

    fun info(vararg mdc: LazyPair, msg: () -> Any?) {
        logger.info(pairs + mdc.toList(), msg)
    }

    fun info(mdc: List<LazyPair>, msg: () -> Any?) {
        logger.info(pairs + mdc, msg)
    }

    fun info(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.info(ex, pairs + mdc.toList(), msg)
    }

    fun info(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.info(ex, pairs + mdc, msg)
    }

    fun info(marker: Marker?, msg: () -> Any?) {
        logger.info(marker, pairs, msg)
    }

    fun info(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
        logger.info(marker, ex, pairs, msg)
    }

    fun info(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.info(marker, pairs + mdc.toList(), msg)
    }

    fun info(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.info(marker, pairs + mdc, msg)
    }

    fun info(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.info(marker, ex, pairs + mdc.toList(), msg)
    }

    fun info(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.info(marker, ex, pairs + mdc, msg)
    }
    // </editor-fold>

    // <editor-fold desc="org.slf4j.Logger info Overrides">
    override fun info(msg: String?) {
        info { msg }
    }

    override fun info(format: String?, arg: Any?) {
        info { MessageFormatter.format(format, arg).message }
    }

    override fun info(format: String?, arg1: Any?, arg2: Any?) {
        info { MessageFormatter.format(format, arg1, arg2).message }
    }

    override fun info(format: String?, vararg arguments: Any?) {
        info { MessageFormatter.arrayFormat(format, arguments).message }
    }

    override fun info(msg: String?, t: Throwable?) {
        info(t) { msg }
    }

    override fun info(marker: Marker?, msg: String?) {
        info(marker) { msg }
    }

    override fun info(marker: Marker?, format: String?, arg: Any?) {
        info(marker) { MessageFormatter.format(format, arg).message }
    }

    override fun info(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
        info(marker) { MessageFormatter.format(format, arg1, arg2).message }
    }

    override fun info(marker: Marker?, format: String?, vararg arguments: Any?) {
        info(marker) { MessageFormatter.arrayFormat(format, arguments).message }
    }

    override fun info(marker: Marker?, msg: String?, t: Throwable?) {
        info(marker, t) { msg }
    }
    // </editor-fold>

    // <editor-fold desc="FixedContextLogger warn Functions">
    fun warn(msg: () -> Any?) {
        logger.warn(pairs, msg)
    }

    fun warn(ex: Throwable?, msg: () -> Any?) {
        logger.warn(ex, pairs, msg)
    }

    fun warn(vararg mdc: LazyPair, msg: () -> Any?) {
        logger.warn(pairs + mdc.toList(), msg)
    }

    fun warn(mdc: List<LazyPair>, msg: () -> Any?) {
        logger.warn(pairs + mdc, msg)
    }

    fun warn(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.warn(ex, pairs + mdc.toList(), msg)
    }

    fun warn(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.warn(ex, pairs + mdc, msg)
    }

    fun warn(marker: Marker?, msg: () -> Any?) {
        logger.warn(marker, pairs, msg)
    }

    fun warn(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
        logger.warn(marker, ex, pairs, msg)
    }

    fun warn(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.warn(marker, pairs + mdc.toList(), msg)
    }

    fun warn(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.warn(marker, pairs + mdc, msg)
    }

    fun warn(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.warn(marker, ex, pairs + mdc.toList(), msg)
    }

    fun warn(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.warn(marker, ex, pairs + mdc, msg)
    }
    // </editor-fold>

    // <editor-fold desc="org.slf4j.Logger warn Overrides">
    override fun warn(msg: String?) {
        warn { msg }
    }

    override fun warn(format: String?, arg: Any?) {
        warn { MessageFormatter.format(format, arg).message }
    }

    override fun warn(format: String?, arg1: Any?, arg2: Any?) {
        warn { MessageFormatter.format(format, arg1, arg2).message }
    }

    override fun warn(format: String?, vararg arguments: Any?) {
        warn { MessageFormatter.arrayFormat(format, arguments).message }
    }

    override fun warn(msg: String?, t: Throwable?) {
        warn(t) { msg }
    }

    override fun warn(marker: Marker?, msg: String?) {
        warn(marker) { msg }
    }

    override fun warn(marker: Marker?, format: String?, arg: Any?) {
        warn(marker) { MessageFormatter.format(format, arg).message }
    }

    override fun warn(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
        warn(marker) { MessageFormatter.format(format, arg1, arg2).message }
    }

    override fun warn(marker: Marker?, format: String?, vararg arguments: Any?) {
        warn(marker) { MessageFormatter.arrayFormat(format, arguments).message }
    }

    override fun warn(marker: Marker?, msg: String?, t: Throwable?) {
        warn(marker, t) { msg }
    }
    // </editor-fold>

    // <editor-fold desc="FixedContextLogger error Functions">
    fun error(msg: () -> Any?) {
        logger.error(pairs, msg)
    }

    fun error(ex: Throwable?, msg: () -> Any?) {
        logger.error(ex, pairs, msg)
    }

    fun error(vararg mdc: LazyPair, msg: () -> Any?) {
        logger.error(pairs + mdc.toList(), msg)
    }

    fun error(mdc: List<LazyPair>, msg: () -> Any?) {
        logger.error(pairs + mdc, msg)
    }

    fun error(ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.error(ex, pairs + mdc.toList(), msg)
    }

    fun error(ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.error(ex, pairs + mdc, msg)
    }

    fun error(marker: Marker?, msg: () -> Any?) {
        logger.error(marker, pairs, msg)
    }

    fun error(marker: Marker?, ex: Throwable?, msg: () -> Any?) {
        logger.error(marker, ex, pairs, msg)
    }

    fun error(marker: Marker?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.error(marker, pairs + mdc.toList(), msg)
    }

    fun error(marker: Marker?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.error(marker, pairs + mdc, msg)
    }

    fun error(marker: Marker?, ex: Throwable?, vararg mdc: LazyPair, msg: () -> Any?) {
        logger.error(marker, ex, pairs + mdc.toList(), msg)
    }

    fun error(marker: Marker?, ex: Throwable?, mdc: List<LazyPair>, msg: () -> Any?) {
        logger.error(marker, ex, pairs + mdc, msg)
    }
    // </editor-fold>

    // <editor-fold desc="org.slf4j.Logger error Overrides">
    override fun error(msg: String?) {
        error { msg }
    }

    override fun error(format: String?, arg: Any?) {
        error { MessageFormatter.format(format, arg).message }
    }

    override fun error(format: String?, arg1: Any?, arg2: Any?) {
        error { MessageFormatter.format(format, arg1, arg2).message }
    }

    override fun error(format: String?, vararg arguments: Any?) {
        error { MessageFormatter.arrayFormat(format, arguments).message }
    }

    override fun error(msg: String?, t: Throwable?) {
        error(t) { msg }
    }

    override fun error(marker: Marker?, msg: String?) {
        error(marker) { msg }
    }

    override fun error(marker: Marker?, format: String?, arg: Any?) {
        error(marker) { MessageFormatter.format(format, arg).message }
    }

    override fun error(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
        error(marker) { MessageFormatter.format(format, arg1, arg2).message }
    }

    override fun error(marker: Marker?, format: String?, vararg arguments: Any?) {
        error(marker) { MessageFormatter.arrayFormat(format, arguments).message }
    }

    override fun error(marker: Marker?, msg: String?, t: Throwable?) {
        error(marker, t) { msg }
    }
    // </editor-fold>

}