bend-trace-context

Releases (3)

• 0.2.0.0 indexed
• 0.1.2.0 unindexed
• 0.1.0.0 unindexed

Definitions (472)

entropy.bend

• def read_u32One word from the host's cryptographic source: WebCrypto in JavaScript and the operating system's generator natively.

generation.bend

• def Source.hostThe host source as the machine reads it: each read returns one word result from Entropy.read_u32, and the state is Unit because the host keeps none.
• def on_hostThe host source has no state to hand back.
• def TraceId.generateA trace ID alone, as an OpenTelemetry SDK generates one before its sampler decides on it (TC.TraceId.generate_with).
• def SpanId.generateA span ID alone, as an SDK generates one once its sampler has decided, or for a child span with its parent's span ID excluded (TC.SpanId.generate_with).
• def Context.rootStart a trace: a trace ID, then a span ID, as TC.Context.root_with composes them, with the sampled indication `sampled`, as it is given.
• def Context.childContinue a remote or local parent with a new operation.
• def Context.restartStart a new trace instead of continuing a received context, with the sampled indication `sampled`, as a root takes it.
• def Context.continue_or_startGive a service its own operation for a received message: a child of the context that extraction keeps, the message's or the base, a root without one, or a new trace in its place at a trust boundary (TC.Context.continue_or_start_with).
• def Context.sendGive one message that the service sends a new child of the service's operation, or the fallback when none can be generated (TC.Context.send_with).
• def NativeHttp.continue_or_startThe service's own operation for a received request, from the header map of the request, on the host's cryptographic source: native_http.bend's continue_or_start_with on Source.host.
• def NativeHttp.sendGive one request that the service sends the context of a new operation, on the host's cryptographic source: native_http.bend's send_with on Source.host, which replaces the context fields of `headers`, the request's own header map.

native_http.bend

• def HeaderMapThe header fields of a bend-kit request or response: each name, as bend-kit stores it, with its values in arrival order.
• type OutboundA request to send: the context fields the package gave it (`sent`), and the header map to send it with, which holds those fields.
• def Headers.pushOne field for each value of `name`, pushed onto `fields` in order, so that the last value ends up first.
• def Headers.gatherThe fields of every entry pushed onto `fields`, entry by entry.
• def carrierThe header fields of a map as a carrier for TC.Context.extract or TC.Context.send: every value of every name, in arrival order within each name (law http_carrier).
• def Headers.valuesThe values a map holds under `name`, none when it has no entry for it.
• def Headers.addPut one field's value first among its name's values.
• def Headers.writePut every field of `fields` first among its name's values, in order.
• def headersThe header map of a carrier, such as the one TC.Sent.carrier gives for a message to send: under each name, the carrier's values of that name in order (law http_headers), as bend-kit's Http.add would add them one by one, with the names as the carrier spells them.
• def continue_or_start_withThe service's own operation for a received message, from the header map of its request, on a caller's source: TC.Context.continue_or_start_with over the extraction of the map's carrier (law http_continue).
• def Headers.outboundThe request to send for a message: the message with the map of the fields that TC.Sent.carrier gives.
• def Headers.strictThe same for a strict result: a failure stays a failure.
• def Headers.writtenA message sent under `policy`, with its header map.
• def Headers.written.doneThe source's final state with a message sent under `policy` and its map.
• def send_withGive one request that the service sends the context of a new operation, on a caller's source: TC.Context.send_with on the carrier of `headers`, the request's own header map, and the map of the fields it gives back (law http_send).
• def Outbound.sentThe context fields that the package gave the request.
• def Outbound.headersThe header map to send the request with.

src/digits.bend

• type Digits.NilThe length is part of the type.
• type Digits.ConA first digit followed by a sequence of p digits: a value of Digits(1n+p).
• def DigitsThe type of sequences of exactly n digits, computed from n: Digits(0n) is Digits.Nil and Digits(1n+p) is Digits.Con<p>.
• def Digits.to_stringThe n lowercase characters of the digits, in order.
• def Digits.is_zeroWhether every digit is 0.
• def Digits.of_u32The eight digits of a word, most significant first: the first digit holds bits 31 to 28 and the last digit bits 3 to 0.
• def Digits.to_u32The word whose eight digits these are, most significant first.
• def Digits.to_byteThe byte of two digits, the high digit first: 16 times the high digit plus the low one, from 0 to 255.
• def Digits.of_byteThe two digits of a byte, the high digit first: bits 7 to 4, then bits 3 to 0.
• def Digits.to_bytesThe n bytes of 2n digits, most significant first: each byte takes the next two digits, the first of them high.
• def Digits.appendThe digits of `left` followed by those of `right`: m + n digits.
• type NonZeron digits that are not all zero.
• def NonZero.new.checkedCarry the equation into the branch: matching status refines its right side.
• def NonZero.newAttach the proof that the digits are not all zero, or None when they are.
• def NonZero.digitsThe digits, without their proof.
• def NonZero.to_stringThe n lowercase characters of the digits.

src/hex.bend

• type DigitA hexadecimal digit has exactly these sixteen values, H0 to Hf, in value order.
• def Digit.to_charThe lowercase character of a digit: '0' to '9', then 'a' to 'f'.
• def Digit.to_u32The value of a digit, 0 to 15.
• def Digit.is_zeroWhether the digit is 0.
• def Digit.is_oddWhether bit 0 (value 1) of the digit is set.
• def Digit.has_bit1Whether bit 1 (value 2) of the digit is set.
• def Digit.has_bit2Whether bit 2 (value 4) of the digit is set.
• def Digit.has_bit3Whether bit 3 (value 8) of the digit is set.
• def Digit.from_bitsThe digit whose value is bit0 + 2 * bit1 + 4 * bit2 + 8 * bit3.
• def Digit.allEvery digit, in encoding order.
• def Digit.from_char.findSearch the encoder's own alphabet, so an accepted character is exactly the encoding of the digit returned for it.
• def Digit.from_charThe digit a character encodes.

trace_context.bend

• type FieldThe field that a ZeroId error names: the trace ID or parent ID of a traceparent value, or a supplied span ID.
• type ErrorWhy the strict codec, TraceId.parse, SpanId.parse or TraceParent.read refused a text, or TraceId.from_bytes or SpanId.from_bytes a list of bytes.
• type ContextErrorWhy creating a context from supplied IDs was refused: a child reused its parent's span ID, or a restart reused the received trace ID.
• type ParsedA sequence of n digits read from the front of a text, with the text that remains after it.
• type ParsedBytesThe digits of n bytes read from the front of a list of cells, two digits per byte, with the cells that remain after them.
• type TraceParentV00A strict traceparent v00 value (W3C 3.2.2): a trace ID of 32 digits and a parent ID of 16 digits, each with a proof that it is not all zero, and a flag byte of two digits.
• type TraceIdA validated trace ID: 32 lowercase hexadecimal digits, not all zero (W3C 3.2.2.3).
• type SpanIdA validated span ID: 16 lowercase hexadecimal digits, not all zero, the identifier of one operation.
• type SamplingHow a child operation obtains its sampled indication (W3C 3.2.2.5.1): InheritSampled{} keeps the parent's and SetSampled{sampled} sets it.
• type RemoteContextA context received from another participant.
• type LocalContextA context that identifies an operation of this participant: the one it sends in its own headers.
• type ParentThe context whose trace a child operation continues: a received context or one of this participant's own operations.
• type GenerationErrorWhy generating identifiers failed.
• type TraceWordsThe words read so far for the current trace ID candidate, in arrival order.
• type SpanWordsThe words read so far for the current span ID candidate.
• type TraceDrawThe generation machine below is shared by the IO operations and stated in the laws.
• type SpanDrawA span ID draw that waits for a word, as TraceDraw: `excluded` is the span ID that no candidate may repeat, such as a child's parent's.
• type TraceStepA trace ID draw after each source word, whether it generates a trace ID alone or the trace ID of a root or a restart: it waits for another word, it drew a trace ID, or it failed.
• type SpanStepA span ID draw after each source word, whether it generates a span ID alone or the span ID of a root, a child or a restart, as TraceStep.
• type SpanPlanWhat a new local context needs besides its span ID: the span ID that it must not repeat (`excluded`), such as a child's parent's, the trace ID that it belongs to, and its sampled indication.
• type TracePlanWhat a new trace needs, a root or a restart: the trace ID that its trace ID must not repeat (`excluded`), none for a root and the received one for a restart, and the sampled indication of the context that it creates.
• type DrawA generation in progress: the trace ID draw of a root or a restart, with the sampled indication of the context that it starts, or a span ID draw, with the trace ID and the sampled indication of the context that its span ID completes.
• type StepThe state of a generation after each source word: it needs another word, it created a context, or it failed.
• type GenerationA generation with its word budget, for a host that feeds it one word at a time instead of passing a source as a template, such as JavaScript code calling this module: the words it may still read (`fuel`) and the machine's step.
• def Parsed.prependPut one more digit in front of a parsed sequence: n digits become 1 + n.
• def Parse.digit_resultA decoded character, or InvalidHex at its offset when it is not a lowercase hexadecimal digit.
• def Parse.digitDecode one character as a lowercase hexadecimal digit.
• def Parse.digitsConsume exactly n characters as digits, keeping the unconsumed rest of the text.
• def Parse.separator_resultThe rest of the text after a "-", or ExpectedSeparator at its offset.
• def Parse.separatorRead the "-" expected at `offset`.
• def Parse.endThe value must end here.
• def Parse.versionThe version digits: 00 is the only version the strict codec reads, ff is forbidden (W3C 3.2.2.1), and any other version is reported with its text.
• def Parse.nonzero_resultAttach the proof that digits are not all zero, or fail with ZeroId naming the field.
• def Parse.nonzeroCheck that digits are not all zero (W3C 3.2.2.3, 3.2.2.4).
• def Parse.flagsThe last field: the two flag digits, then the end of the text.
• def Parse.parentAfter the trace ID: the parent ID, which must not be all zero, its "-" at offset 52 and the flag digits at offset 53.
• def Parse.traceAfter the version: the trace ID, which must not be all zero, its "-" at offset 35 and the parent ID from offset 36.
• def Parse.startAfter the two version digits: the version check, the "-" at offset 2 and the trace ID from offset 3.
• def TraceParentV00.parseParse a strict traceparent v00 value: exactly "00-", 32 lowercase hexadecimal digits, "-", 16 digits, "-" and two digits; the IDs must not be all zero.
• def TraceParentV00.formatThe text of a strict v00 value: always 55 characters.
• def TraceParentV00.is_sampledWhether the sampled flag, bit 0 of the flag byte, is set (W3C 3.2.2.5.1).
• def TraceParentV00.is_randomWhether the random-trace-id flag, bit 1, is set (W3C 3.2.2.5.2).
• def Parse.id.finishThe digits of a supplied ID must be the whole text, and not all zero.