A modern programming language that makes developers happier.

kotlinlang

Is anyone familiar with how to get MDC calls such as `MDC.put(“key”, “val”)` to work within Ktor within a call pipeline? Is there a specific way to get this to work for the logger within Ktor? I’m using SLF4J with a JSON output and my goal is to simply add additional metadata to the JSON output based on the call. 

`org.jetbrains.kotlinx:kotlinx-coroutines-slf4j:kotlinxCoroutines`

we have a util
```/**
 * Use this to make MDC work properly with Kotlin coroutines.
 * Null values will be excluded.
 */
public suspend fun &lt;T&gt; withMdc(mdc: Map&lt;String, Any?&gt;, block: suspend () -&gt; T): T {
  val contextMap = buildMap {
    putAll(MDC.getCopyOfContextMap())
    mdc.forEach { (key, value) -&gt;
      value ?: return@forEach // Don't include null values in MDC.
      put(key, mdcMapper.writeValueAsStringSpecial(value))
    }
  }

  return withContext(MDCContext(contextMap)) {
    block()
  }
}```

<https://github.com/hudson155/kairo/tree/main/kairo-mdc>

This makes it work nicely with coroutines. Otherwise since MDC stores things on the thread context it borks

Oh cool, I was seeing MDCContext come up but I wasn’t sure how it was meant to be used within the context of Ktor. Thanks, I’ll give that a try. 

Where do the Kairo artifacts get published to?

I don't know if you need to use Kairo necessarily — it's a small framework I maintain that only 2 companies use afaik. Although you're welcome to!

```plugins {
  id("com.google.cloud.artifactregistry.gradle-plugin")
}

maven {
  url = uri("<artifactregistry://us-central1-maven.pkg.dev/airborne-software/maven>")
}

dependencies {
  implementation("kairo:kairo-mdc:4.2.0")
}```

Alternatively you could use `org.jetbrains.kotlinx:kotlinx-coroutines-slf4j:kotlinxCoroutines` directly and just copy <https://github.com/hudson155/kairo/blob/main/kairo-mdc/src/main/kotlin/kairo/mdc/withMdc.kt|this file>

But if you find other pieces of Kairo useful, feel free! They're all relatively independent from each other and actively maintained by <https://www.highbeam.co/|my company>

I think the other thing to look at would be <https://github.com/Kotlin/kotlinx.coroutines/blob/master/integration/kotlinx-coroutines-slf4j/src/MDCContext.kt> if you're curious how this works at a deeper level

Yeah, digging into it I am a little bit lost on how this should work with our logger. Would logger calls be done within the block passed into the context functions?

Using the example in this README <https://github.com/Kotlin/kotlinx.coroutines/blob/master/integration/kotlinx-coroutines-slf4j/README.md|https://github.com/Kotlin/kotlinx.coroutines/blob/master/integration/kotlinx-coroutines-slf4j/README.md>

Within the call I have the `MDC.put` calls, and then:
```call.launch(MDCContext()) {
    <http://application.log.info|application.log.info>(“…”)
}```

For future reference for anyone else running into this^

Also, you can use the <https://ktor.io/docs/server-call-logging.html#mdc|CallLogging plugin> to put a diagnostic context value in the call context.

I needed to dynamically add a bunch of values to a call for a specific endpoint.