Annotation @NewSpan does not work for kotlin suspend functions

[mckernant1]

Hey!

I'm building a spring grpc application. I have attached @NewSpan to some suspend service method that makes reactor calls using .awaitSingleOrNull() to convert the Mono to kotlin's suspend syntax.

Tech stack

• Spring Grpc
• Reactor
• Kotlin suspend
• Kotlin reactor bridge (kotlinx.coroutines.reactor)
• opentelemetry-extension-kotlin

I have tried an alternate syntax of wrapping the function body in a span, and that seems to work.

suspend fun example(
    argA: String,
    argB: String
): {
    val span = tracer.nextSpan()
        .name("example")
        .tag("argA", argA)
        .tag("argB", argB)
    try {
       block...
    } finally {
        span.end()
    }
}

Can this annotation be expanded to support this behavior?

[jonatan-ivanov]

Annotations are meant to be used with imperative-style not reactive.
Reactor has the .tap operator for this. Also, you might want to consider using the Observation API instead of just using spans (Reactor has built-in support for that).

This could also help: https://github.com/micrometer-metrics/micrometer/tree/main/micrometer-core/src/main/kotlin/io/micrometer/core/instrument/kotlin

[mckernant1]

Hmmm I see. I guess for the newer async/await style while it is reactive, it looks/feels a lot more imperative.

And tap doesn't feel amazing to add to individual calls that look like a series of await steps. It makes a lot more sense in a functional Mono/Flux chain where you return a Mono/Flux at the end of your function.

suspend fun ex() {
  val res1 = db.getSomeValue().awaitSingle()
  val res2 = db.getOtherValue(res1).awaitSingle()
  ...
}

I'll take a look into the observation stuff. It seems like I would just wrap my functions with this instead of spans. But with reactor support this makes sense.

Thanks!

Edit:
With some AI help and messing around for a while I was able to write an extension function that does what i want i think.
Still a bit confused by the Contexts of it all tbh... But this is generating the traces (which are nested correctly), and I am no longer getting memory leak warnings from observations not being stopped due to thread boundries

suspend fun <T> ObservationRegistry.observe(
    name: String,
    block: suspend () -> T
): T {
    val observation = Observation.createNotStarted(name, this)
        .start()

    return withContext(observation.openScope().use { this.asContextElement() }) {
        try {
            block()
        } catch (e: Throwable) {
            observation.error(e)
            throw e
        } finally {
            observation.stop()
        }
    }
}

[github-actions]

If you would like us to look at this issue, please provide the requested information. If the information is not provided within the next 7 days this issue will be closed.