Work with ThreadLocal-sensitive Components

Many application trace framework use ThreadLocal to store the call context of a application, like the SLF4j MDC, CAT , and other distributed trace system(which use thread local for trace the context in some async situation).

But the coroutine will be dispatched to a unspecified thread to execute, how can i make the tracing work?

[elizarov]

We should really have it out-of-the box in a separate integration module.

[elizarov]

API in PR #454 now looks like this. In your to use it you have to define your own context element that implements ThreadContextElement interface like this:

// declare thread local variable holding MyData
private val myThreadLocal = ThreadLocal<MyData?>()

// declare context element holding MyData
class MyElement(val data: MyData) : ThreadContextElement<MyData?> {
    // declare companion object for a key of this element in coroutine context
    companion object Key : CoroutineContext.Key<MyElement>

    // provide the key of the corresponding context element
    override val key: CoroutineContext.Key<MyElement>
        get() = Key

    // this is invoked before coroutine is resumed on current thread
    override fun updateThreadContext(context: CoroutineContext): MyData? {
        val oldState = myThreadLocal.get()
        myThreadLocal.set(data)
        return oldState
    }

    // this is invoked after coroutine has suspended on current thread
    override fun restoreThreadContext(context: CoroutineContext, oldState: MyData?) {
        myThreadLocal.set(oldState)
    }
}

The implementation is quite efficient now. Its cost is O(N), where N is the size of the context (number of elements in the context). When a coroutine is resumed on a thread its context is scanned for elements that implement ThreadContextElement and they are given change to update the context of the thread.