@qqbrowser/openclaw-qbot 0.10.17 → 0.10.18

package/node_modules/@opentelemetry/otlp-transformer/node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js

@@ -1,146 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import * as api from '@opentelemetry/api';
-import { sanitizeAttributes, isTracingSuppressed, } from '@opentelemetry/core';
-import { SpanImpl } from './Span';
-import { mergeConfig } from './utility';
-import { RandomIdGenerator } from './platform';
-import { TracerMetrics } from './TracerMetrics';
-import { VERSION } from './version';
-/**
- * This class represents a basic tracer.
- */
-export class Tracer {
-    _sampler;
-    _generalLimits;
-    _spanLimits;
-    _idGenerator;
-    instrumentationScope;
-    _resource;
-    _spanProcessor;
-    _tracerMetrics;
-    /**
-     * Constructs a new Tracer instance.
-     */
-    constructor(instrumentationScope, config, resource, spanProcessor) {
-        const localConfig = mergeConfig(config);
-        this._sampler = localConfig.sampler;
-        this._generalLimits = localConfig.generalLimits;
-        this._spanLimits = localConfig.spanLimits;
-        this._idGenerator = config.idGenerator || new RandomIdGenerator();
-        this._resource = resource;
-        this._spanProcessor = spanProcessor;
-        this.instrumentationScope = instrumentationScope;
-        const meter = localConfig.meterProvider
-            ? localConfig.meterProvider.getMeter('@opentelemetry/sdk-trace', VERSION)
-            : api.createNoopMeter();
-        this._tracerMetrics = new TracerMetrics(meter);
-    }
-    /**
-     * Starts a new Span or returns the default NoopSpan based on the sampling
-     * decision.
-     */
-    startSpan(name, options = {}, context = api.context.active()) {
-        // remove span from context in case a root span is requested via options
-        if (options.root) {
-            context = api.trace.deleteSpan(context);
-        }
-        const parentSpan = api.trace.getSpan(context);
-        if (isTracingSuppressed(context)) {
-            api.diag.debug('Instrumentation suppressed, returning Noop Span');
-            const nonRecordingSpan = api.trace.wrapSpanContext(api.INVALID_SPAN_CONTEXT);
-            return nonRecordingSpan;
-        }
-        const parentSpanContext = parentSpan?.spanContext();
-        const spanId = this._idGenerator.generateSpanId();
-        let validParentSpanContext;
-        let traceId;
-        let traceState;
-        if (!parentSpanContext ||
-            !api.trace.isSpanContextValid(parentSpanContext)) {
-            // New root span.
-            traceId = this._idGenerator.generateTraceId();
-        }
-        else {
-            // New child span.
-            traceId = parentSpanContext.traceId;
-            traceState = parentSpanContext.traceState;
-            validParentSpanContext = parentSpanContext;
-        }
-        const spanKind = options.kind ?? api.SpanKind.INTERNAL;
-        const links = (options.links ?? []).map(link => {
-            return {
-                context: link.context,
-                attributes: sanitizeAttributes(link.attributes),
-            };
-        });
-        const attributes = sanitizeAttributes(options.attributes);
-        // make sampling decision
-        const samplingResult = this._sampler.shouldSample(context, traceId, name, spanKind, attributes, links);
-        const recordEndMetrics = this._tracerMetrics.startSpan(parentSpanContext, samplingResult.decision);
-        traceState = samplingResult.traceState ?? traceState;
-        const traceFlags = samplingResult.decision === api.SamplingDecision.RECORD_AND_SAMPLED
-            ? api.TraceFlags.SAMPLED
-            : api.TraceFlags.NONE;
-        const spanContext = { traceId, spanId, traceFlags, traceState };
-        if (samplingResult.decision === api.SamplingDecision.NOT_RECORD) {
-            api.diag.debug('Recording is off, propagating context in a non-recording span');
-            const nonRecordingSpan = api.trace.wrapSpanContext(spanContext);
-            return nonRecordingSpan;
-        }
-        // Set initial span attributes. The attributes object may have been mutated
-        // by the sampler, so we sanitize the merged attributes before setting them.
-        const initAttributes = sanitizeAttributes(Object.assign(attributes, samplingResult.attributes));
-        const span = new SpanImpl({
-            resource: this._resource,
-            scope: this.instrumentationScope,
-            context,
-            spanContext,
-            name,
-            kind: spanKind,
-            links,
-            parentSpanContext: validParentSpanContext,
-            attributes: initAttributes,
-            startTime: options.startTime,
-            spanProcessor: this._spanProcessor,
-            spanLimits: this._spanLimits,
-            recordEndMetrics,
-        });
-        return span;
-    }
-    startActiveSpan(name, arg2, arg3, arg4) {
-        let opts;
-        let ctx;
-        let fn;
-        if (arguments.length < 2) {
-            return;
-        }
-        else if (arguments.length === 2) {
-            fn = arg2;
-        }
-        else if (arguments.length === 3) {
-            opts = arg2;
-            fn = arg3;
-        }
-        else {
-            opts = arg2;
-            ctx = arg3;
-            fn = arg4;
-        }
-        const parentContext = ctx ?? api.context.active();
-        const span = this.startSpan(name, opts, parentContext);
-        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;
-    }
-}
-//# sourceMappingURL=Tracer.js.map

package/node_modules/@opentelemetry/otlp-transformer/node_modules/@opentelemetry/sdk-trace-base/build/esm/TracerMetrics.js

@@ -1,57 +0,0 @@
-import { SamplingDecision } from './Sampler';
-import { ATTR_OTEL_SPAN_PARENT_ORIGIN, ATTR_OTEL_SPAN_SAMPLING_RESULT, METRIC_OTEL_SDK_SPAN_LIVE, METRIC_OTEL_SDK_SPAN_STARTED, } from './semconv';
-/**
- * Generates `otel.sdk.span.*` metrics.
- * https://opentelemetry.io/docs/specs/semconv/otel/sdk-metrics/#span-metrics
- */
-export class TracerMetrics {
-    startedSpans;
-    liveSpans;
-    constructor(meter) {
-        this.startedSpans = meter.createCounter(METRIC_OTEL_SDK_SPAN_STARTED, {
-            unit: '{span}',
-            description: 'The number of created spans.',
-        });
-        this.liveSpans = meter.createUpDownCounter(METRIC_OTEL_SDK_SPAN_LIVE, {
-            unit: '{span}',
-            description: 'The number of currently live spans.',
-        });
-    }
-    startSpan(parentSpanCtx, samplingDecision) {
-        const samplingDecisionStr = samplingDecisionToString(samplingDecision);
-        this.startedSpans.add(1, {
-            [ATTR_OTEL_SPAN_PARENT_ORIGIN]: parentOrigin(parentSpanCtx),
-            [ATTR_OTEL_SPAN_SAMPLING_RESULT]: samplingDecisionStr,
-        });
-        if (samplingDecision === SamplingDecision.NOT_RECORD) {
-            return () => { };
-        }
-        const liveSpanAttributes = {
-            [ATTR_OTEL_SPAN_SAMPLING_RESULT]: samplingDecisionStr,
-        };
-        this.liveSpans.add(1, liveSpanAttributes);
-        return () => {
-            this.liveSpans.add(-1, liveSpanAttributes);
-        };
-    }
-}
-function parentOrigin(parentSpanContext) {
-    if (!parentSpanContext) {
-        return 'none';
-    }
-    if (parentSpanContext.isRemote) {
-        return 'remote';
-    }
-    return 'local';
-}
-function samplingDecisionToString(decision) {
-    switch (decision) {
-        case SamplingDecision.RECORD_AND_SAMPLED:
-            return 'RECORD_AND_SAMPLE';
-        case SamplingDecision.RECORD:
-            return 'RECORD_ONLY';
-        case SamplingDecision.NOT_RECORD:
-            return 'DROP';
-    }
-}
-//# sourceMappingURL=TracerMetrics.js.map

package/node_modules/@opentelemetry/otlp-transformer/node_modules/@opentelemetry/sdk-trace-base/build/esm/config.js

@@ -1,91 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { diag } from '@opentelemetry/api';
-import { getNumberFromEnv, getStringFromEnv } from '@opentelemetry/core';
-import { AlwaysOffSampler } from './sampler/AlwaysOffSampler';
-import { AlwaysOnSampler } from './sampler/AlwaysOnSampler';
-import { ParentBasedSampler } from './sampler/ParentBasedSampler';
-import { TraceIdRatioBasedSampler } from './sampler/TraceIdRatioBasedSampler';
-var TracesSamplerValues;
-(function (TracesSamplerValues) {
-    TracesSamplerValues["AlwaysOff"] = "always_off";
-    TracesSamplerValues["AlwaysOn"] = "always_on";
-    TracesSamplerValues["ParentBasedAlwaysOff"] = "parentbased_always_off";
-    TracesSamplerValues["ParentBasedAlwaysOn"] = "parentbased_always_on";
-    TracesSamplerValues["ParentBasedTraceIdRatio"] = "parentbased_traceidratio";
-    TracesSamplerValues["TraceIdRatio"] = "traceidratio";
-})(TracesSamplerValues || (TracesSamplerValues = {}));
-const DEFAULT_RATIO = 1;
-/**
- * Load default configuration. For fields with primitive values, any user-provided
- * value will override the corresponding default value. For fields with
- * non-primitive values (like `spanLimits`), the user-provided value will be
- * used to extend the default value.
- */
-// object needs to be wrapped in this function and called when needed otherwise
-// envs are parsed before tests are ran - causes tests using these envs to fail
-export function loadDefaultConfig() {
-    return {
-        sampler: buildSamplerFromEnv(),
-        forceFlushTimeoutMillis: 30000,
-        generalLimits: {
-            attributeValueLengthLimit: getNumberFromEnv('OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT') ?? Infinity,
-            attributeCountLimit: getNumberFromEnv('OTEL_ATTRIBUTE_COUNT_LIMIT') ?? 128,
-        },
-        spanLimits: {
-            attributeValueLengthLimit: getNumberFromEnv('OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT') ?? Infinity,
-            attributeCountLimit: getNumberFromEnv('OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT') ?? 128,
-            linkCountLimit: getNumberFromEnv('OTEL_SPAN_LINK_COUNT_LIMIT') ?? 128,
-            eventCountLimit: getNumberFromEnv('OTEL_SPAN_EVENT_COUNT_LIMIT') ?? 128,
-            attributePerEventCountLimit: getNumberFromEnv('OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT') ?? 128,
-            attributePerLinkCountLimit: getNumberFromEnv('OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT') ?? 128,
-        },
-    };
-}
-/**
- * Based on environment, builds a sampler, complies with specification.
- */
-export function buildSamplerFromEnv() {
-    const sampler = getStringFromEnv('OTEL_TRACES_SAMPLER') ??
-        TracesSamplerValues.ParentBasedAlwaysOn;
-    switch (sampler) {
-        case TracesSamplerValues.AlwaysOn:
-            return new AlwaysOnSampler();
-        case TracesSamplerValues.AlwaysOff:
-            return new AlwaysOffSampler();
-        case TracesSamplerValues.ParentBasedAlwaysOn:
-            return new ParentBasedSampler({
-                root: new AlwaysOnSampler(),
-            });
-        case TracesSamplerValues.ParentBasedAlwaysOff:
-            return new ParentBasedSampler({
-                root: new AlwaysOffSampler(),
-            });
-        case TracesSamplerValues.TraceIdRatio:
-            return new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv());
-        case TracesSamplerValues.ParentBasedTraceIdRatio:
-            return new ParentBasedSampler({
-                root: new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv()),
-            });
-        default:
-            diag.error(`OTEL_TRACES_SAMPLER value "${sampler}" invalid, defaulting to "${TracesSamplerValues.ParentBasedAlwaysOn}".`);
-            return new ParentBasedSampler({
-                root: new AlwaysOnSampler(),
-            });
-    }
-}
-function getSamplerProbabilityFromEnv() {
-    const probability = getNumberFromEnv('OTEL_TRACES_SAMPLER_ARG');
-    if (probability == null) {
-        diag.error(`OTEL_TRACES_SAMPLER_ARG is blank, defaulting to ${DEFAULT_RATIO}.`);
-        return DEFAULT_RATIO;
-    }
-    if (probability < 0 || probability > 1) {
-        diag.error(`OTEL_TRACES_SAMPLER_ARG=${probability} was given, but it is out of range ([0..1]), defaulting to ${DEFAULT_RATIO}.`);
-        return DEFAULT_RATIO;
-    }
-    return probability;
-}
-//# sourceMappingURL=config.js.map

package/node_modules/@opentelemetry/otlp-transformer/node_modules/@opentelemetry/sdk-trace-base/build/esm/enums.js

@@ -1,7 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-// Event name definitions
-export const ExceptionEventName = 'exception';
-//# sourceMappingURL=enums.js.map

package/node_modules/@opentelemetry/otlp-transformer/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js

@@ -1,208 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { context, diag, TraceFlags } from '@opentelemetry/api';
-import { BindOnceFuture, ExportResultCode, getNumberFromEnv, globalErrorHandler, suppressTracing, } from '@opentelemetry/core';
-/**
- * Implementation of the {@link SpanProcessor} that batches spans exported by
- * the SDK then pushes them to the exporter pipeline.
- */
-export class BatchSpanProcessorBase {
-    _maxExportBatchSize;
-    _maxQueueSize;
-    _scheduledDelayMillis;
-    _exportTimeoutMillis;
-    _exporter;
-    _isExporting = false;
-    _finishedSpans = [];
-    _timer;
-    _shutdownOnce;
-    _droppedSpansCount = 0;
-    constructor(exporter, config) {
-        this._exporter = exporter;
-        this._maxExportBatchSize =
-            typeof config?.maxExportBatchSize === 'number'
-                ? config.maxExportBatchSize
-                : (getNumberFromEnv('OTEL_BSP_MAX_EXPORT_BATCH_SIZE') ?? 512);
-        this._maxQueueSize =
-            typeof config?.maxQueueSize === 'number'
-                ? config.maxQueueSize
-                : (getNumberFromEnv('OTEL_BSP_MAX_QUEUE_SIZE') ?? 2048);
-        this._scheduledDelayMillis =
-            typeof config?.scheduledDelayMillis === 'number'
-                ? config.scheduledDelayMillis
-                : (getNumberFromEnv('OTEL_BSP_SCHEDULE_DELAY') ?? 5000);
-        this._exportTimeoutMillis =
-            typeof config?.exportTimeoutMillis === 'number'
-                ? config.exportTimeoutMillis
-                : (getNumberFromEnv('OTEL_BSP_EXPORT_TIMEOUT') ?? 30000);
-        this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
-        if (this._maxExportBatchSize > this._maxQueueSize) {
-            diag.warn('BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize');
-            this._maxExportBatchSize = this._maxQueueSize;
-        }
-    }
-    forceFlush() {
-        if (this._shutdownOnce.isCalled) {
-            return this._shutdownOnce.promise;
-        }
-        return this._flushAll();
-    }
-    // does nothing.
-    onStart(_span, _parentContext) { }
-    onEnd(span) {
-        if (this._shutdownOnce.isCalled) {
-            return;
-        }
-        if ((span.spanContext().traceFlags & TraceFlags.SAMPLED) === 0) {
-            return;
-        }
-        this._addToBuffer(span);
-    }
-    shutdown() {
-        return this._shutdownOnce.call();
-    }
-    _shutdown() {
-        return Promise.resolve()
-            .then(() => {
-            return this.onShutdown();
-        })
-            .then(() => {
-            return this._flushAll();
-        })
-            .then(() => {
-            return this._exporter.shutdown();
-        });
-    }
-    /** Add a span in the buffer. */
-    _addToBuffer(span) {
-        if (this._finishedSpans.length >= this._maxQueueSize) {
-            // limit reached, drop span
-            if (this._droppedSpansCount === 0) {
-                diag.debug('maxQueueSize reached, dropping spans');
-            }
-            this._droppedSpansCount++;
-            return;
-        }
-        if (this._droppedSpansCount > 0) {
-            // some spans were dropped, log once with count of spans dropped
-            diag.warn(`Dropped ${this._droppedSpansCount} spans because maxQueueSize reached`);
-            this._droppedSpansCount = 0;
-        }
-        this._finishedSpans.push(span);
-        this._maybeStartTimer();
-    }
-    /**
-     * Send all spans to the exporter respecting the batch size limit
-     * This function is used only on forceFlush or shutdown,
-     * for all other cases _flush should be used
-     * */
-    _flushAll() {
-        return new Promise((resolve, reject) => {
-            const promises = [];
-            // calculate number of batches
-            const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
-            for (let i = 0, j = count; i < j; i++) {
-                promises.push(this._flushOneBatch());
-            }
-            Promise.all(promises)
-                .then(() => {
-                resolve();
-            })
-                .catch(reject);
-        });
-    }
-    _flushOneBatch() {
-        this._clearTimer();
-        if (this._finishedSpans.length === 0) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                // don't wait anymore for export, this way the next batch can start
-                reject(new Error('Timeout'));
-            }, this._exportTimeoutMillis);
-            // prevent downstream exporter calls from generating spans
-            context.with(suppressTracing(context.active()), () => {
-                // Reset the finished spans buffer here because the next invocations of the _flush method
-                // could pass the same finished spans to the exporter if the buffer is cleared
-                // outside the execution of this callback.
-                let spans;
-                if (this._finishedSpans.length <= this._maxExportBatchSize) {
-                    spans = this._finishedSpans;
-                    this._finishedSpans = [];
-                }
-                else {
-                    spans = this._finishedSpans.splice(0, this._maxExportBatchSize);
-                }
-                const doExport = () => this._exporter.export(spans, result => {
-                    clearTimeout(timer);
-                    if (result.code === ExportResultCode.SUCCESS) {
-                        resolve();
-                    }
-                    else {
-                        reject(result.error ??
-                            new Error('BatchSpanProcessor: span export failed'));
-                    }
-                });
-                let pendingResources = null;
-                for (let i = 0, len = spans.length; i < len; i++) {
-                    const span = spans[i];
-                    if (span.resource.asyncAttributesPending &&
-                        span.resource.waitForAsyncAttributes) {
-                        pendingResources ??= [];
-                        pendingResources.push(span.resource.waitForAsyncAttributes());
-                    }
-                }
-                // Avoid scheduling a promise to make the behavior more predictable and easier to test
-                if (pendingResources === null) {
-                    doExport();
-                }
-                else {
-                    Promise.all(pendingResources).then(doExport, err => {
-                        globalErrorHandler(err);
-                        reject(err);
-                    });
-                }
-            });
-        });
-    }
-    _maybeStartTimer() {
-        if (this._isExporting)
-            return;
-        const flush = () => {
-            this._isExporting = true;
-            this._flushOneBatch()
-                .finally(() => {
-                this._isExporting = false;
-                if (this._finishedSpans.length > 0) {
-                    this._clearTimer();
-                    this._maybeStartTimer();
-                }
-            })
-                .catch(e => {
-                this._isExporting = false;
-                globalErrorHandler(e);
-            });
-        };
-        // we only wait if the queue doesn't have enough elements yet
-        if (this._finishedSpans.length >= this._maxExportBatchSize) {
-            return flush();
-        }
-        if (this._timer !== undefined)
-            return;
-        this._timer = setTimeout(() => flush(), this._scheduledDelayMillis);
-        // depending on runtime, this may be a 'number' or NodeJS.Timeout
-        if (typeof this._timer !== 'number') {
-            this._timer.unref();
-        }
-    }
-    _clearTimer() {
-        if (this._timer !== undefined) {
-            clearTimeout(this._timer);
-            this._timer = undefined;
-        }
-    }
-}
-//# sourceMappingURL=BatchSpanProcessorBase.js.map

package/node_modules/@opentelemetry/otlp-transformer/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ConsoleSpanExporter.js

@@ -1,73 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { ExportResultCode, hrTimeToMicroseconds, } from '@opentelemetry/core';
-/**
- * This is implementation of {@link SpanExporter} that prints spans to the
- * console. This class can be used for diagnostic purposes.
- *
- * NOTE: This {@link SpanExporter} is intended for diagnostics use only, output rendered to the console may change at any time.
- */
-/* eslint-disable no-console */
-export class ConsoleSpanExporter {
-    /**
-     * Export spans.
-     * @param spans
-     * @param resultCallback
-     */
-    export(spans, resultCallback) {
-        return this._sendSpans(spans, resultCallback);
-    }
-    /**
-     * Shutdown the exporter.
-     */
-    shutdown() {
-        this._sendSpans([]);
-        return this.forceFlush();
-    }
-    /**
-     * Exports any pending spans in exporter
-     */
-    forceFlush() {
-        return Promise.resolve();
-    }
-    /**
-     * converts span info into more readable format
-     * @param span
-     */
-    _exportInfo(span) {
-        return {
-            resource: {
-                attributes: span.resource.attributes,
-            },
-            instrumentationScope: span.instrumentationScope,
-            traceId: span.spanContext().traceId,
-            parentSpanContext: span.parentSpanContext,
-            traceState: span.spanContext().traceState?.serialize(),
-            name: span.name,
-            id: span.spanContext().spanId,
-            kind: span.kind,
-            timestamp: hrTimeToMicroseconds(span.startTime),
-            duration: hrTimeToMicroseconds(span.duration),
-            attributes: span.attributes,
-            status: span.status,
-            events: span.events,
-            links: span.links,
-        };
-    }
-    /**
-     * Showing spans in console
-     * @param spans
-     * @param done
-     */
-    _sendSpans(spans, done) {
-        for (const span of spans) {
-            console.dir(this._exportInfo(span), { depth: 3 });
-        }
-        if (done) {
-            return done({ code: ExportResultCode.SUCCESS });
-        }
-    }
-}
-//# sourceMappingURL=ConsoleSpanExporter.js.map

package/node_modules/@opentelemetry/otlp-transformer/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/InMemorySpanExporter.js

@@ -1,45 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { ExportResultCode } from '@opentelemetry/core';
-/**
- * This class can be used for testing purposes. It stores the exported spans
- * in a list in memory that can be retrieved using the `getFinishedSpans()`
- * method.
- */
-export class InMemorySpanExporter {
-    _finishedSpans = [];
-    /**
-     * Indicates if the exporter has been "shutdown."
-     * When false, exported spans will not be stored in-memory.
-     */
-    _stopped = false;
-    export(spans, resultCallback) {
-        if (this._stopped)
-            return resultCallback({
-                code: ExportResultCode.FAILED,
-                error: new Error('Exporter has been stopped'),
-            });
-        this._finishedSpans.push(...spans);
-        setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
-    }
-    shutdown() {
-        this._stopped = true;
-        this._finishedSpans = [];
-        return this.forceFlush();
-    }
-    /**
-     * Exports any pending spans in the exporter
-     */
-    forceFlush() {
-        return Promise.resolve();
-    }
-    reset() {
-        this._finishedSpans = [];
-    }
-    getFinishedSpans() {
-        return this._finishedSpans;
-    }
-}
-//# sourceMappingURL=InMemorySpanExporter.js.map

package/node_modules/@opentelemetry/otlp-transformer/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/NoopSpanProcessor.js

@@ -1,16 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-/** No-op implementation of SpanProcessor */
-export class NoopSpanProcessor {
-    onStart(_span, _context) { }
-    onEnd(_span) { }
-    shutdown() {
-        return Promise.resolve();
-    }
-    forceFlush() {
-        return Promise.resolve();
-    }
-}
-//# sourceMappingURL=NoopSpanProcessor.js.map

package/node_modules/@opentelemetry/otlp-transformer/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ReadableSpan.js

@@ -1,6 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-export {};
-//# sourceMappingURL=ReadableSpan.js.map