Kotlin#119: first implementation of a SLF4J MDC Context

Author: abendt

integration/kotlinx-coroutines-slf4j/build.gradle

@@ -0,0 +1,11 @@
+dependencies {
+    compile 'org.slf4j:slf4j-api:1.7.25'
+    testRuntime 'ch.qos.logback:logback-classic:1.2.3'
+    testRuntime 'ch.qos.logback:logback-core:1.2.3'
+}
+
+tasks.withType(dokka.getClass()) {
+    externalDocumentationLink {
+        url = new URL("https://www.slf4j.org/apidocs/")
+    }
+}

integration/kotlinx-coroutines-slf4j/src/main/kotlin/kotlinx/coroutines/experimental/slf4j/MDCContext.kt

@@ -0,0 +1,39 @@
+package kotlinx.coroutines.experimental.slf4j
+
+import org.slf4j.MDC
+import kotlin.coroutines.experimental.AbstractCoroutineContextElement
+import kotlin.coroutines.experimental.Continuation
+import kotlin.coroutines.experimental.ContinuationInterceptor
+import kotlin.coroutines.experimental.CoroutineContext
+
+class MDCContext(
+        private val context: CoroutineContext,
+        private val contextMap: Map<String, String> = MDC.getCopyOfContextMap()
+) : AbstractCoroutineContextElement(ContinuationInterceptor), ContinuationInterceptor {
+
+    override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> {
+        val next = context[ContinuationInterceptor]
+
+        val wrappedContinuation = Wrapper(continuation)
+
+        return when (next) {
+            null -> wrappedContinuation
+            else -> next.interceptContinuation(wrappedContinuation)
+        }
+    }
+
+    private inner class Wrapper<T>(private val continuation: Continuation<T>) : Continuation<T> {
+        private inline fun wrap(block: () -> Unit) {
+            try {
+                MDC.setContextMap(contextMap)
+                block()
+            } finally {
+                MDC.clear()
+            }
+        }
+
+        override val context: CoroutineContext get() = continuation.context
+        override fun resume(value: T) = wrap { continuation.resume(value) }
+        override fun resumeWithException(exception: Throwable) = wrap { continuation.resumeWithException(exception) }
+    }
+}

integration/kotlinx-coroutines-slf4j/src/test/kotlin/kotlinx/coroutines/experimental/slf4j/MDCContextTest.kt

@@ -0,0 +1,63 @@
+package kotlinx.coroutines.experimental.slf4j
+
+import kotlinx.coroutines.experimental.*
+import org.junit.Test
+import org.slf4j.MDC
+import kotlin.test.assertEquals
+
+class MDCContextTest : TestBase() {
+
+    @Test
+    fun mdcContextIsNotPassedByDefaultBetweenCoRoutines() = runTest {
+        expect(1)
+        MDC.put("myKey", "myValue")
+
+        launch {
+            val mdcValue = MDC.get("myKey")
+            check(mdcValue == null)
+            expect(2)
+        }.join()
+
+        expect(3)
+
+        finish(4)
+    }
+
+    @Test
+    fun mdcContextCanBePassedBetweenCoRoutines() = runTest {
+        expect(1)
+        MDC.put("myKey", "myValue")
+
+        launch(MDCContext(DefaultDispatcher)) {
+            val mdcValue = MDC.get("myKey")
+            check(mdcValue == "myValue")
+            expect(2)
+        }.join()
+
+        expect(3)
+
+        finish(4)
+    }
+
+    @Test
+    fun mdcContextNotNeededWhileOnMainThread() {
+        MDC.put("myKey", "myValue")
+
+        runBlocking {
+            val mdcValue = MDC.get("myKey")
+
+            assertEquals(mdcValue, "myValue")
+        }
+    }
+
+    @Test
+    fun mdcContextNeededWithOtherContext() {
+        MDC.put("myKey", "myValue")
+
+        runBlocking(MDCContext(DefaultDispatcher)) {
+            val mdcValue = MDC.get("myKey")
+
+            assertEquals(mdcValue, "myValue")
+        }
+    }
+}

settings.gradle

@@ -24,6 +24,7 @@ module('integration/kotlinx-coroutines-guava')
 module('integration/kotlinx-coroutines-jdk8')
 module('integration/kotlinx-coroutines-nio')
 module('integration/kotlinx-coroutines-quasar')
+module('integration/kotlinx-coroutines-slf4j')
 
 module('reactive/kotlinx-coroutines-reactive')
 module('reactive/kotlinx-coroutines-reactor')