A Natchez-like "continuation" API to avoid MonadCancelThrow leakage?

[rossabaker]

Compared to natchez.Trace, a library instrumented with org.typelevel.otel4s.trace.Tracer may require stronger constraints.

Natchez

The Natchez Trace API includes:

  /** Create a new span, and within it run the continuation `k`. */
  def span[A](name: String, options: Span.Options = Span.Options.Defaults)(k: F[A]): F[A]

Typical usage is:

Trace[F].span("child") {
  someEffect
}

Spanning someEffect only requires a Trace constraint.

Otel4s

As of #37, our Tracer provides the following API, via TracerMacro:

  def span(name: String, attributes: Attribute[_]*): Resource[F, Span[F]]

We might do:

Tracer[F].span("child").use { span =>
  someEffect
}

Or, equivalently, and closer to Natchez:

Tracer[F].span("child").surround {
  someEffect
}

.use and .surround both introduce a MonadCancelThrow constraint on spanned code, even if the concrete tracer is the simple, applicative noop. It's nice to have the full power of resource, but it's also now difficult to instrument an existing library without constraints rippling beyond Tracer.

[rossabaker]

I think the spanK on natchez.Trace is awfully neat, returning an F ~> F. It possibly costs a few nanoseconds more.

[rossabaker]

I added a naive spanK to Tracer:

  def spanK(name: String, attributes: Attribute[_]*): F ~> F =
    macro TracerMacro.spanK

But the macro inlines the implementation, and thus need for a MonadCancelThrow, at the call site. Drat.

[iRevive]

Not ideal, but we can hide some instances there https://github.com/typelevel/otel4s/blob/main/core/common/src/main/scala/org/typelevel/otel4s/meta/InstrumentMeta.scala

[rossabaker]

That spanK is like surround. For the current TracingExample, we also need something like use, or a way to augment the contextual span without referencing it directly. I'm afraid we're writing macros for many of the methods of Resource, or writing forwarders for most of the methods of Span.

        Tracer[F].span("Work.DoWork").use { span =>
          span.addEvent("Starting the work.") *>
            doWorkInternal *>
            span.addEvent("Finished working.")
        }

[rossabaker]

This is an uphill climb, because childScope and rootScope and noopScope also return Resource. Even if we replace span with something that hides the MonadCancelThrow, we have to deal with all of those.

[rossabaker]

We still need a MonadCancelThrow to construct even a noop instance, but we've removed the need from the use sites. I'm declaring victory.