Coroutines Stacktrace Recovery trims the suspend call stack

[andriybobchuk]

Describe the bug

I enabled stack trace recovery with
System.setProperty("kotlinx.coroutines.stacktrace.recovery", "true")
in my project's Application class onCreate, but it does not seem to work for me no matter what I do.

For example this code:

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        runBlocking {
            callerFunction1()
        }
     }

fun callerFunction1() {
        CoroutineScope(Dispatchers.Main + CoroutineName("Caller1")).launch {
            intermediateFunction1()
        }
}

suspend fun intermediateFunction1() {
        delay(100) 
        intermediateFunction3()
    }

suspend fun intermediateFunction2() {
        delay(100)
        crashFunction()
    }

will trim the stack trace only to crashFunction call without any callers info.

What I tried:

• Using Coroutine ExceptionHandler
• Using try-catch at the top level
• Using my CustomException which implements CopiableThrowable
• Using other types of exception like IllegalStateException

Environment

• Android
• Standard debug build - no Proguard or R8
• kotlin 2.0.0
• coroutinesVersion 1.8.1

[dkhalanskyjb]

Please use Stack Overflow or the Kotlin Slack for usage questions.

As described in https://github.com/Kotlin/kotlinx.coroutines/blob/master/docs/topics/debugging.md, stacktrace recovery is enabled by default whenever the debug mode is enabled, you don't need to enable it manually. You do need to enable the debug mode, though.

Here's a minimal example to get you going (copy-pasted from the docs linked to above):

import kotlinx.coroutines.*

object PublicApiImplementation : CoroutineScope by CoroutineScope(CoroutineName("Example")) {

    private fun doWork(): Int {
        error("Internal invariant failed")
    }

    private fun asynchronousWork(): Int {
        return doWork() + 1
    }

    public suspend fun awaitAsynchronousWorkInMainThread() {
        val task = async(Dispatchers.Default) {
            asynchronousWork()
        }

        task.await()
    }
}


fun main() {
    System.setProperty(DEBUG_PROPERTY_NAME, DEBUG_PROPERTY_VALUE_ON) // comment out to disable recovery
    runBlocking {
        // Try to switch debug mode on and off to see the difference
        PublicApiImplementation.awaitAsynchronousWorkInMainThread()
    }
}