sdk-trace: add IdGenerator

[iRevive]

Reference	Link
Spec	https://opentelemetry.io/docs/specs/otel/trace/sdk/#id-generators
Java implementation	IdGenerator.java RandomIdGenerator.java

[armanbilge]

Suggested change

	private val InvalidId = 0
	private final val InvalidId = 0

[armanbilge]

What are the rules for trace ids? is it not a valid trace id if hi != 0 but lo == 0?

[iRevive]

Yes. At least it's correct for Java SDK: https://github.com/open-telemetry/opentelemetry-java/blob/main/sdk/trace/src/main/java/io/opentelemetry/sdk/trace/RandomIdGenerator.java#L32-L38

[armanbilge]

A valid trace identifier is a 16-byte array with at least one non-zero byte.

Isn't that ID generator missing lots and lots of possible valid IDs? Is that intentional 🤔

[armanbilge]

Aha, there is some explanation here in open-telemetry/opentelemetry-java#3291 (comment). I'm not sure if that's still relevant, or relevant to us.

[iRevive]

I guess we can stick with Java SDK implementation

[armanbilge]

😱

[iRevive]

On the other hand, you rarely need to allocate 1 million random uuids

[iRevive]

nextLong:

      for {
        r <- f
        out <- Sync[F].delay(r.nextLong())
      } yield out

nextLongBounded:

    def nextLongBounded(n: Long): F[Long] = {
      /*
       * Divide n by two until small enough for nextInt. On each
       * iteration (at most 31 of them but usually much less),
       * randomly choose both whether to include high bit in result
       * (offset) and whether to continue with the lower vs upper
       * half (which makes a difference only if odd).
       */
      for {
        _ <- require(n > 0, s"n must be positive, but was $n")
        offset <- Ref[F].of(0L)
        _n <- Ref[F].of(n)
        _ <- Monad[F].whileM_(_n.get.map(_ >= Integer.MAX_VALUE))(
          for {
            bits <- nextIntBounded(2)
            halfn <- _n.get.map(_ >>> 1)
            nextN <- if ((bits & 2) == 0) halfn.pure[F] else _n.get.map(_ - halfn)
            _ <-
              if ((bits & 1) == 0) _n.get.flatMap(n => offset.update(_ + (n - nextN)))
              else Applicative[F].unit
            _ <- _n.set(nextN)
          } yield ()
        )
        finalOffset <- offset.get
        int <- _n.get.flatMap(l => nextIntBounded(l.toInt))
      } yield finalOffset + int
    }

[armanbilge]

Gosh, is that really the implementation? I assumed it was delegating to the underlying Random instance, not that there are atomics and monadic loops in there 🤦

[iRevive]

I believe I'm looking into the right one :D

https://github.com/typelevel/cats-effect/blob/9ff20a5ce17e91b0a61addf7f724e498cb13578e/std/shared/src/main/scala/cats/effect/std/Random.scala#L403

[armanbilge]

I hope we don't get screwed over by compatibility 😇 probably not, but the F[_] makes it impossible for us to add default implementations of new methods where other languages could.