dd-trace 5.103.0 → 5.104.0

package/vendor/dist/opentracing/reference.d.ts

@@ -1,33 +0,0 @@
-import Span from './span';
-import SpanContext from './span_context';
-/**
- * Reference pairs a reference type constant (e.g., REFERENCE_CHILD_OF or
- * REFERENCE_FOLLOWS_FROM) with the SpanContext it points to.
- *
- * See the exported childOf() and followsFrom() functions at the package level.
- */
-export default class Reference {
-    protected _type: string;
-    protected _referencedContext: SpanContext;
-    /**
-     * @return {string} The Reference type (e.g., REFERENCE_CHILD_OF or
-     *         REFERENCE_FOLLOWS_FROM).
-     */
-    type(): string;
-    /**
-     * @return {SpanContext} The SpanContext being referred to (e.g., the
-     *         parent in a REFERENCE_CHILD_OF Reference).
-     */
-    referencedContext(): SpanContext;
-    /**
-     * Initialize a new Reference instance.
-     *
-     * @param {string} type - the Reference type constant (e.g.,
-     *        REFERENCE_CHILD_OF or REFERENCE_FOLLOWS_FROM).
-     * @param {SpanContext} referencedContext - the SpanContext being referred
-     *        to. As a convenience, a Span instance may be passed in instead
-     *        (in which case its .context() is used here).
-     */
-    constructor(type: string, referencedContext: SpanContext | Span);
-}
-//# sourceMappingURL=reference.d.ts.map

package/vendor/dist/opentracing/span.d.ts

@@ -1,147 +0,0 @@
-import SpanContext from './span_context';
-import Tracer from './tracer';
-/**
- * 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.
- */
-export declare class Span {
-    /**
-     * Returns the SpanContext object associated with this Span.
-     *
-     * @return {SpanContext}
-     */
-    context(): SpanContext;
-    /**
-     * Returns the Tracer object used to create this Span.
-     *
-     * @return {Tracer}
-     */
-    tracer(): Tracer;
-    /**
-     * Sets the string name for the logical operation this span represents.
-     *
-     * @param {string} name
-     */
-    setOperationName(name: string): this;
-    /**
-     * 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.
-     *
-     * @param {string} key
-     * @param {string} value
-     */
-    setBaggageItem(key: string, value: string): this;
-    /**
-     * Returns the value for a baggage item given its key.
-     *
-     * @param  {string} key
-     *         The key for the given trace attribute.
-     * @return {string}
-     *         String value for the given key, or undefined if the key does not
-     *         correspond to a set trace attribute.
-     */
-    getBaggageItem(key: string): string | undefined;
-    /**
-     * Adds a single tag to the span.  See `addTags()` for details.
-     *
-     * @param {string} key
-     * @param {any} value
-     */
-    setTag(key: string, value: any): this;
-    /**
-     * 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).
-     *
-     * @return {[type]} [description]
-     */
-    addTags(keyValueMap: {
-        [key: string]: any;
-    }): this;
-    /**
-     * 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());
-     *
-     * @param {object} keyValuePairs
-     *        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.
-     * @param {number} timestamp
-     *        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.
-     */
-    log(keyValuePairs: {
-        [key: string]: any;
-    }, timestamp?: number): this;
-    /**
-     * DEPRECATED
-     */
-    logEvent(eventName: string, payload: any): void;
-    /**
-     * 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.
-     *
-     * @param  {number} finishTime
-     *         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.
-     */
-    finish(finishTime?: number): void;
-    protected _context(): SpanContext;
-    protected _tracer(): Tracer;
-    protected _setOperationName(name: string): void;
-    protected _setBaggageItem(key: string, value: string): void;
-    protected _getBaggageItem(key: string): string | undefined;
-    protected _addTags(keyValuePairs: {
-        [key: string]: any;
-    }): void;
-    protected _log(keyValuePairs: {
-        [key: string]: any;
-    }, timestamp?: number): void;
-    protected _finish(finishTime?: number): void;
-}
-export default Span;
-//# sourceMappingURL=span.d.ts.map

package/vendor/dist/opentracing/span_context.d.ts

@@ -1,26 +0,0 @@
-/**
- * SpanContext represents Span state that must propagate to descendant Spans
- * and across process boundaries.
- *
- * SpanContext is logically divided into two pieces: the user-level "Baggage"
- * (see setBaggageItem and getBaggageItem) that propagates across Span
- * boundaries and any Tracer-implementation-specific fields that are needed to
- * identify or otherwise contextualize the associated Span instance (e.g., a
- * <trace_id, span_id, sampled> tuple).
- */
-export declare class SpanContext {
-    /**
-     * Returns a string representation of the implementation internal trace ID.
-     *
-     * @returns {string}
-     */
-    toTraceId(): string;
-    /**
-     * Returns a string representation of the implementation internal span ID.
-     *
-     * @returns {string}
-     */
-    toSpanId(): string;
-}
-export default SpanContext;
-//# sourceMappingURL=span_context.d.ts.map

package/vendor/dist/opentracing/test/api_compatibility.d.ts

@@ -1,16 +0,0 @@
-import { Tracer } from '../index';
-export interface ApiCompatibilityChecksOptions {
-    /** a boolean that controls whether or not to verify certain API functionality */
-    skipBaggageChecks?: boolean;
-    skipInjectExtractChecks?: boolean;
-}
-/**
- * A function that takes a tracer factory, and tests wheter the initialized tracer
- * fulfills Opentracing's api requirements.
- *
- * @param {object} createTracer - a factory function that allocates a tracer.
- * @param {object} [options] - the options to be set on api compatibility
- */
-declare function apiCompatibilityChecks(createTracer?: () => Tracer, options?: ApiCompatibilityChecksOptions): void;
-export default apiCompatibilityChecks;
-//# sourceMappingURL=api_compatibility.d.ts.map

package/vendor/dist/opentracing/test/mocktracer_implemenation.d.ts

@@ -1,3 +0,0 @@
-declare function mockTracerimplementationTests(): void;
-export default mockTracerimplementationTests;
-//# sourceMappingURL=mocktracer_implemenation.d.ts.map

package/vendor/dist/opentracing/test/noop_implementation.d.ts

@@ -1,4 +0,0 @@
-import { Tracer } from '../index';
-export declare function noopImplementationTests(createTracer?: () => Tracer): void;
-export default noopImplementationTests;
-//# sourceMappingURL=noop_implementation.d.ts.map

package/vendor/dist/opentracing/test/opentracing_api.d.ts

@@ -1,3 +0,0 @@
-export declare function opentracingAPITests(): void;
-export default opentracingAPITests;
-//# sourceMappingURL=opentracing_api.d.ts.map

package/vendor/dist/opentracing/test/unittest.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=unittest.d.ts.map

package/vendor/dist/opentracing/tracer.d.ts

@@ -1,127 +0,0 @@
-import Reference from './reference';
-import Span from './span';
-import SpanContext from './span_context';
-export interface SpanOptions {
-    /**
-     * a parent SpanContext (or Span, for convenience) that the newly-started
-     * span will be the child of (per REFERENCE_CHILD_OF). If specified,
-     * `references` must be unspecified.
-     */
-    childOf?: Span | SpanContext;
-    /**
-     * an array of Reference instances, each pointing to a causal parent
-     * SpanContext. If specified, `fields.childOf` must be unspecified.
-     */
-    references?: Reference[];
-    /**
-     * set of key-value pairs which will be set as tags on the newly created
-     * Span. Ownership of the object is passed to the created span for
-     * efficiency reasons (the caller should not modify this object after
-     * calling startSpan).
-     */
-    tags?: {
-        [key: string]: any;
-    };
-    /**
-     * a manually specified start time for the created Span object. The time
-     * should be specified in milliseconds as Unix timestamp. Decimal value are
-     * supported to represent time values with sub-millisecond accuracy.
-     */
-    startTime?: number;
-}
-/**
- * Tracer is the entry-point between the instrumentation API and the tracing
- * implementation.
- *
- * The default object acts as a no-op implementation.
- *
- * Note to implementators: derived classes can choose to directly implement the
- * methods in the "OpenTracing API methods" section, or optionally the subset of
- * underscore-prefixed methods to pick up the argument checking and handling
- * automatically from the base class.
- */
-export declare class Tracer {
-    /**
-     * Starts and returns a new Span representing a logical unit of work.
-     *
-     * For example:
-     *
-     *     // Start a new (parentless) root Span:
-     *     var parent = Tracer.startSpan('DoWork');
-     *
-     *     // Start a new (child) Span:
-     *     var child = Tracer.startSpan('load-from-db', {
-     *         childOf: parent.context(),
-     *     });
-     *
-     *     // Start a new async (FollowsFrom) Span:
-     *     var child = Tracer.startSpan('async-cache-write', {
-     *         references: [
-     *             opentracing.followsFrom(parent.context())
-     *         ],
-     *     });
-     *
-     * @param {string} name - the name of the operation (REQUIRED).
-     * @param {SpanOptions} [options] - options for the newly created span.
-     * @return {Span} - a new Span object.
-     */
-    startSpan(name: string, options?: SpanOptions): Span;
-    /**
-     * Injects the given SpanContext instance for cross-process propagation
-     * within `carrier`. The expected type of `carrier` depends on the value of
-     * `format.
-     *
-     * OpenTracing defines a common set of `format` values (see
-     * FORMAT_TEXT_MAP, FORMAT_HTTP_HEADERS, and FORMAT_BINARY), and each has
-     * an expected carrier type.
-     *
-     * Consider this pseudocode example:
-     *
-     *     var clientSpan = ...;
-     *     ...
-     *     // Inject clientSpan into a text carrier.
-     *     var headersCarrier = {};
-     *     Tracer.inject(clientSpan.context(), Tracer.FORMAT_HTTP_HEADERS, headersCarrier);
-     *     // Incorporate the textCarrier into the outbound HTTP request header
-     *     // map.
-     *     Object.assign(outboundHTTPReq.headers, headersCarrier);
-     *     // ... send the httpReq
-     *
-     * @param  {SpanContext} spanContext - the SpanContext to inject into the
-     *         carrier object. As a convenience, a Span instance may be passed
-     *         in instead (in which case its .context() is used for the
-     *         inject()).
-     * @param  {string} format - the format of the carrier.
-     * @param  {any} carrier - see the documentation for the chosen `format`
-     *         for a description of the carrier object.
-     */
-    inject(spanContext: SpanContext | Span, format: string, carrier: any): void;
-    /**
-     * Returns a SpanContext instance extracted from `carrier` in the given
-     * `format`.
-     *
-     * OpenTracing defines a common set of `format` values (see
-     * FORMAT_TEXT_MAP, FORMAT_HTTP_HEADERS, and FORMAT_BINARY), and each has
-     * an expected carrier type.
-     *
-     * Consider this pseudocode example:
-     *
-     *     // Use the inbound HTTP request's headers as a text map carrier.
-     *     var headersCarrier = inboundHTTPReq.headers;
-     *     var wireCtx = Tracer.extract(Tracer.FORMAT_HTTP_HEADERS, headersCarrier);
-     *     var serverSpan = Tracer.startSpan('...', { childOf : wireCtx });
-     *
-     * @param  {string} format - the format of the carrier.
-     * @param  {any} carrier - the type of the carrier object is determined by
-     *         the format.
-     * @return {SpanContext}
-     *         The extracted SpanContext, or null if no such SpanContext could
-     *         be found in `carrier`
-     */
-    extract(format: string, carrier: any): SpanContext | null;
-    protected _startSpan(name: string, fields: SpanOptions): Span;
-    protected _inject(spanContext: SpanContext, format: string, carrier: any): void;
-    protected _extract(format: string, carrier: any): SpanContext | null;
-}
-export default Tracer;
-//# sourceMappingURL=tracer.d.ts.map