How to completely execute async method even after main thread execution ends?

I have a requirement in Kotlin where I need some logic in a method which includes logging and a network call.

I have tried different coroutine builders and async {} but no luck and I can not use threads. There will be thousands of requests.

This logic has high latency than the main flow itself. I want to execute this method asynchronously. But problem is

• Even the execution is async the main thread waits for it to complete
  before returning the response.
• If I use GlobalScope, the logging does not happen (I do not see the logs and I am not sure why this happens).

@GRpcService
class myApi() {

   override suspend fun createSomething(request: Request): Response  = coroutineScope {
       
        getSomething()
        getSomethingSomething()
        
        // I want to call a method here asynchronously 

        return response // but this response should not be delayed in any way
    }
}

I have an idea but I am not sure if it will work as I have not tested it but you can use NonCancellable context. Here is example:

 @GRpcService
 class myApi() {

   override suspend fun createSomething(request: Request): Response  = 
    coroutineScope {
   
    getSomething()
    getSomethingSomething()

    launch(NonCancellable + Dispatchers.IO) {
       // I want to call a method here asynchronously 

     }
    return response // but this response should not be delayed in any way
 }
}

If I understand correctly, you want to be able to fire off asynchronous work that doesn’t have to be waited for in the current coroutine, but must be finished before the app terminates. I have not tried this, but maybe you can store your top level runBlocking’s scope and use it to run these side tasks.

private lateinit var topScope: CoroutineScope

fun main() = runBlocking(Dispatchers.Default) {
    topScope = this
    //. . .
}

fun submitRequiredAsyncTask(
    context: CoroutineContext = EmptyCoroutineContext,
    block: suspend CoroutineScope.()->Unit
): Job {
    return topScope.launch(context) { 
        try { block() }
        catch(e: Exception) {
            if (e is CancellationException) throw e
            // logging
        }
    }
}

@GRpcService
class myApi() {

   override suspend fun createSomething(request: Request): Response  = 
       coroutineScope {
   
           getSomething()
           getSomethingSomething()

           submitRequiredAsyncTask(Dispatchers.IO) {
               // I want to call a method here asynchronously 

           }
           response // but this response should not be delayed in any way
       }
   }

}

What we are doing here is running these tasks in child coroutines of the top level runBlocking, which must wait for all its children to finish. You were trying to run them either as children of the current coroutine (causing the hang as the current coroutine waits for its children) or as GlobalScope coroutines (the main function won’t wait for them to finish).