General info

During @mrdziuban's work on trace4cats/trace4cats-xray#4 we've realized that we don't have a mechanism for overriding the way of generation of TraceId/SpanId. This PR introduces typeclasses for providing generators for them.

We now require F[_] : TraceId.Gen : SpanId.Gen bounds in the whole model from SpanContext to Span to EntryPoint. That is, we now can provide an X-Ray compatible traceId generator to EntryPoint.apply[F] if needed.

I also replaced wide bounds (e.g. Sync[F]) with fine-grained multiple bounds.

This change is (almost) fully source compatible, i.e. all the newly introduced context bounds are automatically derivable via previously existed bounds (e.g. Sync[F]). If a user didn't provide them explicitly, they shouldn't have any errors with recompilation. And, of course, the change is not binary compatible.

The default instances (as previously) are based on ThreadLocalRandom which is a fast, threadsafe, but cryptographically insecure RNG. Tracing seems to be a proper field of usage for such a generator.

How I see the usage of alternative generators on example of AWS X-Ray

1. We put alternative generators in a separate package named trace4cats.xray.compat in forms of implicit and explicit instances.

   Code sample

   package io.janstenpickle.trace4cats.xray
   
   import cats.effect.kernel.Sync
   import io.janstenpickle.trace4cats.model.TraceId
   
   package object compat {
     implicit def xrayTraceIdGenInstance[F[_]: Sync]: TraceId.Gen[F] = explicits.xrayTraceIdGen
   
     object explicits {
       def xrayTraceIdGen[F[_]: Sync]: TraceId.Gen[F] = TraceId.Gen.from(???)
     }
   }

2. When a user constructs an EntryPoint, they should provide the custom instance either via a global import clause or via a local instance.

   Code sample

   import io.janstenpickle.trace4cats.xray.compat._
   
   def entryPoint[F[_]: Async](process: TraceProcess): Resource[F, EntryPoint[F]] = {
     Resource.eval(LogSpanCompleter.create[F](process)).map { completer =>
       EntryPoint[F](SpanSampler.always[F], completer)
     }
   }

   or

   def entryPoint[F[_]: Async](process: TraceProcess): Resource[F, EntryPoint[F]] = {
     Resource.eval(LogSpanCompleter.create[F](process)).map { completer =>
       implicit val xrayTraceIdGen = io.janstenpickle.trace4cats.xray.compat.explicits.xrayTraceIdGen[F]
       EntryPoint[F](SpanSampler.always[F], completer)
     }
   }

There's also an option to provide a custom object with a factory apply method that uses custom generators, but as for me it doesn't seem more discoverable or clearer.