bend-trace-context

Releases (3)

• 0.2.0.0 indexed
• 0.1.2.0 unindexed
• 0.1.0.0 unindexed

Definitions (472)

trace_context.bend

• def Parse.idA supplied ID is exactly n lowercase hexadecimal digits, not all zero.
• def TraceId.parseParse a supplied trace ID: exactly 32 lowercase hexadecimal digits, not all zero.
• def TraceId.assert_randomRecord the caller's assertion that these digits were generated randomly, so that the random-trace-id flag is emitted with them.
• def TraceId.is_randomWhether the trace ID asserts that it was generated randomly.
• def TraceId.to_stringThe 32 lowercase hexadecimal digits of the trace ID.
• def TraceId.is_eqWhether two trace IDs name the same trace.
• def SpanId.parseParse a supplied span ID: exactly 16 lowercase hexadecimal digits, not all zero (laws span_id_parse and span_id_roundtrip).
• def SpanId.to_stringThe 16 lowercase hexadecimal digits of the span ID.
• def SpanId.is_eqWhether two span IDs name the same operation.
• def Sampling.resolveThe sampled indication a child receives: the inherited one, unless the caller set another (law sampling).
• def RemoteContext.from_traceparentInterpret a received strict-v00 value as the sender's context.
• def RemoteContext.from_idsBuild the sender's context from its parts, as an OpenTelemetry SDK does for a link or for a propagator of another format: its trace ID, its span ID and its sampled indication, kept as they are.
• def RemoteContext.trace_idThe trace the received context belongs to.
• def RemoteContext.span_idThe sender's operation: the parent ID of the received value.
• def RemoteContext.is_sampledThe sender's sampled indication.
• def Flags.knownThe known trace flags as a number: `sampled` in bit 0 and `random` in bit 1 (W3C 3.2.2.5), with the six reserved bits zero.
• def RemoteContext.flagsThe trace flags that the context keeps, as a number from 0 to 3: bit 0 is its sampled indication and bit 1 its trace ID's randomness assertion, the known flags that it was received or built with.
• def LocalContext.trace_idThe trace this participant's operation belongs to.
• def LocalContext.span_idThis participant's operation.
• def LocalContext.is_sampledThe sampled indication this participant sends.
• def LocalContext.to_traceparentThe participating representation of a local context: version 00, and flags limited to sampled (bit 0) and random-trace-id (bit 1), with every reserved bit zero (W3C 3.2.2.5.3; laws emitted_traceparent and emitted_projection).
• def LocalContext.flagsThe trace flags of the context as a number from 0 to 3: bit 0 is its sampled indication and bit 1 its trace ID's randomness assertion.
• def Parent.trace_idThe trace a child continues.
• def Parent.span_idThe parent's operation, which a child must not reuse.
• def Parent.is_sampledThe sampled indication a child inherits by default.
• def Context.from_idsRepresent an operation the caller owns, with supplied IDs and an explicit sampled indication.
• def Context.root_from_idsStart a trace with supplied IDs and the sampled indication that the caller decided, kept as it is given (spec #41, "Sampling decision when starting a trace"; law root).
• def Context.child_from_id.checkedThe child, unless the span ID was found equal to the parent's.
• def Context.child_from_idContinue the parent's trace with a new operation identified by a supplied span ID.
• def Context.restart_from_ids.checkedThe restarted root, unless the trace ID was found equal to the received one.
• def Context.restart_from_idsStart a new trace with supplied IDs instead of continuing a received context.
• def U32.to_hexThe eight lowercase hexadecimal digits of a word, most significant first (laws hex_injective and word_hex).
• def TraceId.from_digitsA trace ID from nonzero digits, with no randomness assertion.
• def TraceId.from_wordsA trace ID from four words, read most significant first: the first word gives the first eight digits.
• def SpanId.from_digitsA span ID from nonzero digits.
• def SpanId.from_wordsA span ID from two words, most significant first.
• def ParsedBytes.prependPut the two digits of one more byte in front of the bytes already read: n bytes become 1 + n.
• def Parse.byte.checkedThe two digits of a cell, or InvalidByte at its offset when the check found the cell above 255.
• def Parse.byteRead one cell as a byte.
• def Parse.bytesConsume exactly n cells as bytes, keeping the cells after them.
• def Parse.bytes_endThe list must end after the ID's bytes: a cell after them fails with TrailingInput, whatever it holds.
• def Parse.id_bytes.finishThe bytes of a supplied ID must be the whole list, and not all zero.
• def Parse.id_bytesA supplied ID is exactly n bytes, not all zero.
• def TraceId.to_bytesThe 16 bytes of the trace ID, most significant first, in Base's byte convention, that of TCP.send_bytes and TCP.recv_bytes: one U32 cell from 0 to 255 per byte.
• def TraceId.from_bytesRead a trace ID from exactly 16 bytes, most significant first.
• def SpanId.to_bytesThe 8 bytes of the span ID, most significant first (laws span_bytes, span_bytes_roundtrip and span_bytes_injective).
• def SpanId.from_bytesRead a span ID from exactly 8 bytes, most significant first, with the rules and errors of TraceId.from_bytes.
• def Draw.assertedGeneration reads its words from a source trusted to be random, so each trace ID candidate asserts random-trace-id.
• def Tape.nextA deterministic word source for tests and replay: each read takes the next result, and an empty tape fails with code 1, tape-exhausted.
• def Drive.fedThe driver of the three machines: a trace ID draw, a span ID draw and a generation.
• def Drive.runDrive a machine from a tape, stopping as soon as its step has ended; unread words stay on the tape.
• def Drive.readDrive a machine from any source, one word at a time.
• def Drive.endedWhether the machine in a driver's result has ended.
• def Drive.outcomeThe source's final state with the result that `result` gives of the machine's final step.
• def Drive.finishedTurn the IO driver's final step into its result.
• def TraceDraw.startA trace ID draw starts with its first candidate; seven further candidates may follow it, eight in all.
• def TraceDraw.retryTry another trace ID candidate, or fail once the eight are used.
• def TraceDraw.reuseA trace ID candidate equal to the excluded one is retried.
• def TraceDraw.checkCheck a complete trace ID candidate: zero and the excluded trace ID are retried; anything else is the trace ID drawn.
• def TraceDraw.takeAdd a word to the current trace ID candidate.
• def TraceDraw.feedFeed the next source word to a trace ID draw, given as its three fields.
• def TraceDraw.nextThe step of a trace ID draw after its next source word, TraceDraw.feed of its fields: the `feed` that Drive takes.
• def TraceStep.waitingThe draw that a trace ID draw's step feeds its next word to, while it waits for one: the view of the step that Drive needs.
• def TraceDraw.resultThe trace ID of a finished trace ID draw, or why it failed.
• def TraceDraw.runDrive a trace ID draw from a tape (Drive.run).
• def TraceDraw.endedWhether the trace ID draw in a driver's result has ended.
• def TraceDraw.outcomeThe source's final state with the trace ID draw's result.
• def TraceId.generate_withA trace ID alone, from a caller's source, as an OpenTelemetry SDK generates one before its sampler decides on it.
• def SpanDraw.startA span ID draw starts with its first candidate; seven further candidates may follow it, eight in all.
• def SpanDraw.retryTry another span ID candidate, or fail once the eight are used.
• def SpanDraw.reuseA span ID candidate equal to the excluded one is retried.
• def SpanDraw.checkCheck a complete span ID candidate: zero and the excluded span ID are retried; anything else is the span ID drawn.
• def SpanDraw.takeAdd a word to the current span ID candidate.
• def SpanDraw.feedFeed the next source word to a span ID draw, given as its three fields.
• def SpanDraw.nextThe step of a span ID draw after its next source word, SpanDraw.feed of its fields: the `feed` that Drive takes.
• def SpanStep.waitingThe draw that a span ID draw's step feeds its next word to, while it waits for one.
• def SpanDraw.resultThe span ID of a finished span ID draw, or why it failed, as TraceDraw.result; law span_id_ends shows that the word budget of SpanId.generate_with makes the unfinished case unreachable.
• def SpanDraw.runDrive a span ID draw from a tape (Drive.run).
• def SpanDraw.endedWhether the span ID draw in a driver's result has ended.
• def SpanDraw.outcomeThe source's final state with the span ID draw's result.
• def SpanId.generate_withA span ID alone, from a caller's source, as an OpenTelemetry SDK generates one once its sampler has decided.
• def Step.of_spanThe generation that a span ID draw's step gives, for a context of `trace_id` with the sampled indication `sampled`: waiting for the draw's next word, the context once the span ID is drawn, or the draw's failure.
• def SpanPlan.rootThe plan of a root's span ID, once its trace ID is drawn, and of a restart's: nothing to exclude, and the sampled indication that the root or the restart was given, as it is given.
• def SpanPlan.childThe plan of a child's span ID: the parent's span ID excluded, the parent's trace ID, and the sampled indication that `sampling` resolves from the parent's.
• def SpanPlan.drawThe generation that draws the span ID of a plan, from its first candidate.
• def Step.of_traceThe generation that a trace ID draw's step gives, for a root or a restart with the sampled indication `sampled`: waiting for the draw's next word, the root's span ID draw once the trace ID is drawn (SpanPlan.root), or the draw's failure.
• def TracePlan.rootThe plan of a root: no trace ID to exclude, and the sampled indication `sampled`, as it is given.
• def TracePlan.restartThe plan of a restart replacing `previous`: the received trace ID to exclude, and the sampled indication `sampled`, as it is given.
• def TracePlan.drawThe generation that draws the new trace of a plan: its trace ID, from the first candidate, then the span ID of the root's span plan (Step.of_trace).
• def Draw.rootA root draws the new trace of its plan (TracePlan.root).
• def Draw.restartA restart draws like a root but excludes the received trace ID (TracePlan.restart).
• def Draw.childA child draws the span ID of its plan (SpanPlan.child).
• def Draw.feedFeed the next source word, or the source's error, to the trace ID draw or the span ID draw that the generation runs.
• def Step.waitingThe draw that a generation's step feeds its next word to, while it waits for one.
• def Step.resultThe result of a finished generation.
• def Draw.runDrive a generation from a tape (Drive.run).
• def Draw.readDrive a generation from any source (Drive.read).
• def Draw.endedWhether the generation in a driver's result has ended.
• def Draw.outcomeThe source's final state with the generation's result.
• def Draw.finishedTurn the driver's final step into the generation's result.