bend-trace-context

Releases (4)

• 0.2.0.0 indexed
• 0.1.2.0 unindexed
• 0.1.1.0 unindexed
• 0.1.0.0 unindexed

Definitions (472)

trace_context.bend

• def Extraction.showBoth outcomes of an extraction, for a log line: "TraceParentAccepted, StateDiscarded InvalidEntry 1 MissingEquals" for example.
• type InjectionThe carrier an injection writes, and the keys of the entries that truncation to the output budget dropped from the state, in their original order: diagnostics, kept apart from the carrier.
• def Carrier.is_contextWhether a field name is traceparent or tracestate, without regard to ASCII case.
• def Carrier.keep_unrelated`header` before `kept` unless it is a context field (`context_field`): one step of Carrier.unrelated.go.
• def Carrier.unrelated.goThe unrelated fields, those that are not context fields, most recent first, before `kept`.
• def Carrier.replaceThe carrier's unrelated fields, followed by `fields`: reversing the loop's result onto `fields`, also a loop, puts them back in order.
• def Context.field_namesThe names of the context fields as injection writes them: traceparent, then tracestate, in lowercase (W3C 3.2.1 and 3.3.1), the names that extraction and cleanup read too.
• def Carrier.context_fieldsThe context fields of a traceparent value and a tracestate value, with lowercase names; the tracestate field is left out when its value is empty.
• def Context.clearRemove every traceparent and tracestate field, whatever the case of its name, and keep the other fields in their order: the carrier of a message sent without context (spec #1, "Provide explicit context-field cleanup for the no-context path").
• def Injection.ofThe injection of an emission into a carrier.
• def Context.injectWrite an outgoing context into a carrier as a participant: the context fields of the carrier are replaced by the emitted traceparent, version 00 with only the sampled and random-trace-id flags, and the emitted tracestate, truncated to the output budget of `limits` and left out when empty.
• def Injection.carrierThe carrier to send.
• def Injection.droppedThe keys of the entries truncation dropped, in their original order; none when the state fitted.
• type ForwardErrorWhy a received context could not be forwarded unchanged: NothingToForward{} it keeps no received pair: its tracestate was discarded when it was extracted, or it was built from parts (IncomingContext.from_remote) ForwardTooLarge{} its tracestate fields, joined by commas, exceed the tracestate output budget InvalidForwardParent{error} its traceparent value is not one that TraceParent.read accepts InvalidForwardState{error} its tracestate fields are not ones that TraceState.parse_fields accepts A pair that extraction keeps always passes the last two checks (law forward_extracted); they refuse a pair built directly.
• def Text.joined.goThe fields joined by commas, most recent character first, after `done`: each field is reversed onto the comma before it.
• def Text.joinedThe fields joined by commas into one value, as String.join(fields, ",") writes it.
• def Forward.carrierThe carrier with its context fields replaced by a received pair: the traceparent value, and the tracestate fields joined into one value, left out when empty.
• def Forward.stateThe last check of a forwarded pair: its tracestate fields parse.
• def Forward.parentThe second check of a forwarded pair: its traceparent value reads back.
• def Forward.fitsThe first check of a forwarded pair: its tracestate fields, joined by commas, fit the output budget.
• def Forward.pairForward the received pair, if there is one.
• def Context.forwardForward a received context unchanged into a carrier: its context fields are replaced by the traceparent value of the received pair and by its tracestate fields joined into one field, and the other fields keep their order.
• def ForwardError.showThe name of a forwarding error; an invalid field adds its error.
• type ReceptionHow a service takes the context that extraction keeps, the message's or the base: Continue{} continue it with a child Restart{} replace it with a new trace, as at a trust boundary: its trace ID is not reused, its state is discarded and the root defaults apply
• type FailurePolicyWhat the operations do when generating an identifier fails: Lenient{} carry on without a new operation; the result says why Strict{} fail with the GenerationError, so that the caller can refuse the operation
• type OriginHow a service's operation came about: Continued{} a child of the context that extraction kept Started{} a root: extraction kept no context Restarted{} a new trace in place of the kept context (Restart{})
• type ServiceThe service's own operation for a received message, with the state it sends, or the error that left it without one.
• def FailurePolicy.resultThe type an operation returns under `policy`: the value itself with Lenient{}, and the value or the GenerationError with Strict{}.
• def Policy.applyA value under `policy`: itself with Lenient{}, and what `strict` makes of it with Strict{}.
• def Policy.apply.doneThe source's final state with a value under `policy`.
• def Serve.new_trace_sampledThe sampled indication of the new trace, a root or a restart, that Context.continue_or_start_with starts: the one that `sampling` resolves from the default, not sampled (spec #1, "New roots default to sampled `0`").
• def Serve.from_childThe service that a child of the kept context gives, with `state`, or Untraced with the error.
• def Serve.from_startThe service that a new trace gives: its generated operation, whose sampled indication Serve.new_trace_sampled gave its generation, and no state, or Untraced with the error.
• type ServicePlanThe service's operation as Context.continue_or_start_with decides it for a received message, before it reads any word: the generation to drive and what the generation's result makes of the service.
• def Serve.replacedThe context that a restart replaces, as Generation.restart takes it: an incoming base's received context, or an outgoing base's operation as another participant receives it.
• def Serve.usableContinue the kept context with a child, with its parent and state, or replace it with a new trace, as `reception` says.
• def Serve.keptTake the context that extraction keeps, or start a root without one.
• def ServicePlan.newThe plan of the service's operation for a message (see ServicePlan).
• def ServicePlan.generationThe generation that the plan drives.
• def ServicePlan.serviceThe service that the result of the plan's generation gives, before the policy applies: its operation, or Untraced with the error.
• def Serve.finishThe source's final state with the service that the plan gives.
• def Serve.runDrive the plan's generation from a caller's source.
• def Serve.operationThe service for a message, before the policy applies.
• def Serve.strictA service without an operation as the GenerationError that caused it.
• def Context.continue_or_start_withGive a service its own operation for a received message, from a caller's source (see the section's introduction).
• type UnforwardedWhy a message without a new operation does not forward a received pair: NothingKept{} the service keeps no received context: its operation is, or was to be, a root, a restart or a child of a base ForwardFailed{error} Context.forward refused the received context with `error`
• type SentThe context fields of one message and how they came about: Fresh{operation, injection} a new operation, injected with the service's state Forwarded{carrier, error} no operation could be generated (`error`); the received pair is forwarded unchanged NoContext{carrier, error, no operation could be generated, and no reason} pair was forwarded (`reason`): the context fields are cleared
• def Send.forwardedThe fallback when a forwarding of the received pair was tried.
• def Send.fallbackThe fields a message carries when no operation could be generated: the received pair forwarded unchanged if it can be, and no context fields otherwise.
• def Send.ofThe message that a generated child gives: the child injected with the service's state, or the fallback.
• type SendPlanA message's operation as Context.send_with decides it before it reads any word, with the limits and the carrier to send it with: SendChild{generation, limits, outgoing, received, carrier} a child of the service's operation, injected with the service's state SendFallback{error, limits, received, carrier} no operation, for a service without one: the fallback, reading no word A host that feeds a generation one word at a time drives SendPlan.generation and hands the result to SendPlan.sent (law hosted_send).
• def SendPlan.newThe plan of one message that the service sends (see SendPlan).
• def SendPlan.generationThe generation that the plan drives.
• def SendPlan.sentThe message that the result of the plan's generation gives, before the policy applies.
• def Send.finishThe source's final state with the message that the plan gives.
• def Send.runDrive the plan's generation from a caller's source.
• def Send.strictA message without a new operation as the GenerationError that caused it.
• def Context.send_withGive one message that the service sends the context of a new operation, from a caller's source (see the section's introduction).
• def Origin.showThe name of an origin.
• def Service.originHow the service's operation came about; None{} without an operation.
• def Service.outgoingThe service's operation with the state it sends; None{} without one.
• def Service.errorWhy the service has no operation; None{} with one.
• def Service.setAdd or update an entry of the state that the service's operation sends, such as this participant's own (see OutgoingContext.set).
• def Service.removeDelete an entry of the state that the service's operation sends (see OutgoingContext.remove).
• def Service.showThe name of a service's origin, or Untraced with its error.
• def Unforwarded.showWhy no pair was forwarded: NothingKept, or the ForwardError's name.
• def Sent.carrierThe fields to send with the message, in every case.
• def Sent.operationThe new operation that the message carries; None{} for a fallback.
• def Sent.errorWhy no operation could be generated; None{} for a new operation.
• def Sent.droppedThe keys that truncating the service's state to the output budget dropped from a new operation's message (see Injection.dropped); none for a fallback, which sends no state of its own.
• def Send.freshThe name of a new operation's message, saying whether its state was truncated.
• def Sent.showThe name of a message's context: Fresh, saying whether its state was truncated, or for a fallback why no operation was generated and, without a forwarded pair, why none was forwarded.