dd-trace
    Preparing search index...

    Interface Span

    Span represents a logical unit of work as part of a broader Trace. Examples of span might include remote procedure calls or a in-process function calls to sub-components. A Trace has a single, top-level "root" Span that in turn may have zero or more child Spans, which in turn may have children.

    interface Span {
        addLink(context: SpanContext, attributes?: Object): void;
        addLink(link: { attributes?: Object; context: SpanContext }): void;
        addLinks(links: { attributes?: Object; context: SpanContext }[]): void;
        addTags(keyValueMap: { [key: string]: any }): this;
        context(): SpanContext;
        finish(finishTime?: number): void;
        getBaggageItem(key: string): undefined | string;
        log(keyValuePairs: { [key: string]: any }, timestamp?: number): this;
        logEvent(eventName: string, payload: any): void;
        setBaggageItem(key: string, value: string): this;
        setOperationName(name: string): this;
        setTag(key: string, value: any): this;
        tracer(): Tracer;
    }

    Hierarchy

    • Span
      • Span
    Index

    Methods

    addLink addLinks addTags context finish getBaggageItem log logEvent setBaggageItem setOperationName setTag tracer

    Methods

    • Causally links another span to the current span

      Parameters

      • context: SpanContext

        The context of the span to link to.

      • Optionalattributes: Object

        An optional key value pair of arbitrary values.

      Returns void

      In favor of addLink(link: { context: SpanContext, attributes?: Object }). This will be removed in the next major version.

    • Adds a single link to the span.

      Links added after the creation will not affect the sampling decision. It is preferred span links be added at span creation.

      Parameters

      • link: { attributes?: Object; context: SpanContext }

        the link to add.

      Returns void

    • Adds multiple links to the span.

      Links added after the creation will not affect the sampling decision. It is preferred span links be added at span creation.

      Parameters

      • links: { attributes?: Object; context: SpanContext }[]

        the links to add.

      Returns void

    • Adds the given key value pairs to the set of span tags.

      Multiple calls to addTags() results in the tags being the superset of all calls.

      The behavior of setting the same key multiple times on the same span is undefined.

      The supported type of the values is implementation-dependent. Implementations are expected to safely handle all types of values but may choose to ignore unrecognized / unhandle-able values (e.g. objects with cyclic references, function objects).

      Parameters

      • keyValueMap: { [key: string]: any }

      Returns this

      [description]

    • Sets the end timestamp and finalizes Span state.

      With the exception of calls to Span.context() (which are always allowed), finish() must be the last call made to any span instance, and to do otherwise leads to undefined behavior.

      Parameters

      • OptionalfinishTime: number

        Optional finish time in milliseconds as a Unix timestamp. Decimal values are supported for timestamps with sub-millisecond accuracy. If not specified, the current time (as defined by the implementation) will be used.

      Returns void

    • Returns the value for a baggage item given its key.

      Parameters

      • key: string

        The key for the given trace attribute.

      Returns undefined | string

      String value for the given key, or undefined if the key does not correspond to a set trace attribute.

    • Add a log record to this Span, optionally at a user-provided timestamp.

      For example:

      span.log({
    size: rpc.size(),  // numeric value
    URI: rpc.URI(),  // string value
    payload: rpc.payload(),  // Object value
    "keys can be arbitrary strings": rpc.foo(),
});

span.log({
    "error.description": someError.description(),
}, someError.timestampMillis());

      Parameters

      • keyValuePairs: { [key: string]: any }

        An object mapping string keys to arbitrary value types. All Tracer implementations should support bool, string, and numeric value types, and some may also support Object values.

      • Optionaltimestamp: number

        An optional parameter specifying the timestamp in milliseconds since the Unix epoch. Fractional values are allowed so that timestamps with sub-millisecond accuracy can be represented. If not specified, the implementation is expected to use its notion of the current time of the call.

      Returns this

    • DEPRECATED

      Parameters

      • eventName: string
      • payload: any

      Returns void

    • Sets a key:value pair on this Span that also propagates to future children of the associated Span.

      setBaggageItem() enables powerful functionality given a full-stack opentracing integration (e.g., arbitrary application data from a web client can make it, transparently, all the way into the depths of a storage system), and with it some powerful costs: use this feature with care.

      IMPORTANT NOTE #1: setBaggageItem() will only propagate baggage items to future causal descendants of the associated Span.

      IMPORTANT NOTE #2: Use this thoughtfully and with care. Every key and value is copied into every local and remote child of the associated Span, and that can add up to a lot of network and cpu overhead.

      Parameters

      • key: string
      • value: string

      Returns this

    • Sets the string name for the logical operation this span represents.

      Parameters

      • name: string

      Returns this

    • Adds a single tag to the span. See addTags() for details.

      Parameters

      • key: string
      • value: any

      Returns this

    Settings

    Member Visibility

    On This Page

    Methods