```@Component class RiskAssertionFeedbackHandler( ) { companion object { } f...

# coroutines

[NewtoKotlin]

@Component
class RiskAssertionFeedbackHandler(


) {
    companion object {
        
    }

    fun sendFeedback (authZResponse: AuthZResponse){
        val customScopeLocal = CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO> + MDCContext())
        customScopeLocal.launch {
            when {
                isOperationSupportedForAuthBlock(authZResponse, reason!!, operationMethodName!!) -> {
                    authBlockedFeedbackHandler.recordAuthBlocked(authZResponse, reason , operationMethodName)
                }
          
            }
        }
    }

    fun sendFeedback(operationMethodName: String, feedbackTransaction: FraudTransaction) {
        ThreadContextLocal.addAllAttributesToMDC()
        val customScope = CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO> + MDCContext())
        customScope.launch {
            when (feedbackTransaction) {
                FraudTransaction.AUTH_BLOCKED -> authFailedFeedbackHandler.recordAuthFailed(operationMethodName)
                FraudTransaction.UAF_REG_PASS -> uafRegPassFeedbackHandler.recordUAFRegPass(operationMethodName)
                FraudTransaction.UAF_REG_FAILED -> uafRegFailedFeedbackHandler.recordUAFRegFailed(operationMethodName)
            }
        }
    }

Is this efficient way to launch coroutines ? I read that CoroutineScope is also same as GlobalLaunch and not good for production.

[ephemient]

it is not a good way to do that, no

[ephemient]

not enough context to determine what the right scope is, but in most cases I would say it should be injected instead of created by a class like this

[NewtoKotlin]

Can you pls give an example?

[NewtoKotlin]

This coroutine is used to make a rest api call to downstream api

[NewtoKotlin]

Also functions from this class are invoked in during api processing to make an async call

[NewtoKotlin]

Because callers of this function are not suspended,need to find a way call suspended functions from non- suspended one

[NewtoKotlin]

@ephemient can you pls help with above ?

[NewtoKotlin]

Can someone help with this ?

[ross_a]

Typical pattern I use with Spring is this:

@Configuration
class MyConfiguration {

    @Qualifier("default")
    @Bean
    fun defaultDispatcher() = Dispatchers.Default
}

@Component
class MyComponent(
    @Qualifier("default") private val defaultDispatcher: CoroutineDispatcher,
) {
    private val backgroundScope = CoroutineScope(
        defaultDispatcher +
                SupervisorJob() +
                CoroutineExceptionHandler { coroutineContext, throwable ->
                    // logging
                }
    )
    
    fun launchBackgroundWork(): Job {
        return backgroundScope.launch { 
            // Background work
        }
    }

    fun launchOtherBackgroundWork(): Job {
        return backgroundScope.launch {
            // Background work
        }
    }
    
    @PreDestroy
    fun destroy() {
        backgroundScope.cancel()
    }
}

[ross_a]

Inject the dispatchers so that it can be replaced for testing
Create a scope per service component with appropriate exception handling/logging
Use SupervisorJob so that one launched task failing doesn't cause the scope to terminate
Use @PreDestroy to ensure the scope is bound to the bean's lifecycle (particularly useful if your Spring application does context reloads).
I often return Job when launching background work so that the calling method can optionally choose to wait for completion with join, but this is optional

[NewtoKotlin]

Thanks for responding

[NewtoKotlin]

I need to pass mdc context with each request from which coroutine will be started

[ross_a]

ah yeah so that's just:

fun launchOtherBackgroundWork(): Job {
        return backgroundScope.launch(MDCContext()) {
            // Background work
        }
    }

[NewtoKotlin]

Thank you so much!

[ross_a]

👍

[NewtoKotlin]

One follow up question on this, if one coroutine fails in background scope will it block execution of other coroutines ?

[ross_a]

no, because of the added SupervisorJob()

[ross_a]

https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-supervisor-job.html