@openclaw/diagnostics-otel 2026.7.2-beta.2 → 2026.7.2-beta.4

package/node_modules/@opentelemetry/sdk-trace/build/esnext/semconv.d.ts

@@ -0,0 +1,103 @@
+/**
+ * A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance.
+ *
+ * @example otlp_grpc_span_exporter/0
+ * @example custom-name
+ *
+ * @note Implementations **SHOULD** ensure a low cardinality for this attribute, even across application or SDK restarts.
+ * E.g. implementations **MUST NOT** use UUIDs as values for this attribute.
+ *
+ * Implementations **MAY** achieve these goals by following a `<otel.component.type>/<instance-counter>` pattern, e.g. `batching_span_processor/0`.
+ * Hereby `otel.component.type` refers to the corresponding attribute value of the component.
+ *
+ * The value of `instance-counter` **MAY** be automatically assigned by the component and uniqueness within the enclosing SDK instance **MUST** be guaranteed.
+ * For example, `<instance-counter>` **MAY** be implemented by using a monotonically increasing counter (starting with `0`), which is incremented every time an
+ * instance of the given component type is started.
+ *
+ * With this implementation, for example the first Batching Span Processor would have `batching_span_processor/0`
+ * as `otel.component.name`, the second one `batching_span_processor/1` and so on.
+ * These values will therefore be reused in the case of an application restart.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_OTEL_COMPONENT_NAME: "otel.component.name";
+/**
+ * A name identifying the type of the OpenTelemetry component.
+ *
+ * @example batching_span_processor
+ * @example com.example.MySpanExporter
+ *
+ * @note If none of the standardized values apply, implementations **SHOULD** use the language-defined name of the type.
+ * E.g. for Java the fully qualified classname **SHOULD** be used in this case.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_OTEL_COMPONENT_TYPE: "otel.component.type";
+/**
+ * Determines whether the span has a parent span, and if so, [whether it is a remote parent](https://opentelemetry.io/docs/specs/otel/trace/api/#isremote)
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_OTEL_SPAN_PARENT_ORIGIN: "otel.span.parent.origin";
+/**
+ * The result value of the sampler for this span
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_OTEL_SPAN_SAMPLING_RESULT: "otel.span.sampling_result";
+/**
+ * The number of spans for which the processing has finished, either successful or failed.
+ *
+ * @note For successful processing, `error.type` **MUST NOT** be set. For failed processing, `error.type` **MUST** contain the failure cause.
+ * For the SDK Simple and Batching Span Processor a span is considered to be processed already when it has been submitted to the exporter, not when the corresponding export call has finished.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_OTEL_SDK_PROCESSOR_SPAN_PROCESSED: "otel.sdk.processor.span.processed";
+/**
+ * The maximum number of spans the queue of a given instance of an SDK span processor can hold.
+ *
+ * @note Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_CAPACITY: "otel.sdk.processor.span.queue.capacity";
+/**
+ * The number of spans in the queue of a given instance of an SDK span processor.
+ *
+ * @note Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_SIZE: "otel.sdk.processor.span.queue.size";
+/**
+ * The number of created spans with `recording=true` for which the end operation has not been called yet.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_OTEL_SDK_SPAN_LIVE: "otel.sdk.span.live";
+/**
+ * The number of created spans.
+ *
+ * @note Implementations **MUST** record this metric for all spans, even for non-recording ones.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_OTEL_SDK_SPAN_STARTED: "otel.sdk.span.started";
+/**
+ * Enum value "batching_span_processor" for attribute {@link ATTR_OTEL_COMPONENT_TYPE}.
+ *
+ * The builtin SDK batching span processor
+ *
+ * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const OTEL_COMPONENT_TYPE_VALUE_BATCHING_SPAN_PROCESSOR: "batching_span_processor";
+/**
+ * Enum value "simple_span_processor" for attribute {@link ATTR_OTEL_COMPONENT_TYPE}.
+ *
+ * The builtin SDK simple span processor
+ *
+ * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const OTEL_COMPONENT_TYPE_VALUE_SIMPLE_SPAN_PROCESSOR: "simple_span_processor";
+//# sourceMappingURL=semconv.d.ts.map

package/node_modules/@opentelemetry/sdk-trace/build/esnext/semconv.js

@@ -0,0 +1,112 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/*
+ * This file contains a copy of unstable semantic convention definitions
+ * used by this package.
+ * @see https://github.com/open-telemetry/opentelemetry-js/tree/main/semantic-conventions#unstable-semconv
+ */
+/**
+ * A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance.
+ *
+ * @example otlp_grpc_span_exporter/0
+ * @example custom-name
+ *
+ * @note Implementations **SHOULD** ensure a low cardinality for this attribute, even across application or SDK restarts.
+ * E.g. implementations **MUST NOT** use UUIDs as values for this attribute.
+ *
+ * Implementations **MAY** achieve these goals by following a `<otel.component.type>/<instance-counter>` pattern, e.g. `batching_span_processor/0`.
+ * Hereby `otel.component.type` refers to the corresponding attribute value of the component.
+ *
+ * The value of `instance-counter` **MAY** be automatically assigned by the component and uniqueness within the enclosing SDK instance **MUST** be guaranteed.
+ * For example, `<instance-counter>` **MAY** be implemented by using a monotonically increasing counter (starting with `0`), which is incremented every time an
+ * instance of the given component type is started.
+ *
+ * With this implementation, for example the first Batching Span Processor would have `batching_span_processor/0`
+ * as `otel.component.name`, the second one `batching_span_processor/1` and so on.
+ * These values will therefore be reused in the case of an application restart.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const ATTR_OTEL_COMPONENT_NAME = 'otel.component.name';
+/**
+ * A name identifying the type of the OpenTelemetry component.
+ *
+ * @example batching_span_processor
+ * @example com.example.MySpanExporter
+ *
+ * @note If none of the standardized values apply, implementations **SHOULD** use the language-defined name of the type.
+ * E.g. for Java the fully qualified classname **SHOULD** be used in this case.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const ATTR_OTEL_COMPONENT_TYPE = 'otel.component.type';
+/**
+ * Determines whether the span has a parent span, and if so, [whether it is a remote parent](https://opentelemetry.io/docs/specs/otel/trace/api/#isremote)
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const ATTR_OTEL_SPAN_PARENT_ORIGIN = 'otel.span.parent.origin';
+/**
+ * The result value of the sampler for this span
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const ATTR_OTEL_SPAN_SAMPLING_RESULT = 'otel.span.sampling_result';
+/**
+ * The number of spans for which the processing has finished, either successful or failed.
+ *
+ * @note For successful processing, `error.type` **MUST NOT** be set. For failed processing, `error.type` **MUST** contain the failure cause.
+ * For the SDK Simple and Batching Span Processor a span is considered to be processed already when it has been submitted to the exporter, not when the corresponding export call has finished.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const METRIC_OTEL_SDK_PROCESSOR_SPAN_PROCESSED = 'otel.sdk.processor.span.processed';
+/**
+ * The maximum number of spans the queue of a given instance of an SDK span processor can hold.
+ *
+ * @note Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_CAPACITY = 'otel.sdk.processor.span.queue.capacity';
+/**
+ * The number of spans in the queue of a given instance of an SDK span processor.
+ *
+ * @note Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_SIZE = 'otel.sdk.processor.span.queue.size';
+/**
+ * The number of created spans with `recording=true` for which the end operation has not been called yet.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const METRIC_OTEL_SDK_SPAN_LIVE = 'otel.sdk.span.live';
+/**
+ * The number of created spans.
+ *
+ * @note Implementations **MUST** record this metric for all spans, even for non-recording ones.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const METRIC_OTEL_SDK_SPAN_STARTED = 'otel.sdk.span.started';
+/**
+ * Enum value "batching_span_processor" for attribute {@link ATTR_OTEL_COMPONENT_TYPE}.
+ *
+ * The builtin SDK batching span processor
+ *
+ * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const OTEL_COMPONENT_TYPE_VALUE_BATCHING_SPAN_PROCESSOR = 'batching_span_processor';
+/**
+ * Enum value "simple_span_processor" for attribute {@link ATTR_OTEL_COMPONENT_TYPE}.
+ *
+ * The builtin SDK simple span processor
+ *
+ * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const OTEL_COMPONENT_TYPE_VALUE_SIMPLE_SPAN_PROCESSOR = 'simple_span_processor';
+//# sourceMappingURL=semconv.js.map

package/node_modules/@opentelemetry/sdk-trace/build/esnext/semconv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semconv.js","sourceRoot":"","sources":["../../src/semconv.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,qBAA8B,CAAC;AAEvE;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,qBAA8B,CAAC;AAEvE;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,yBAAkC,CAAC;AAE/E;;;;GAIG;AACH,MAAM,CAAC,MAAM,8BAA8B,GACzC,2BAAoC,CAAC;AAEvC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wCAAwC,GACnD,mCAA4C,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,6CAA6C,GACxD,wCAAiD,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yCAAyC,GACpD,oCAA6C,CAAC;AAEhD;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,oBAA6B,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,uBAAgC,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iDAAiD,GAC5D,yBAAkC,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,+CAA+C,GAC1D,uBAAgC,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/*\n * This file contains a copy of unstable semantic convention definitions\n * used by this package.\n * @see https://github.com/open-telemetry/opentelemetry-js/tree/main/semantic-conventions#unstable-semconv\n */\n\n/**\n * A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance.\n *\n * @example otlp_grpc_span_exporter/0\n * @example custom-name\n *\n * @note Implementations **SHOULD** ensure a low cardinality for this attribute, even across application or SDK restarts.\n * E.g. implementations **MUST NOT** use UUIDs as values for this attribute.\n *\n * Implementations **MAY** achieve these goals by following a `<otel.component.type>/<instance-counter>` pattern, e.g. `batching_span_processor/0`.\n * Hereby `otel.component.type` refers to the corresponding attribute value of the component.\n *\n * The value of `instance-counter` **MAY** be automatically assigned by the component and uniqueness within the enclosing SDK instance **MUST** be guaranteed.\n * For example, `<instance-counter>` **MAY** be implemented by using a monotonically increasing counter (starting with `0`), which is incremented every time an\n * instance of the given component type is started.\n *\n * With this implementation, for example the first Batching Span Processor would have `batching_span_processor/0`\n * as `otel.component.name`, the second one `batching_span_processor/1` and so on.\n * These values will therefore be reused in the case of an application restart.\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const ATTR_OTEL_COMPONENT_NAME = 'otel.component.name' as const;\n\n/**\n * A name identifying the type of the OpenTelemetry component.\n *\n * @example batching_span_processor\n * @example com.example.MySpanExporter\n *\n * @note If none of the standardized values apply, implementations **SHOULD** use the language-defined name of the type.\n * E.g. for Java the fully qualified classname **SHOULD** be used in this case.\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const ATTR_OTEL_COMPONENT_TYPE = 'otel.component.type' as const;\n\n/**\n * Determines whether the span has a parent span, and if so, [whether it is a remote parent](https://opentelemetry.io/docs/specs/otel/trace/api/#isremote)\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const ATTR_OTEL_SPAN_PARENT_ORIGIN = 'otel.span.parent.origin' as const;\n\n/**\n * The result value of the sampler for this span\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const ATTR_OTEL_SPAN_SAMPLING_RESULT =\n  'otel.span.sampling_result' as const;\n\n/**\n * The number of spans for which the processing has finished, either successful or failed.\n *\n * @note For successful processing, `error.type` **MUST NOT** be set. For failed processing, `error.type` **MUST** contain the failure cause.\n * For the SDK Simple and Batching Span Processor a span is considered to be processed already when it has been submitted to the exporter, not when the corresponding export call has finished.\n *\n * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const METRIC_OTEL_SDK_PROCESSOR_SPAN_PROCESSED =\n  'otel.sdk.processor.span.processed' as const;\n\n/**\n * The maximum number of spans the queue of a given instance of an SDK span processor can hold.\n *\n * @note Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.\n *\n * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_CAPACITY =\n  'otel.sdk.processor.span.queue.capacity' as const;\n\n/**\n * The number of spans in the queue of a given instance of an SDK span processor.\n *\n * @note Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.\n *\n * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_SIZE =\n  'otel.sdk.processor.span.queue.size' as const;\n\n/**\n * The number of created spans with `recording=true` for which the end operation has not been called yet.\n *\n * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const METRIC_OTEL_SDK_SPAN_LIVE = 'otel.sdk.span.live' as const;\n\n/**\n * The number of created spans.\n *\n * @note Implementations **MUST** record this metric for all spans, even for non-recording ones.\n *\n * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const METRIC_OTEL_SDK_SPAN_STARTED = 'otel.sdk.span.started' as const;\n\n/**\n * Enum value \"batching_span_processor\" for attribute {@link ATTR_OTEL_COMPONENT_TYPE}.\n *\n * The builtin SDK batching span processor\n *\n * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const OTEL_COMPONENT_TYPE_VALUE_BATCHING_SPAN_PROCESSOR =\n  'batching_span_processor' as const;\n\n/**\n * Enum value \"simple_span_processor\" for attribute {@link ATTR_OTEL_COMPONENT_TYPE}.\n *\n * The builtin SDK simple span processor\n *\n * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const OTEL_COMPONENT_TYPE_VALUE_SIMPLE_SPAN_PROCESSOR =\n  'simple_span_processor' as const;\n"]}

package/node_modules/@opentelemetry/{sdk-trace-base/build/src → sdk-trace/build/esnext}/types.d.ts

@@ -1,18 +1,14 @@
-import type { ContextManager, MeterProvider, TextMapPropagator } from '@opentelemetry/api';
+import type { MeterProvider } from '@opentelemetry/api';
 import type { Resource } from '@opentelemetry/resources';
 import type { IdGenerator } from './IdGenerator';
 import type { Sampler } from './Sampler';
 import type { SpanProcessor } from './SpanProcessor';
-/**
- * TracerConfig provides an interface for configuring a Basic Tracer.
- */
-export interface TracerConfig {
+import type { SpanExporter } from './export/SpanExporter';
+export interface TracerProviderOptions {
     /**
      * Sampler determines if a span should be recorded or should be a NoopSpan.
      */
     sampler?: Sampler;
-    /** General Limits */
-    generalLimits?: GeneralLimits;
     /** Span Limits */
     spanLimits?: SpanLimits;
     /** Resource associated with trace telemetry  */
@@ -33,27 +29,23 @@ export interface TracerConfig {
     spanProcessors?: SpanProcessor[];
     /**
      * A meter provider to record trace SDK metrics to.
+     * This defaults to a no-op meter provider.
      * @experimental This option is experimental and is subject to breaking changes in minor releases.
      */
     meterProvider?: MeterProvider;
 }
 /**
- * Configuration options for registering the API with the SDK.
- * Undefined values may be substituted for defaults, and null
- * values will not be registered.
+ * The constructor options for the internal Tracer implementation.
+ * This is similar to, but not exactly the same exactly the same as
+ * `TracerProviderOptions`.
  */
-export interface SDKRegistrationConfig {
-    /** Propagator to register as the global propagator */
-    propagator?: TextMapPropagator | null;
-    /** Context manager to register as the global context manager */
-    contextManager?: ContextManager | null;
-}
-/** Global configuration limits of trace service */
-export interface GeneralLimits {
-    /** attributeValueLengthLimit is maximum allowed attribute value size */
-    attributeValueLengthLimit?: number;
-    /** attributeCountLimit is number of attributes per trace */
-    attributeCountLimit?: number;
+export interface TracerOptions {
+    resource: Resource;
+    sampler: Sampler;
+    spanLimits: SpanLimits;
+    idGenerator: IdGenerator;
+    spanProcessor: SpanProcessor;
+    meterProvider: MeterProvider;
 }
 /** Global configuration of trace service */
 export interface SpanLimits {
@@ -70,8 +62,23 @@ export interface SpanLimits {
     /** attributePerLinkCountLimit is the maximum number of attributes allowed per span link */
     attributePerLinkCountLimit?: number;
 }
-/** Interface configuration for a buffer. */
-export interface BufferConfig {
+/**
+ * Common options for SDK span processors.
+ *
+ * @experimental This interface is experimental and is subject to breaking changes in minor releases.
+ */
+export interface SpanProcessorOptions {
+    /**
+     * A meter provider to which to record self-observability span processor metrics.
+     * @experimental This option is experimental and is subject to breaking changes in minor releases.
+     */
+    selfObsMeterProvider?: MeterProvider;
+}
+export interface SimpleSpanProcessorOptions extends SpanProcessorOptions {
+    exporter: SpanExporter;
+}
+export interface BatchSpanProcessorOptions extends SpanProcessorOptions {
+    exporter: SpanExporter;
     /** The maximum batch size of every export. It must be smaller or equal to
      * maxQueueSize. The default value is 512. */
     maxExportBatchSize?: number;
@@ -86,7 +93,7 @@ export interface BufferConfig {
     maxQueueSize?: number;
 }
 /** Interface configuration for BatchSpanProcessor on browser */
-export interface BatchSpanProcessorBrowserConfig extends BufferConfig {
+export interface BatchSpanProcessorBrowserOptions extends BatchSpanProcessorOptions {
     /** Disable flush when a user navigates to a new page, closes the tab or the browser, or,
      * on mobile, switches to a different app. Auto flush is enabled by default. */
     disableAutoFlushOnDocumentHide?: boolean;

package/node_modules/@opentelemetry/sdk-trace/build/esnext/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { MeterProvider } from '@opentelemetry/api';\nimport type { Resource } from '@opentelemetry/resources';\nimport type { IdGenerator } from './IdGenerator';\nimport type { Sampler } from './Sampler';\nimport type { SpanProcessor } from './SpanProcessor';\nimport type { SpanExporter } from './export/SpanExporter';\n\nexport interface TracerProviderOptions {\n  /**\n   * Sampler determines if a span should be recorded or should be a NoopSpan.\n   */\n  sampler?: Sampler;\n\n  /** Span Limits */\n  spanLimits?: SpanLimits;\n\n  /** Resource associated with trace telemetry  */\n  resource?: Resource;\n\n  /**\n   * Generator of trace and span IDs\n   * The default idGenerator generates random ids\n   */\n  idGenerator?: IdGenerator;\n\n  /**\n   * How long the forceFlush can run before it is cancelled.\n   * The default value is 30000ms\n   */\n  forceFlushTimeoutMillis?: number;\n\n  /**\n   * List of SpanProcessor for the tracer\n   */\n  spanProcessors?: SpanProcessor[];\n\n  /**\n   * A meter provider to record trace SDK metrics to.\n   * This defaults to a no-op meter provider.\n   * @experimental This option is experimental and is subject to breaking changes in minor releases.\n   */\n  meterProvider?: MeterProvider;\n}\n\n/**\n * The constructor options for the internal Tracer implementation.\n * This is similar to, but not exactly the same exactly the same as\n * `TracerProviderOptions`.\n */\nexport interface TracerOptions {\n  resource: Resource;\n  sampler: Sampler;\n  spanLimits: SpanLimits;\n  idGenerator: IdGenerator;\n  spanProcessor: SpanProcessor;\n  meterProvider: MeterProvider;\n}\n\n/** Global configuration of trace service */\nexport interface SpanLimits {\n  /** attributeValueLengthLimit is maximum allowed attribute value size */\n  attributeValueLengthLimit?: number;\n  /** attributeCountLimit is number of attributes per span */\n  attributeCountLimit?: number;\n  /** linkCountLimit is number of links per span */\n  linkCountLimit?: number;\n  /** eventCountLimit is number of message events per span */\n  eventCountLimit?: number;\n  /** attributePerEventCountLimit is the maximum number of attributes allowed per span event */\n  attributePerEventCountLimit?: number;\n  /** attributePerLinkCountLimit is the maximum number of attributes allowed per span link */\n  attributePerLinkCountLimit?: number;\n}\n\n/**\n * Common options for SDK span processors.\n *\n * @experimental This interface is experimental and is subject to breaking changes in minor releases.\n */\nexport interface SpanProcessorOptions {\n  /**\n   * A meter provider to which to record self-observability span processor metrics.\n   * @experimental This option is experimental and is subject to breaking changes in minor releases.\n   */\n  selfObsMeterProvider?: MeterProvider;\n}\n\nexport interface SimpleSpanProcessorOptions extends SpanProcessorOptions {\n  exporter: SpanExporter;\n}\n\nexport interface BatchSpanProcessorOptions extends SpanProcessorOptions {\n  exporter: SpanExporter;\n\n  /** The maximum batch size of every export. It must be smaller or equal to\n   * maxQueueSize. The default value is 512. */\n  maxExportBatchSize?: number;\n\n  /** The delay interval in milliseconds between two consecutive exports.\n   *  The default value is 5000ms. */\n  scheduledDelayMillis?: number;\n\n  /** How long the export can run before it is cancelled.\n   * The default value is 30000ms */\n  exportTimeoutMillis?: number;\n\n  /** The maximum queue size. After the size is reached spans are dropped.\n   * The default value is 2048. */\n  maxQueueSize?: number;\n}\n\n/** Interface configuration for BatchSpanProcessor on browser */\nexport interface BatchSpanProcessorBrowserOptions\n  extends BatchSpanProcessorOptions {\n  /** Disable flush when a user navigates to a new page, closes the tab or the browser, or,\n   * on mobile, switches to a different app. Auto flush is enabled by default. */\n  disableAutoFlushOnDocumentHide?: boolean;\n}\n"]}

package/node_modules/@opentelemetry/sdk-trace/build/esnext/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "2.9.0";
+//# sourceMappingURL=version.d.ts.map

package/node_modules/@opentelemetry/sdk-trace/build/esnext/version.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// this is autogenerated file, see scripts/version-update.js
+export const VERSION = '2.9.0';
+//# sourceMappingURL=version.js.map

package/node_modules/@opentelemetry/sdk-trace/build/esnext/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,4DAA4D;AAC5D,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n// this is autogenerated file, see scripts/version-update.js\nexport const VERSION = '2.9.0';\n"]}

package/node_modules/@opentelemetry/{sdk-trace-base/build/esm → sdk-trace/build/src}/Tracer.d.ts

@@ -1,8 +1,6 @@
 import * as api from '@opentelemetry/api';
 import type { InstrumentationScope } from '@opentelemetry/core';
-import type { GeneralLimits, SpanLimits, TracerConfig } from './types';
-import type { SpanProcessor } from './SpanProcessor';
-import type { Resource } from '@opentelemetry/resources';
+import type { TracerOptions } from './types';
 import type { InspectFn, InspectStylizeOptions } from './inspect';
 import { inspectCustom } from './inspect';
 /**
@@ -10,7 +8,6 @@ import { inspectCustom } from './inspect';
  */
 export declare class Tracer implements api.Tracer {
     private readonly _sampler;
-    private readonly _generalLimits;
     private readonly _spanLimits;
     private readonly _idGenerator;
     readonly instrumentationScope: InstrumentationScope;
@@ -20,7 +17,7 @@ export declare class Tracer implements api.Tracer {
     /**
      * Constructs a new Tracer instance.
      */
-    constructor(instrumentationScope: InstrumentationScope, config: TracerConfig, resource: Resource, spanProcessor: SpanProcessor);
+    constructor(instrumentationScope: InstrumentationScope, options: TracerOptions);
     /**
      * Starts a new Span or returns the default NoopSpan based on the sampling
      * decision.
@@ -77,10 +74,6 @@ export declare class Tracer implements api.Tracer {
     startActiveSpan<F extends (span: api.Span) => ReturnType<F>>(name: string, fn: F): ReturnType<F>;
     startActiveSpan<F extends (span: api.Span) => ReturnType<F>>(name: string, opts: api.SpanOptions, fn: F): ReturnType<F>;
     startActiveSpan<F extends (span: api.Span) => ReturnType<F>>(name: string, opts: api.SpanOptions, ctx: api.Context, fn: F): ReturnType<F>;
-    /** Returns the active {@link GeneralLimits}. */
-    getGeneralLimits(): GeneralLimits;
-    /** Returns the active {@link SpanLimits}. */
-    getSpanLimits(): SpanLimits;
     [inspectCustom](depth: number, options: InspectStylizeOptions | undefined, inspect: InspectFn | undefined): unknown;
 }
 //# sourceMappingURL=Tracer.d.ts.map

package/node_modules/@opentelemetry/{sdk-trace-base → sdk-trace}/build/src/Tracer.js

@@ -8,8 +8,6 @@ exports.Tracer = void 0;
 const api = require("@opentelemetry/api");
 const core_1 = require("@opentelemetry/core");
 const Span_1 = require("./Span");
-const utility_1 = require("./utility");
-const platform_1 = require("./platform");
 const TracerMetrics_1 = require("./TracerMetrics");
 const version_1 = require("./version");
 const inspect_1 = require("./inspect");
@@ -18,7 +16,6 @@ const inspect_1 = require("./inspect");
  */
 class Tracer {
     _sampler;
-    _generalLimits;
     _spanLimits;
     _idGenerator;
     instrumentationScope;
@@ -28,18 +25,14 @@ class Tracer {
     /**
      * Constructs a new Tracer instance.
      */
-    constructor(instrumentationScope, config, resource, spanProcessor) {
-        const localConfig = (0, utility_1.mergeConfig)(config);
-        this._sampler = localConfig.sampler;
-        this._generalLimits = localConfig.generalLimits;
-        this._spanLimits = localConfig.spanLimits;
-        this._idGenerator = config.idGenerator || new platform_1.RandomIdGenerator();
-        this._resource = resource;
-        this._spanProcessor = spanProcessor;
+    constructor(instrumentationScope, options) {
         this.instrumentationScope = instrumentationScope;
-        const meter = localConfig.meterProvider
-            ? localConfig.meterProvider.getMeter('@opentelemetry/sdk-trace', version_1.VERSION)
-            : api.createNoopMeter();
+        this._sampler = options.sampler;
+        this._spanLimits = options.spanLimits;
+        this._resource = options.resource;
+        this._idGenerator = options.idGenerator;
+        this._spanProcessor = options.spanProcessor;
+        const meter = options.meterProvider.getMeter('@opentelemetry/sdk-trace', version_1.VERSION);
         this._tracerMetrics = new TracerMetrics_1.TracerMetrics(meter);
     }
     /**
@@ -138,20 +131,11 @@ class Tracer {
         const contextWithSpanSet = api.trace.setSpan(parentContext, span);
         return api.context.with(contextWithSpanSet, fn, undefined, span);
     }
-    /** Returns the active {@link GeneralLimits}. */
-    getGeneralLimits() {
-        return this._generalLimits;
-    }
-    /** Returns the active {@link SpanLimits}. */
-    getSpanLimits() {
-        return this._spanLimits;
-    }
     [inspect_1.inspectCustom](depth, options, inspect) {
         const payload = {
             instrumentationScope: this.instrumentationScope,
             resource: { attributes: (0, inspect_1.settledResourceAttributes)(this._resource) },
             spanLimits: this._spanLimits,
-            generalLimits: this._generalLimits,
         };
         return (0, inspect_1.formatInspect)('Tracer', payload, depth, options, inspect);
     }

package/node_modules/@opentelemetry/sdk-trace/build/src/Tracer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tracer.js","sourceRoot":"","sources":["../../src/Tracer.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport * as api from '@opentelemetry/api';\nimport type { InstrumentationScope } from '@opentelemetry/core';\nimport { sanitizeAttributes, isTracingSuppressed } from '@opentelemetry/core';\nimport { SpanImpl } from './Span';\nimport type { SpanLimits, TracerOptions } from './types';\nimport type { SpanProcessor } from './SpanProcessor';\nimport type { Sampler } from './Sampler';\nimport type { IdGenerator } from './IdGenerator';\nimport type { Resource } from '@opentelemetry/resources';\nimport { TracerMetrics } from './TracerMetrics';\nimport { VERSION } from './version';\nimport type { InspectFn, InspectStylizeOptions } from './inspect';\nimport {\n  formatInspect,\n  inspectCustom,\n  settledResourceAttributes,\n} from './inspect';\n\n/**\n * This class represents a basic tracer.\n */\nexport class Tracer implements api.Tracer {\n  private readonly _sampler: Sampler;\n  private readonly _spanLimits: SpanLimits;\n  private readonly _idGenerator: IdGenerator;\n  readonly instrumentationScope: InstrumentationScope;\n\n  private readonly _resource: Resource;\n  private readonly _spanProcessor: SpanProcessor;\n  private readonly _tracerMetrics: TracerMetrics;\n\n  /**\n   * Constructs a new Tracer instance.\n   */\n  constructor(\n    instrumentationScope: InstrumentationScope,\n    options: TracerOptions\n  ) {\n    this.instrumentationScope = instrumentationScope;\n    this._sampler = options.sampler;\n    this._spanLimits = options.spanLimits;\n    this._resource = options.resource;\n    this._idGenerator = options.idGenerator;\n    this._spanProcessor = options.spanProcessor;\n\n    const meter = options.meterProvider.getMeter(\n      '@opentelemetry/sdk-trace',\n      VERSION\n    );\n    this._tracerMetrics = new TracerMetrics(meter);\n  }\n\n  /**\n   * Starts a new Span or returns the default NoopSpan based on the sampling\n   * decision.\n   */\n  startSpan(\n    name: string,\n    options: api.SpanOptions = {},\n    context = api.context.active()\n  ): api.Span {\n    // remove span from context in case a root span is requested via options\n    if (options.root) {\n      context = api.trace.deleteSpan(context);\n    }\n    const parentSpan = api.trace.getSpan(context);\n\n    if (isTracingSuppressed(context)) {\n      api.diag.debug('Instrumentation suppressed, returning Noop Span');\n      const nonRecordingSpan = api.trace.wrapSpanContext(\n        api.INVALID_SPAN_CONTEXT\n      );\n      return nonRecordingSpan;\n    }\n\n    const parentSpanContext = parentSpan?.spanContext();\n    const spanId = this._idGenerator.generateSpanId();\n    let validParentSpanContext;\n    let traceId;\n    let traceState;\n    if (\n      !parentSpanContext ||\n      !api.trace.isSpanContextValid(parentSpanContext)\n    ) {\n      // New root span.\n      traceId = this._idGenerator.generateTraceId();\n    } else {\n      // New child span.\n      traceId = parentSpanContext.traceId;\n      traceState = parentSpanContext.traceState;\n      validParentSpanContext = parentSpanContext;\n    }\n\n    const spanKind = options.kind ?? api.SpanKind.INTERNAL;\n    const links = (options.links ?? []).map(link => {\n      return {\n        context: link.context,\n        attributes: sanitizeAttributes(link.attributes),\n      };\n    });\n    const attributes = sanitizeAttributes(options.attributes);\n    // make sampling decision\n    const samplingResult = this._sampler.shouldSample(\n      context,\n      traceId,\n      name,\n      spanKind,\n      attributes,\n      links\n    );\n\n    const recordEndMetrics = this._tracerMetrics.startSpan(\n      parentSpanContext,\n      samplingResult.decision\n    );\n\n    traceState = samplingResult.traceState ?? traceState;\n\n    const traceFlags =\n      samplingResult.decision === api.SamplingDecision.RECORD_AND_SAMPLED\n        ? api.TraceFlags.SAMPLED\n        : api.TraceFlags.NONE;\n    const spanContext = { traceId, spanId, traceFlags, traceState };\n    if (samplingResult.decision === api.SamplingDecision.NOT_RECORD) {\n      api.diag.debug(\n        'Recording is off, propagating context in a non-recording span'\n      );\n      const nonRecordingSpan = api.trace.wrapSpanContext(spanContext);\n      return nonRecordingSpan;\n    }\n\n    // Set initial span attributes. The attributes object may have been mutated\n    // by the sampler, so we sanitize the merged attributes before setting them.\n    const initAttributes = sanitizeAttributes(\n      Object.assign(attributes, samplingResult.attributes)\n    );\n\n    const span = new SpanImpl({\n      resource: this._resource,\n      scope: this.instrumentationScope,\n      context,\n      spanContext,\n      name,\n      kind: spanKind,\n      links,\n      parentSpanContext: validParentSpanContext,\n      attributes: initAttributes,\n      startTime: options.startTime,\n      spanProcessor: this._spanProcessor,\n      spanLimits: this._spanLimits,\n      recordEndMetrics,\n    });\n    return span;\n  }\n\n  /**\n   * Starts a new {@link Span} and calls the given function passing it the\n   * created span as first argument.\n   * Additionally the new span gets set in context and this context is activated\n   * for the duration of the function call.\n   *\n   * **Important**: The callback function is responsible for calling `span.end()`\n   * to finish the span. Unlike some other OpenTelemetry implementations, the span\n   * is NOT automatically ended when the callback returns. If `span.end()` is not\n   * called, the span will never be exported and will be silently lost.\n   *\n   * @param name The name of the span\n   * @param [options] SpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns return value of fn\n   * @example\n   *   const something = tracer.startActiveSpan('op', span => {\n   *     try {\n   *       do some work\n   *       span.setStatus({code: SpanStatusCode.OK});\n   *       return something;\n   *     } catch (err) {\n   *       span.setStatus({\n   *         code: SpanStatusCode.ERROR,\n   *         message: err.message,\n   *       });\n   *       throw err;\n   *     } finally {\n   *       span.end();\n   *     }\n   *   });\n   * @example\n   *   const span = tracer.startActiveSpan('op', span => {\n   *     try {\n   *       do some work\n   *       return span;\n   *     } catch (err) {\n   *       span.setStatus({\n   *         code: SpanStatusCode.ERROR,\n   *         message: err.message,\n   *       });\n   *       throw err;\n   *     }\n   *   });\n   *   do some more work\n   *   span.end();\n   */\n  startActiveSpan<F extends (span: api.Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  startActiveSpan<F extends (span: api.Span) => ReturnType<F>>(\n    name: string,\n    opts: api.SpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  startActiveSpan<F extends (span: api.Span) => ReturnType<F>>(\n    name: string,\n    opts: api.SpanOptions,\n    ctx: api.Context,\n    fn: F\n  ): ReturnType<F>;\n  startActiveSpan<F extends (span: api.Span) => ReturnType<F>>(\n    name: string,\n    arg2?: F | api.SpanOptions,\n    arg3?: F | api.Context,\n    arg4?: F\n  ): ReturnType<F> | undefined {\n    let opts: api.SpanOptions | undefined;\n    let ctx: api.Context | undefined;\n    let fn: F;\n\n    if (arguments.length < 2) {\n      return;\n    } else if (arguments.length === 2) {\n      fn = arg2 as F;\n    } else if (arguments.length === 3) {\n      opts = arg2 as api.SpanOptions | undefined;\n      fn = arg3 as F;\n    } else {\n      opts = arg2 as api.SpanOptions | undefined;\n      ctx = arg3 as api.Context | undefined;\n      fn = arg4 as F;\n    }\n\n    const parentContext = ctx ?? api.context.active();\n    const span = this.startSpan(name, opts, parentContext);\n    const contextWithSpanSet = api.trace.setSpan(parentContext, span);\n\n    return api.context.with(contextWithSpanSet, fn, undefined, span);\n  }\n\n  [inspectCustom](\n    depth: number,\n    options: InspectStylizeOptions | undefined,\n    inspect: InspectFn | undefined\n  ): unknown {\n    const payload = {\n      instrumentationScope: this.instrumentationScope,\n      resource: { attributes: settledResourceAttributes(this._resource) },\n      spanLimits: this._spanLimits,\n    };\n    return formatInspect('Tracer', payload, depth, options, inspect);\n  }\n}\n"]}

package/node_modules/@opentelemetry/{sdk-trace-base/build/esnext/BasicTracerProvider.d.ts → sdk-trace/build/src/TracerProvider.d.ts}

@@ -1,22 +1,17 @@
-import type { TracerProvider, Tracer as ApiTracer } from '@opentelemetry/api';
-import type { TracerConfig } from './types';
+import type { TracerProvider as ApiTracerProvider, Tracer as ApiTracer } from '@opentelemetry/api';
+import type { TracerProviderOptions } from './types';
 import type { InspectFn, InspectStylizeOptions } from './inspect';
 import { inspectCustom } from './inspect';
-export declare enum ForceFlushState {
-    'resolved' = 0,
-    'timeout' = 1,
-    'error' = 2,
-    'unresolved' = 3
-}
 /**
  * This class represents a basic tracer provider which platform libraries can extend
  */
-export declare class BasicTracerProvider implements TracerProvider {
-    private readonly _config;
-    private readonly _tracers;
+export declare class TracerProvider implements ApiTracerProvider {
     private readonly _resource;
     private readonly _activeSpanProcessor;
-    constructor(config?: TracerConfig);
+    private readonly _forceFlushTimeoutMillis;
+    private readonly _tracerOptions;
+    private readonly _tracers;
+    constructor(options?: TracerProviderOptions);
     getTracer(name: string, version?: string, options?: {
         schemaUrl?: string;
     }): ApiTracer;
@@ -24,4 +19,4 @@ export declare class BasicTracerProvider implements TracerProvider {
     shutdown(): Promise<void>;
     [inspectCustom](depth: number, options: InspectStylizeOptions | undefined, inspect: InspectFn | undefined): unknown;
 }
-//# sourceMappingURL=BasicTracerProvider.d.ts.map
+//# sourceMappingURL=TracerProvider.d.ts.map

package/node_modules/@opentelemetry/{sdk-trace-base/build/src/BasicTracerProvider.js → sdk-trace/build/src/TracerProvider.js}

@@ -4,13 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BasicTracerProvider = exports.ForceFlushState = void 0;
-const core_1 = require("@opentelemetry/core");
+exports.TracerProvider = void 0;
+const api_1 = require("@opentelemetry/api");
 const resources_1 = require("@opentelemetry/resources");
 const Tracer_1 = require("./Tracer");
-const config_1 = require("./config");
 const MultiSpanProcessor_1 = require("./MultiSpanProcessor");
-const utility_1 = require("./utility");
+const ParentBasedSampler_1 = require("./sampler/ParentBasedSampler");
+const AlwaysOnSampler_1 = require("./sampler/AlwaysOnSampler");
+const platform_1 = require("./platform");
 const inspect_1 = require("./inspect");
 var ForceFlushState;
 (function (ForceFlushState) {
@@ -18,36 +19,53 @@ var ForceFlushState;
     ForceFlushState[ForceFlushState["timeout"] = 1] = "timeout";
     ForceFlushState[ForceFlushState["error"] = 2] = "error";
     ForceFlushState[ForceFlushState["unresolved"] = 3] = "unresolved";
-})(ForceFlushState = exports.ForceFlushState || (exports.ForceFlushState = {}));
+})(ForceFlushState || (ForceFlushState = {}));
 /**
  * This class represents a basic tracer provider which platform libraries can extend
  */
-class BasicTracerProvider {
-    _config;
-    _tracers = new Map();
+class TracerProvider {
     _resource;
     _activeSpanProcessor;
-    constructor(config = {}) {
-        const mergedConfig = (0, core_1.merge)({}, (0, config_1.loadDefaultConfig)(), (0, utility_1.reconfigureLimits)(config));
-        this._resource = mergedConfig.resource ?? (0, resources_1.defaultResource)();
-        this._config = Object.assign({}, mergedConfig, {
-            resource: this._resource,
-        });
-        const spanProcessors = [];
-        if (config.spanProcessors?.length) {
-            spanProcessors.push(...config.spanProcessors);
-        }
+    _forceFlushTimeoutMillis;
+    _tracerOptions;
+    _tracers = new Map();
+    constructor(options = {}) {
+        this._forceFlushTimeoutMillis = options.forceFlushTimeoutMillis ?? 30000;
+        this._resource = options.resource ?? (0, resources_1.defaultResource)();
+        const spanProcessors = options.spanProcessors ?? [];
         this._activeSpanProcessor = new MultiSpanProcessor_1.MultiSpanProcessor(spanProcessors);
+        this._tracerOptions = {
+            resource: this._resource,
+            sampler: options.sampler ??
+                new ParentBasedSampler_1.ParentBasedSampler({
+                    root: new AlwaysOnSampler_1.AlwaysOnSampler(),
+                }),
+            spanLimits: {
+                attributeCountLimit: options.spanLimits?.attributeCountLimit ?? 128,
+                attributeValueLengthLimit: options.spanLimits?.attributeValueLengthLimit ?? Infinity,
+                eventCountLimit: options.spanLimits?.eventCountLimit ?? 128,
+                linkCountLimit: options.spanLimits?.linkCountLimit ?? 128,
+                attributePerEventCountLimit: options.spanLimits?.attributePerEventCountLimit ?? 128,
+                attributePerLinkCountLimit: options.spanLimits?.attributePerLinkCountLimit ?? 128,
+            },
+            idGenerator: options.idGenerator || new platform_1.RandomIdGenerator(),
+            spanProcessor: this._activeSpanProcessor,
+            meterProvider: options.meterProvider ?? {
+                getMeter() {
+                    return (0, api_1.createNoopMeter)();
+                },
+            },
+        };
     }
     getTracer(name, version, options) {
         const key = `${name}@${version || ''}:${options?.schemaUrl || ''}`;
         if (!this._tracers.has(key)) {
-            this._tracers.set(key, new Tracer_1.Tracer({ name, version, schemaUrl: options?.schemaUrl }, this._config, this._resource, this._activeSpanProcessor));
+            this._tracers.set(key, new Tracer_1.Tracer({ name, version, schemaUrl: options?.schemaUrl }, this._tracerOptions));
         }
         return this._tracers.get(key);
     }
     forceFlush() {
-        const timeout = this._config.forceFlushTimeoutMillis;
+        const timeout = this._forceFlushTimeoutMillis;
         const promises = this._activeSpanProcessor['_spanProcessors'].map((spanProcessor) => {
             return new Promise(resolve => {
                 let state;
@@ -95,8 +113,8 @@ class BasicTracerProvider {
             tracers: Array.from(this._tracers.keys()),
             spanProcessors: processors.map(p => p.constructor?.name ?? 'SpanProcessor'),
         };
-        return (0, inspect_1.formatInspect)('BasicTracerProvider', payload, depth, options, inspect);
+        return (0, inspect_1.formatInspect)('TracerProvider', payload, depth, options, inspect);
     }
 }
-exports.BasicTracerProvider = BasicTracerProvider;
-//# sourceMappingURL=BasicTracerProvider.js.map
+exports.TracerProvider = TracerProvider;
+//# sourceMappingURL=TracerProvider.js.map