Spans as Resources

[tabdulradi]

Spans have lifetime, i.e. they get created, logged against, then finally they must be finished.

Currently we tackle this in Cats DSL by providing inChildSpan block, that uses Bracket to guarantee finishing the Span even in case of failures. The signature looks like this (simplified)

def inChildSpan[A](operationName: String)(thunk: F[A]): F[A]

The aim of this task, is try to change the signature to be

def childSpan(operationName: String): Resource[F, SpanOps[F]]

So that it'd be used like this:

def getUser[F[_]](userId: String) =
  childSpan[F]("getUser").use { span =>
    span.log("userId" -> userId) *> getUserImpl(userId)
  }

Please keep in mind that Span get's propagated along the context of F, creation of child Span should yield a Tree-like lineage of spans. For example:

childSpan[F]("outer").use { _ =>
  childSpan[F]("inner1").use { _ => 
    childSpan[F]("inner11").use { _ => op1(userId) }
  } *>
  childSpan[F]("inner2").use { _ => 
    childSpan[F]("inner22").use { _ => op2(userId) }
  }
}

means that spans inner1 & inner2 are adjacent, and both are children of outer.

outer 
  |_ inner1
     |_ inner11
  |_ inner2
     |_ inner22

[tabdulradi]

Approach 1

Keeping Propagation as ReaderT

PR #14 attempts to implement childSpan as follows:

def childSpan(operationName: String): Resource[F, SpanOps[F]] = Resource[F, SpanOps[F]] {
  for {
    parent <- tracing.currentSpan()
    span <- tracing.startChild(parent, operationName)
    // ReaderT.local doesn't play nice with Resource.
  } yield span -> tracing.finish(span)
}

The code above doesn't work. Spans look like:

outer 
  |_ inner1
  |_ inner11
  |_ inner2
  |_ inner22

Everything was a direct child of the root span.

Since Propagation is backed by a ReaderT, we can only change the currentSpan by calling ReaderT.local(newSpan)(codeThatRunsWithTheNewSpan), the problem here that we inverted the control, codeThatRunsWithTheNewSpan is not a parameter any more.

[tabdulradi]

Approach 2

Implement Propagation as StateT

PR #13 attempts to implement Propagation as a StateT, which would allow setting the current span to new one, however we can't set it back to the parent span once the child has been finished.

for {
  parent <- tracing.getSpan()
  span <- tracing.startChild(parent, operationName)
  _ <- tracing.setSpan(span)
  release = tracing.finish(span) *> tracing.setSpan(parent) // this doesn't work, release is not part of the monadic flow
} yield richSpan -> release

As result of this, code in the PR produce wrong spans.

outer 
  |_ inner1
     |_ inner11
        |_ inner2
           |_ inner22

Every span was a child of the previous span, even if it was just adjacent to it.