@opentelemetry/api

method active

active: () => Context;

• Get the currently active context

method bind

bind: <T>(context: Context, target: T) => T;

• Bind a context to a target function or event emitter

  Parameter context

  context to bind to the event emitter or function. Defaults to the currently active context

  Parameter target

  function or event emitter to bind

method disable

disable: () => void;

• Disable and remove the global context manager

method getInstance

static getInstance: () => ContextAPI;

• Get the singleton instance of the Context API

method setGlobalContextManager

setGlobalContextManager: (contextManager: ContextManager) => boolean;

• Set the current context manager.

  Returns

  true if the context manager was successfully registered, else false

method with

with: <A extends unknown[], F extends (...args: A) => ReturnType<F>>(
    context: Context,
    fn: F,
    thisArg?: ThisParameterType<F>,
    ...args: A
) => ReturnType<F>;

• Execute a function with an active context

  Parameter context

  context to be active during function execution

  Parameter fn

  function to execute in a context

  Parameter thisArg

  optional receiver to be used for calling fn

  Parameter args

  optional arguments forwarded to fn

property createComponentLogger

createComponentLogger: (options: ComponentLoggerOptions) => DiagLogger;

property debug

debug: DiagLogFunction;

property disable

disable: () => void;

• Unregister the global logger and return to Noop

property error

error: DiagLogFunction;

property info

info: DiagLogFunction;

property setLogger

setLogger: {
    (logger: DiagLogger, options?: DiagLoggerOptions): boolean;
    (logger: DiagLogger, logLevel?: DiagLogLevel): boolean;
};

property verbose

verbose: DiagLogFunction;

property warn

warn: DiagLogFunction;

method instance

static instance: () => DiagAPI;

• Get the singleton instance of the DiagAPI API

constructor

constructor();

property debug

debug: DiagLogFunction;

• Log a general debug message that can be useful for identifying a failure. Information logged at this level may include diagnostic details that would help identify a failure scenario. Useful scenarios would be to log the execution order of async operations

property error

error: DiagLogFunction;

• Log an error scenario that was not expected and caused the requested operation to fail.

property info

info: DiagLogFunction;

• Log a general informational message, this should not affect functionality. This is also the default logging level so this should NOT be used for logging debugging level information.

property verbose

verbose: DiagLogFunction;

• Log a detailed (verbose) trace level logging that can be used to identify failures where debug level logging would be insufficient, this level of tracing can include input and output parameters and as such may include PII information passing through the API. As such it is recommended that this level of tracing should not be enabled in a production environment.

property warn

warn: DiagLogFunction;

• Log a warning scenario to inform the developer of an issues that should be investigated. The requested operation may or may not have succeeded or completed.

method disable

disable: () => void;

• Remove the global meter provider

method getInstance

static getInstance: () => MetricsAPI;

• Get the singleton instance of the Metrics API

method getMeter

getMeter: (name: string, version?: string, options?: MeterOptions) => Meter;

• Returns a meter from the global meter provider.

method getMeterProvider

getMeterProvider: () => MeterProvider;

• Returns the global meter provider.

method setGlobalMeterProvider

setGlobalMeterProvider: (provider: MeterProvider) => boolean;

• Set the current global meter provider. Returns true if the meter provider was successfully registered, else false.

property createBaggage

createBaggage: (entries?: Record<string, BaggageEntry>) => Baggage;

property deleteBaggage

deleteBaggage: (context: Context) => Context;

property getActiveBaggage

getActiveBaggage: () => Baggage;

property getBaggage

getBaggage: (context: Context) => Baggage;

property setBaggage

setBaggage: (context: Context, baggage: Baggage) => Context;

method disable

disable: () => void;

• Remove the global propagator

method extract

extract: <Carrier>(
    context: Context,
    carrier: Carrier,
    getter?: TextMapGetter<Carrier>
) => Context;

• Extract context from a carrier

  Parameter context

  Context which the newly created context will inherit from

  Parameter carrier

  Carrier to extract context from

  Parameter getter

  Function used to extract keys from a carrier

method fields

fields: () => string[];

• Return a list of all fields which may be used by the propagator.

method getInstance

static getInstance: () => PropagationAPI;

• Get the singleton instance of the Propagator API

method inject

inject: <Carrier>(
    context: Context,
    carrier: Carrier,
    setter?: TextMapSetter<Carrier>
) => void;

• Inject context into a carrier to be propagated inter-process

  Parameter context

  Context carrying tracing data to inject

  Parameter carrier

  carrier to inject context into

  Parameter setter

  Function used to set values on the carrier

method setGlobalPropagator

setGlobalPropagator: (propagator: TextMapPropagator) => boolean;

• Set the current propagator.

  Returns

  true if the propagator was successfully registered, else false

constructor

constructor(
    _provider: TracerDelegator,
    name: string,
    version?: string,
    options?: TracerOptions
);

property name

readonly name: string;

property options

readonly options?: TracerOptions;

property version

readonly version?: string;

method startActiveSpan

startActiveSpan: <F extends (span: Span) => unknown>(
    _name: string,
    _options: F | SpanOptions,
    _context?: F | Context,
    _fn?: F
) => ReturnType<F>;

method startSpan

startSpan: (name: string, options?: SpanOptions, context?: Context) => Span;

method getDelegate

getDelegate: () => TracerProvider;

method getDelegateTracer

getDelegateTracer: (
    name: string,
    version?: string,
    options?: TracerOptions
) => Tracer | undefined;

method getTracer

getTracer: (name: string, version?: string, options?: TracerOptions) => Tracer;

• Get a ProxyTracer

method setDelegate

setDelegate: (delegate: TracerProvider) => void;

• Set the delegate tracer provider

property deleteSpan

deleteSpan: (context: Context) => Context;

property getActiveSpan

getActiveSpan: () => Span;

property getSpan

getSpan: (context: Context) => Span;

property getSpanContext

getSpanContext: (context: Context) => SpanContext;

property isSpanContextValid

isSpanContextValid: (spanContext: SpanContext) => boolean;

property setSpan

setSpan: (context: Context, span: Span) => Context;

property setSpanContext

setSpanContext: (context: Context, spanContext: SpanContext) => Context;

property wrapSpanContext

wrapSpanContext: (spanContext: SpanContext) => Span;

method disable

disable: () => void;

• Remove the global tracer provider

method getInstance

static getInstance: () => TraceAPI;

• Get the singleton instance of the Trace API

method getTracer

getTracer: (name: string, version?: string) => Tracer;

• Returns a tracer from the global tracer provider.

method getTracerProvider

getTracerProvider: () => TracerProvider;

• Returns the global tracer provider.

method setGlobalTracerProvider

setGlobalTracerProvider: (provider: TracerProvider) => boolean;

• Set the current global tracer.

  Returns

  true if the tracer provider was successfully registered, else false

index signature

[attributeKey: string]: AttributeValue | undefined;

method clear

clear: () => Baggage;

• Returns a new baggage with no entries

method getAllEntries

getAllEntries: () => [string, BaggageEntry][];

• Get a list of all entries in the Baggage

method getEntry

getEntry: (key: string) => BaggageEntry | undefined;

• Get an entry from Baggage if it exists

  Parameter key

  The key which identifies the BaggageEntry

method removeEntries

removeEntries: (...key: string[]) => Baggage;

• Returns a new baggage with the entries from the current bag except the removed entries

  Parameter key

  keys identifying the entries to be removed

method removeEntry

removeEntry: (key: string) => Baggage;

• Returns a new baggage with the entries from the current bag except the removed entry

  Parameter key

  key identifying the entry to be removed

method setEntry

setEntry: (key: string, entry: BaggageEntry) => Baggage;

• Returns a new baggage with the entries from the current bag and the specified entry

  Parameter key

  string which identifies the baggage entry

  Parameter entry

  BaggageEntry for the given key

property metadata

metadata?: BaggageEntryMetadata;

• Metadata is an optional string property defined by the W3C baggage specification. It currently has no special meaning defined by the specification.

property value

value: string;

• String value of the BaggageEntry.

method observe

observe: (
    this: BatchObservableResult<AttributesTypes>,
    metric: Observable<AttributesTypes>,
    value: number,
    attributes?: AttributesTypes
) => void;

• Observe a measurement of the value associated with the given attributes.

  Parameter metric

  The observable metric to be observed.

  Parameter value

  The value to be observed.

  Parameter attributes

  The attributes associated with the value. If more than one values associated with the same attributes values, SDK may pick the last one or simply drop the entire observable result.

property namespace

namespace: string;

method deleteValue

deleteValue: (key: symbol) => Context;

• Return a new context which inherits from this context but does not contain a value for the given key.

  Parameter key

  context key for which to clear a value

method getValue

getValue: (key: symbol) => unknown;

• Get a value from the context.

  Parameter key

  key which identifies a context value

method setValue

setValue: (key: symbol, value: unknown) => Context;

• Create a new context which inherits from this context and has the given key set to the given value.

  Parameter key

  context key for which to set the value

  Parameter value

  value to set for the given key

method active

active: () => Context;

• Get the current active context

method bind

bind: <T>(context: Context, target: T) => T;

• Bind an object as the current context (or a specific one)

  Parameter context

  Optionally specify the context which you want to assign

  Parameter target

  Any object to which a context need to be set

method disable

disable: () => this;

• Disable context management

method enable

enable: () => this;

• Enable context management

method with

with: <A extends unknown[], F extends (...args: A) => ReturnType<F>>(
    context: Context,
    fn: F,
    thisArg?: ThisParameterType<F>,
    ...args: A
) => ReturnType<F>;

• Run the fn callback with object set as the current active context

  Parameter context

  Any object to set as the current active context

  Parameter fn

  A callback to be immediately run within a specific context

  Parameter thisArg

  optional receiver to be used for calling fn

  Parameter args

  optional arguments forwarded to fn

method add

add: (value: number, attributes?: AttributesTypes, context?: Context) => void;

• Increment value of counter by the input. Inputs must not be negative.

property debug

debug: DiagLogFunction;

• Log a general debug message that can be useful for identifying a failure. Information logged at this level may include diagnostic details that would help identify a failure scenario. For example: Logging the order of execution of async operations.

property error

error: DiagLogFunction;

• Log an error scenario that was not expected and caused the requested operation to fail.

property info

info: DiagLogFunction;

• Log a general informational message, this should not affect functionality. This is also the default logging level so this should NOT be used for logging debugging level information.

property verbose

verbose: DiagLogFunction;

• Log a detailed (verbose) trace level logging that can be used to identify failures where debug level logging would be insufficient, this level of tracing can include input and output parameters and as such may include PII information passing through the API. As such it is recommended that this level of tracing should not be enabled in a production environment.

property warn

warn: DiagLogFunction;

• Log a warning scenario to inform the developer of an issues that should be investigated. The requested operation may or may not have succeeded or completed.

property logLevel

logLevel?: DiagLogLevel;

• The DiagLogLevel used to filter logs sent to the logger.

property suppressOverrideMessage

suppressOverrideMessage?: boolean;

• Setting this value to true will suppress the warning message normally emitted when registering a logger when another logger is already registered.

method record

record: (value: number, attributes?: AttributesTypes, context?: Context) => void;

• Records a measurement. Value of the measurement must not be negative.

property attributes

attributes?: SpanAttributes;

• A set of SpanAttributes on the link.

property context

context: SpanContext;

• The SpanContext of a linked span.

property droppedAttributesCount

droppedAttributesCount?: number;

• Count of attributes of the link that were dropped due to collection limits

method addBatchObservableCallback

addBatchObservableCallback: <AttributesTypes extends Attributes = Attributes>(
    callback: BatchObservableCallback<AttributesTypes>,
    observables: Observable<AttributesTypes>[]
) => void;

• Sets up a function that will be called whenever a metric collection is initiated.

  If the function is already in the list of callbacks for this Observable, the function is not added a second time.

  Only the associated observables can be observed in the callback. Measurements of observables that are not associated observed in the callback are dropped.

  Parameter callback

  the batch observable callback

  Parameter observables

  the observables associated with this batch observable callback

method createCounter

createCounter: <AttributesTypes extends Attributes = Attributes>(
    name: string,
    options?: MetricOptions
) => Counter<AttributesTypes>;

• Creates a new Counter metric. Generally, this kind of metric when the value is a quantity, the sum is of primary interest, and the event count and value distribution are not of primary interest.

  Parameter name

  the name of the metric.

  Parameter options

  the metric options.

method createHistogram

createHistogram: <AttributesTypes extends Attributes = Attributes>(
    name: string,
    options?: MetricOptions
) => Histogram<AttributesTypes>;

• Creates and returns a new Histogram.

  Parameter name

  the name of the metric.

  Parameter options

  the metric options.

method createObservableCounter

createObservableCounter: <AttributesTypes extends Attributes = Attributes>(
    name: string,
    options?: MetricOptions
) => ObservableCounter<AttributesTypes>;

• Creates a new ObservableCounter metric.

  The callback SHOULD be safe to be invoked concurrently.

  Parameter name

  the name of the metric.

  Parameter options

  the metric options.

method createObservableGauge

createObservableGauge: <AttributesTypes extends Attributes = Attributes>(
    name: string,
    options?: MetricOptions
) => ObservableGauge<AttributesTypes>;

• Creates a new ObservableGauge metric.

  The callback SHOULD be safe to be invoked concurrently.

  Parameter name

  the name of the metric.

  Parameter options

  the metric options.

method createObservableUpDownCounter

createObservableUpDownCounter: <AttributesTypes extends Attributes = Attributes>(
    name: string,
    options?: MetricOptions
) => ObservableUpDownCounter<AttributesTypes>;

• Creates a new ObservableUpDownCounter metric.

  The callback SHOULD be safe to be invoked concurrently.

  Parameter name

  the name of the metric.

  Parameter options

  the metric options.

method createUpDownCounter

createUpDownCounter: <AttributesTypes extends Attributes = Attributes>(
    name: string,
    options?: MetricOptions
) => UpDownCounter<AttributesTypes>;

• Creates a new UpDownCounter metric. UpDownCounter is a synchronous instrument and very similar to Counter except that Add(increment) supports negative increments. It is generally useful for capturing changes in an amount of resources used, or any quantity that rises and falls during a request. Example uses for UpDownCounter: count the number of active requests. count memory in use by instrumenting new and delete. count queue size by instrumenting enqueue and dequeue. count semaphore up and down operations.

  Parameter name

  the name of the metric.

  Parameter options

  the metric options.

method removeBatchObservableCallback

removeBatchObservableCallback: <AttributesTypes extends Attributes = Attributes>(
    callback: BatchObservableCallback<AttributesTypes>,
    observables: Observable<AttributesTypes>[]
) => void;

• Removes a callback previously registered with Meter.addBatchObservableCallback.

  The callback to be removed is identified using a combination of the callback itself, and the set of the observables associated with it.

  Parameter callback

  the batch observable callback

  Parameter observables

  the observables associated with this batch observable callback

property schemaUrl

schemaUrl?: string;

• The schemaUrl of the meter or instrumentation library

method getMeter

getMeter: (name: string, version?: string, options?: MeterOptions) => Meter;

• Returns a Meter, creating one if one with the given name, version, and schemaUrl pair is not already created.

  Parameter name

  The name of the meter or instrumentation library.

  Parameter version

  The version of the meter or instrumentation library.

  Parameter options

  The options of the meter or instrumentation library.

  Returns

  Meter A Meter with the given name and version

property description

description?: string;

• The description of the Metric. ''

property unit

unit?: string;

• The unit of the Metric values. ''

property valueType

valueType?: ValueType;

• Indicates the type of the recorded value. ValueType.DOUBLE

method addCallback

addCallback: (callback: ObservableCallback<AttributesTypes>) => void;

• Sets up a function that will be called whenever a metric collection is initiated.

  If the function is already in the list of callbacks for this Observable, the function is not added a second time.

method removeCallback

removeCallback: (callback: ObservableCallback<AttributesTypes>) => void;

• Removes a callback previously registered with Observable.addCallback.

method observe

observe: (
    this: ObservableResult<AttributesTypes>,
    value: number,
    attributes?: AttributesTypes
) => void;

• Observe a measurement of the value associated with the given attributes.

  Parameter value

  The value to be observed.

  Parameter attributes

  The attributes associated with the value. If more than one values associated with the same attributes values, SDK may pick the last one or simply drop the entire observable result.

method shouldSample

shouldSample: (
    context: Context,
    traceId: string,
    spanName: string,
    spanKind: SpanKind,
    attributes: SpanAttributes,
    links: Link[]
) => SamplingResult;

• Checks whether span needs to be created and tracked.

  Parameter context

  Parent Context which may contain a span.

  Parameter traceId

  of the span to be created. It can be different from the traceId in the SpanContext. Typically in situations when the span to be created starts a new trace.

  Parameter spanName

  of the span to be created.

  Parameter spanKind

  of the span to be created.

  Parameter attributes

  Initial set of SpanAttributes for the Span being constructed.

  Parameter links

  Collection of links that will be associated with the Span to be created. Typically useful for batch operations.

  Returns

  a SamplingResult.

method toString

toString: () => string;

• Returns the sampler name or short description with the configuration.

property attributes

attributes?: Readonly<SpanAttributes>;

• The list of attributes returned by SamplingResult MUST be immutable. Caller may call Sampler.shouldSample any number of times and can safely cache the returned value.

property decision

decision: SamplingDecision;

• A sampling decision, refer to SamplingDecision for details.

property traceState

traceState?: TraceState;

• A TraceState that will be associated with the Span through the new SpanContext. Samplers SHOULD return the TraceState from the passed-in Context if they do not intend to change it. Leaving the value undefined will also leave the TraceState unchanged.

method addEvent

addEvent: (
    name: string,
    attributesOrStartTime?: SpanAttributes | TimeInput,
    startTime?: TimeInput
) => this;

• Adds an event to the Span.

  Parameter name

  the name of the event.

  Parameter attributesOrStartTime

  the attributes that will be added; these are associated with this event. Can be also a start time if type is and 3rd param is undefined

  Parameter startTime

  start time of the event.

method end

end: (endTime?: TimeInput) => void;

• Marks the end of Span execution.

  Call to End of a Span MUST not have any effects on child spans. Those may still be running and can be ended later.

  Do not return this. The Span generally should not be used after it is ended so chaining is not desired in this context.

  Parameter endTime

  the time to set as Span's end time. If not provided, use the current time as the span's end time.

method isRecording

isRecording: () => boolean;

• Returns the flag whether this span will be recorded.

  Returns

  true if this Span is active and recording information like events with the AddEvent operation and attributes using setAttributes.

method recordException

recordException: (exception: Exception, time?: TimeInput) => void;

• Sets exception as a span event

  Parameter exception

  the exception the only accepted values are string or Error

  Parameter time

  the time to set as Span's event time. If not provided, use the current time.

method setAttribute

setAttribute: (key: string, value: SpanAttributeValue) => this;

• Sets an attribute to the span.

  Sets a single Attribute with the key and value passed as arguments.

  Parameter key

  the key for this attribute.

  Parameter value

  the value for this attribute. Setting a value null or undefined is invalid and will result in undefined behavior.

method setAttributes

setAttributes: (attributes: SpanAttributes) => this;

• Sets attributes to the span.

  Parameter attributes

  the attributes that will be added. null or undefined attribute values are invalid and will result in undefined behavior.

method setStatus

setStatus: (status: SpanStatus) => this;

• Sets a status to the span. If used, this will override the default Span status. Default is SpanStatusCode.UNSET. SetStatus overrides the value of previous calls to SetStatus on the Span.

  Parameter status

  the SpanStatus to set.

method spanContext

spanContext: () => SpanContext;

• Returns the SpanContext object associated with this Span.

  Get an immutable, serializable identifier for this span that can be used to create new child spans. Returned SpanContext is usable even after the span ends.

  Returns

  the SpanContext object associated with this Span.

method updateName

updateName: (name: string) => this;

• Updates the Span name.

  This will override the name provided via Tracer.startSpan.

  Upon this update, any sampling behavior based on Span name will depend on the implementation.

  Parameter name

  the Span name.

property isRemote

isRemote?: boolean;

• Only true if the SpanContext was propagated from a remote parent.

property spanId

spanId: string;

• The ID of the Span. It is globally unique with practically sufficient probability by being made as 8 randomly generated bytes, encoded as a 16 lowercase hex characters corresponding to 64 bits.

property traceFlags

traceFlags: number;

• Trace flags to propagate.

  It is represented as 1 byte (bitmap). Bit to represent whether trace is sampled or not. When set, the least significant bit documents that the caller may have recorded trace data. A caller who does not record trace data out-of-band leaves this flag unset.

  see TraceFlags for valid flag values.

property traceId

traceId: string;

• The ID of the trace that this span belongs to. It is worldwide unique with practically sufficient probability by being made as 16 randomly generated bytes, encoded as a 32 lowercase hex characters corresponding to 128 bits.

property traceState

traceState?: TraceState;

• Tracing-system-specific info to propagate.

  The tracestate field value is a list as defined below. The list is a series of list-members separated by commas ,, and a list-member is a key/value pair separated by an equals sign =. Spaces and horizontal tabs surrounding list-members are ignored. There can be a maximum of 32 list-members in a list. More Info: https://www.w3.org/TR/trace-context/#tracestate-field

  Examples: Single tracing system (generic format): tracestate: rojo=00f067aa0ba902b7 Multiple tracing systems (with different formatting): tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE

property attributes

attributes?: SpanAttributes;

• A span's attributes

property kind

kind?: SpanKind;

• The SpanKind of a span SpanKind.INTERNAL

property links

links?: Link[];

• Links span to other spans

property root

root?: boolean;

• The new span should be a root span. (Ignore parent from context).

property startTime

startTime?: TimeInput;

• A manually specified start time for the created Span object.

property code

code: SpanStatusCode;

• The status code of this message.

property message

message?: string;

• A developer-facing error message.

method get

get: (carrier: Carrier, key: string) => undefined | string | string[];

• Get the value of a specific key from the carrier.

  Parameter carrier

  Parameter key

method keys

keys: (carrier: Carrier) => string[];

• Get a list of all keys available on the carrier.

  Parameter carrier

method extract

extract: (
    context: Context,
    carrier: Carrier,
    getter: TextMapGetter<Carrier>
) => Context;

• Given a Context and a carrier, extract context values from a carrier and return a new context, created from the old context, with the extracted values.

  Parameter context

  the Context from which to extract values to transmit over the wire.

  Parameter carrier

  the carrier of propagation fields, such as http request headers.

  Parameter getter

  an optional TextMapGetter. If undefined, keys will be all own properties, and keys will be accessed by direct object access.

method fields

fields: () => string[];

• Return a list of all fields which may be used by the propagator.

method inject

inject: (
    context: Context,
    carrier: Carrier,
    setter: TextMapSetter<Carrier>
) => void;

• Injects values from a given Context into a carrier.

  OpenTelemetry defines a common set of format values (TextMapPropagator), and each has an expected carrier type.

  Parameter context

  the Context from which to extract values to transmit over the wire.

  Parameter carrier

  the carrier of propagation fields, such as http request headers.

  Parameter setter

  an optional TextMapSetter. If undefined, values will be set by direct object assignment.

method set

set: (carrier: Carrier, key: string, value: string) => void;

• Callback used to set a key/value pair on an object.

  Should be called by the propagator each time a key/value pair should be set, and should set that key/value pair on the propagator.

  Parameter carrier

  object or class which carries key/value pairs

  Parameter key

  string key to modify

  Parameter value

  value to be set to the key on the carrier

method startActiveSpan

startActiveSpan: {
    <F extends (span: Span) => unknown>(name: string, fn: F): ReturnType<F>;
    <F extends (span: Span) => unknown>(
        name: string,
        options: SpanOptions,
        fn: F
    ): ReturnType<F>;
    <F extends (span: Span) => unknown>(
        name: string,
        options: SpanOptions,
        context: Context,
        fn: F
    ): ReturnType<F>;
};

• Starts a new Span and calls the given function passing it the created span as first argument. Additionally the new span gets set in context and this context is activated for the duration of the function call.

  Parameter name

  The name of the span

  Parameter options

  SpanOptions used for span creation

  Parameter context

  Context to use to extract parent

  Parameter fn

  function called in the context of the span and receives the newly created span as an argument

  Returns

  return value of fn

  Example 1

  const something = tracer.startActiveSpan('op', span => { try { do some work span.setStatus({code: SpanStatusCode.OK}); return something; } catch (err) { span.setStatus({ code: SpanStatusCode.ERROR, message: err.message, }); throw err; } finally { span.end(); } });

  Example 2

  const span = tracer.startActiveSpan('op', span => { try { do some work return span; } catch (err) { span.setStatus({ code: SpanStatusCode.ERROR, message: err.message, }); throw err; } }); do some more work span.end();

method startSpan

startSpan: (name: string, options?: SpanOptions, context?: Context) => Span;

• Starts a new Span. Start the span without setting it on context.

  This method do NOT modify the current Context.

  Parameter name

  The name of the span

  Parameter options

  SpanOptions used for span creation

  Parameter context

  Context to use to extract parent

  Returns

  Span The newly created span

  Example 1

  const span = tracer.startSpan('op'); span.setAttribute('key', 'value'); span.end();

method getDelegateTracer

getDelegateTracer: (
    name: string,
    version?: string,
    options?: TracerOptions
) => Tracer | undefined;

property schemaUrl

schemaUrl?: string;

• The schemaUrl of the tracer or instrumentation library

method getTracer

getTracer: (name: string, version?: string, options?: TracerOptions) => Tracer;

• Returns a Tracer, creating one if one with the given name and version is not already created.

  This function may return different Tracer types (e.g. NoopTracerProvider vs. a functional tracer).

  Parameter name

  The name of the tracer or instrumentation library.

  Parameter version

  The version of the tracer or instrumentation library.

  Parameter options

  The options of the tracer or instrumentation library.

  Returns

  Tracer A Tracer with the given name and version

method get

get: (key: string) => string | undefined;

• Returns the value to which the specified key is mapped, or undefined if this map contains no mapping for the key.

  Parameter key

  with which the specified value is to be associated.

  Returns

  the value to which the specified key is mapped, or undefined if this map contains no mapping for the key.

method serialize

serialize: () => string;

• Serializes the TraceState to a list as defined below. The list is a series of list-members separated by commas ,, and a list-member is a key/value pair separated by an equals sign =. Spaces and horizontal tabs surrounding list-members are ignored. There can be a maximum of 32 list-members in a list.

  Returns

  the serialized string.

method set

set: (key: string, value: string) => TraceState;

• Create a new TraceState which inherits from this TraceState and has the given key set. The new entry will always be added in the front of the list of states.

  Parameter key

  key of the TraceState entry.

  Parameter value

  value of the TraceState entry.

method unset

unset: (key: string) => TraceState;

• Return a new TraceState which inherits from this TraceState but does not contain the given key.

  Parameter key

  the key for the TraceState entry to be removed.

method add

add: (value: number, attributes?: AttributesTypes, context?: Context) => void;

• Increment value of counter by the input. Inputs may be negative.

member ALL

ALL = 9999

• Used to set the logging level to include all logging

member DEBUG

DEBUG = 70

• General debug log message

member ERROR

ERROR = 30

• Identifies an error scenario

member INFO

INFO = 60

• General informational log message

member NONE

NONE = 0

• Diagnostic Logging level setting to disable all logging (except and forced logs)

member VERBOSE

VERBOSE = 80

• Detailed trace level logging should only be used for development, should only be set in a development environment.

member WARN

WARN = 50

• Identifies a warning scenario