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 TracePlan.generationThe generation of the new trace of a plan: at most 48 words, eight trace ID candidates of four words and eight span ID candidates of two.
• def Generation.rootA root with the sampled indication `sampled`, as it is given (TracePlan.root).
• def Generation.restartA restart replacing `previous`, with the sampled indication `sampled`, as a root (TracePlan.restart).
• def Generation.childA child of `parent`: at most 16 words, eight span ID candidates.
• def Generation.needs.ofWhether a step needs another word within `fuel` more words.
• def Generation.needsWhether the generation needs another word: it has not ended, and its budget allows one more.
• def Generation.fedThe generation after `word`: the step it gives with one word less of budget, or, for a step that needs no word, the same step with none left.
• def Generation.feedFeed the generation the next word of its source (see Draw.feed).
• def Generation.resultThe generation's result: the context it created, or why it failed.
• def Generation.run_withDrive a generation from a caller's source, one word at a time (Draw.read), and hand back the source's final state with the result.
• def Draw.span_contextThe context of a span ID generated from a source for an operation of `trace_id` with the sampled indication `sampled`, with the source's final state: the span ID's failure is the context's.
• def SpanPlan.generate_withThe local context of a span plan, from a caller's source: a span ID that excludes the plan's (SpanId.generate_with), and the context of the plan's trace ID and sampled indication with it.
• def Draw.root_span_withThe span ID of a root or a restart with the sampled indication `sampled`, from the source's next state, once its trace ID is generated: the trace ID's failure is the generation's, and otherwise the local context of the root's span plan (SpanPlan.root).
• def TracePlan.generate_withThe local context of the new trace of a plan, from a caller's source: a trace ID that excludes the plan's (TraceId.generate_with), then, from the source's next state, the span ID of the root's span plan with the plan's sampled indication (Draw.root_span_with).
• def Context.root_withGenerated contexts from a caller's source.
• def Context.child_withA generated child of `parent` from a caller's source: the local context of its span plan (SpanPlan.child), a span ID that excludes the parent's, with the parent's trace ID and the sampled indication that `sampling` resolves.
• def Context.restart_withA generated restart replacing `previous` from a caller's source: a trace ID that excludes the received one, then a span ID, as for a root, with the sampled indication `sampled` (TracePlan.restart and TracePlan.generate_with).
• def Source.tapeA deterministic source that replays a tape of word results.
• def Error.showThe name of a codec or ID error, with its offset or, for an unsupported version, its two digits.
• def ContextError.showThe name of a context creation error.
• def GenerationError.showThe name of a generation error; a source failure adds the source's code and message.
• type LimitsErrorWhy a limit configuration was refused.
• def Limits.is_validThe rules of a configuration, which must accept its own emitted representation: a traceparent input budget of at least 55 octets, the length of a v00 value, and a tracestate input budget no smaller than an output budget of at least 512 octets (spec #1, "Tracestate policy and resource bounds"; the 512-octet minimum comes from #8; law limits_bounds).
• type LimitsBudgets in UTF-8 octets.
• def Limits.errorThe first rule a refused configuration breaks.
• def Limits.new.checkedThe configuration, when the check found it valid.
• def Limits.newValidate a configuration; budgets count UTF-8 octets (laws limits_new and limits_fields).
• def Limits.default32 KiB for each received value and 512 octets for an emitted tracestate (law default_limits).
• def Limits.traceparent_inputThe most octets a received traceparent value may take.
• def Limits.tracestate_inputThe most octets a combined tracestate value may take, including the commas that join repeated fields.
• def Limits.tracestate_outputThe most octets an emitted tracestate may take.
• def LimitsError.showThe name of a limits error.
• type EntryErrorWhy a tracestate key, value or received member was refused: MissingEquals{} a nonempty member has no "=" InvalidKey{} the text before the first "=" is not a key InvalidValue{} the text after it, without trailing optional whitespace, is not a value
• def StateChar.in_rangeWhether a code point lies between two others, both included.
• def StateChar.is_key_startlcalpha / DIGIT: a lowercase ASCII letter (%x61-7A) or a digit (%x30-39), the first character of a key.
• def StateChar.is_keykeychar: lcalpha / DIGIT / "_" / "-" / "*" / "/" / "@".
• def StateChar.is_value_endnblk-chr: %x21-2B / %x2D-3C / %x3E-7E, printable ASCII other than space, "," and "=".
• def StateChar.is_valuechr: %x20 / nblk-chr, a character of a value: nblk-chr or a space.
• def StateChar.is_owsOWS: a space or a horizontal tab (RFC 9110, section 5.6.3).
• def StateKey.valid.restEvery remaining character is a key character, and at most `room` remain.
• def StateKey.is_validkey = ( lcalpha / DIGIT ) 0*255( keychar ): 1 to 256 characters (W3C 3.3.2.2.1).
• def StateValue.valid.go`char` is a value character followed by `tail`, of which at most `room` characters are allowed; the last character is not a space.
• def StateValue.is_validvalue = 0*255( chr ) nblk-chr: 1 to 256 printable ASCII characters other than "," and "=", the last of which is not a space (W3C 3.3.2.2.2).
• type StateKeyA tracestate key, naming the vendor that owns an entry.
• type StateValueA tracestate value, opaque to every other vendor.
• def StateKey.parse.checkedThe key, when the check found the text valid.
• def StateKey.parseAccept exactly a Level 2 key, or fail with InvalidKey.
• def StateKey.to_stringThe key's text.
• def StateValue.parse.checkedThe value, when the check found the text valid.
• def StateValue.parseAccept exactly a Level 2 value, leading spaces included, or fail with InvalidValue.
• def StateValue.to_stringThe value's text.
• def EntryError.showThe name of an entry error.
• type StateErrorWhy a received tracestate value was discarded: StateTooLarge{} the combined value exceeds its input budget TooManyMembers{} a 33rd nonempty member was reached InvalidEntry{member, error} a member is invalid; `member` numbers the comma-separated members of the combined value from zero, empty members included Discarding the state never invalidates a valid traceparent (spec #1).
• type StateEntryOne vendor's entry: a key and its value.
• def StateEntry.keyThe entry's key.
• def StateEntry.valueThe entry's value.
• def StateEntry.key_textThe text of the entry's key.
• def StateEntry.format`key=value`, as the entry is sent.
• def Entries.has_keyWhether one of the entries has this key.
• def Entries.uniqueNo entry repeats the key of an entry before it; `seen` holds the entries already passed.
• def TraceState.is_validDistinct keys and at most 32 entries (W3C 3.3.2 and 3.3.3).
• type TraceStateOrdered vendor state: at most 32 entries with distinct keys, leftmost first.
• def TraceState.emptyThe state with no entries.
• def TraceState.entriesThe entries in order, leftmost first.
• def TraceState.is_emptyWhether the state has no entries.
• def Entries.get.putThe value of `entry` when its key matched, or the result for the rest.
• def Entries.getThe value of the first entry with this key.
• def TraceState.getThe value of the entry with this key, if there is one (laws get_entry and get_absent).
• def Entries.format.restEach entry after the first, preceded by its comma.
• def Entries.formatThe entries as `key=value`, joined by commas.
• def TraceState.formatThe normalized value: the entries in order, joined by commas, with no optional whitespace.
• def Utf8.widthThe UTF-8 octets of a character.
• def Utf8.lengthThe UTF-8 octets of a text, in which the laws state every budget.
• def Budget.takeWhat is left of a budget after taking `need` octets, or None when less remains.
• def Utf8.leftWhat is left of a budget after a text, or None once the text exceeds it.
• def Utf8.left_moreFields after the first are measured with the comma that joins them.
• def Utf8.left_fieldsWhat is left of a budget after repeated fields and the commas that join them.
• type MemberWhere reading the current member stands: before its key, with only optional whitespace so far; inside its key; or inside its value.
• type ScanA tracestate being read: the members ended so far, empty ones included; how many more nonempty members are allowed; the current member; and the first entry of each key, in reading order.
• def Value.restore.stepA value's characters arrive most recent first.
• def Value.restore.goThe restoring loop: one character at a time, with the state (whether a character was kept yet, the value so far).
• def Value.restoreThe value in reading order without its trailing optional whitespace.
• def Member.startA character of a member that has no key yet: optional whitespace is skipped, an "=" gives the member an empty key, which validation refuses, and anything else starts the key.
• def Member.keyA character inside a key: the first "=" ends the key, anything else extends it.
• def Member.pushA character other than a comma extends the current member.
• def Scan.validateValidate the key and value texts of a member that ended.
• def Entries.add.ifKeep the entries unchanged when the key was present; otherwise add the entry at the end.
• def Entries.addKeep only the first entry of each key (spec #1, "Preserve the first occurrence of a duplicate key").
• def Scan.keepA valid member counts toward the 32 allowed before duplicates are dropped (spec #1); with no room left, the state is discarded with TooManyMembers.
• def Scan.entryA member that ended: an invalid one stops reading with its number and reason; a valid one is counted and kept.
• def Scan.closeThe current member ends at a comma or with the value.
• def Scan.readOne character of a scan that is still reading: a comma ends the member, and anything else extends it.
• def Scan.charRead one character, unless the scan has stopped.
• def Scan.textRead a text one character at a time, stopping at the first problem.
• def Scan.moreFields after the first are read after the comma that joins them.
• def Scan.fieldsRead repeated fields as their comma-joined combination.
• def Scan.startThe scan of a new value: no member ended, 32 allowed, nothing kept.
• def Scan.stateThe scan keeps only the first entry of each key and stops at a 33rd member, so this check is not expected to fail: the laws prove it passes for normalized values, and the corpus exercises the rest.
• def Scan.resultThe state read, once the last member has ended.
• def Scan.finishThe last member ends with the value.