chinalife-otel-web-sdk 1.0.0

package/dist/index.umd.js

@@ -0,0 +1,1428 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@opentelemetry/api'), require('@opentelemetry/sdk-trace-web'), require('@opentelemetry/exporter-trace-otlp-http'), require('@opentelemetry/resources'), require('@opentelemetry/semantic-conventions'), require('@opentelemetry/instrumentation'), require('@opentelemetry/instrumentation-fetch'), require('@opentelemetry/instrumentation-xml-http-request'), require('@opentelemetry/instrumentation-document-load'), require('@opentelemetry/instrumentation-user-interaction'), require('@opentelemetry/instrumentation-long-task')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@opentelemetry/api', '@opentelemetry/sdk-trace-web', '@opentelemetry/exporter-trace-otlp-http', '@opentelemetry/resources', '@opentelemetry/semantic-conventions', '@opentelemetry/instrumentation', '@opentelemetry/instrumentation-fetch', '@opentelemetry/instrumentation-xml-http-request', '@opentelemetry/instrumentation-document-load', '@opentelemetry/instrumentation-user-interaction', '@opentelemetry/instrumentation-long-task'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.OTelSDK = {}, global.api, global.sdkTraceWeb, global.exporterTraceOtlpHttp, global.resources, global.semanticConventions, global.instrumentation, global.instrumentationFetch, global.instrumentationXmlHttpRequest, global.instrumentationDocumentLoad, global.instrumentationUserInteraction, global.instrumentationLongTask));
+})(this, (function (exports, api, sdkTraceWeb, exporterTraceOtlpHttp, resources, semanticConventions, instrumentation, instrumentationFetch, instrumentationXmlHttpRequest, instrumentationDocumentLoad, instrumentationUserInteraction, instrumentationLongTask) { 'use strict';
+
+    /**
+     * 默认配置
+     */
+    const DEFAULT_CONFIG = {
+        serviceName: 'unknown-service',
+        serviceVersion: '1.0.0',
+        environment: 'production',
+        datacenter: 'dc1',
+        collectorEndpoint: 'http://localhost:4318/v1/traces',
+        samplingRatio: 1.0,
+        enableAutoInstrumentation: true,
+        enableRouterTracing: true,
+        enableHttpTracing: true,
+        framework: 'h5',
+        batchConfig: {
+            maxQueueSize: 2048,
+            maxExportBatchSize: 512,
+            scheduledDelayMillis: 5000,
+            exportTimeoutMillis: 30000,
+        },
+        enableLocalStorage: false,
+        localStorageKey: 'otel_spans',
+        maxLocalStorageSize: 10240,
+        logLevel: 'info',
+        propagationFormat: 'w3c',
+    };
+    /**
+     * 从环境变量读取配置
+     */
+    function getEnvConfig() {
+        const config = {};
+        // 支持浏览器环境变量（通过 window 对象或 process.env）
+        // 注意：import.meta.env 需要在构建时由构建工具（如 Vite）注入
+        // 使用方应该通过配置选项或 window.__OTEL_CONFIG__ 传递环境变量
+        const getEnv = (key) => {
+            // 1. 尝试从 window.__OTEL_CONFIG__ 获取（推荐方式）
+            if (typeof window !== 'undefined') {
+                const win = window;
+                if (win.__OTEL_CONFIG__ && typeof win.__OTEL_CONFIG__ === 'object') {
+                    const value = win.__OTEL_CONFIG__[key];
+                    if (value !== undefined) {
+                        return String(value);
+                    }
+                }
+            }
+            // 2. 尝试从 process.env 获取（Node.js/Webpack 环境）
+            if (typeof process !== 'undefined' && process.env) {
+                const value = process.env[key];
+                if (value !== undefined) {
+                    return value;
+                }
+            }
+            // 3. 尝试从全局对象获取（某些构建工具可能会注入）
+            if (typeof globalThis !== 'undefined') {
+                const global = globalThis;
+                if (global.process?.env?.[key]) {
+                    return global.process.env[key];
+                }
+            }
+            return undefined;
+        };
+        // 获取环境变量（支持多种命名方式）
+        const serviceName = getEnv('OTEL_SERVICE_NAME') || getEnv('VITE_OTEL_SERVICE_NAME') || getEnv('REACT_APP_OTEL_SERVICE_NAME');
+        if (serviceName)
+            config.serviceName = serviceName;
+        const serviceVersion = getEnv('OTEL_SERVICE_VERSION') || getEnv('VITE_OTEL_SERVICE_VERSION') || getEnv('REACT_APP_OTEL_SERVICE_VERSION');
+        if (serviceVersion)
+            config.serviceVersion = serviceVersion;
+        const environment = getEnv('OTEL_DEPLOYMENT_ENVIRONMENT') || getEnv('VITE_OTEL_DEPLOYMENT_ENVIRONMENT') || getEnv('REACT_APP_OTEL_DEPLOYMENT_ENVIRONMENT');
+        if (environment)
+            config.environment = environment;
+        const datacenter = getEnv('OTEL_DATACENTER') || getEnv('VITE_OTEL_DATACENTER') || getEnv('REACT_APP_OTEL_DATACENTER');
+        if (datacenter)
+            config.datacenter = datacenter;
+        const collectorEndpoint = getEnv('OTEL_EXPORTER_OTLP_ENDPOINT') ||
+            getEnv('OTEL_EXPORTER_OTLP_TRACES_ENDPOINT') ||
+            getEnv('VITE_OTEL_COLLECTOR_ENDPOINT') ||
+            getEnv('VITE_OTEL_EXPORTER_OTLP_ENDPOINT') ||
+            getEnv('REACT_APP_OTEL_COLLECTOR_ENDPOINT');
+        if (collectorEndpoint)
+            config.collectorEndpoint = collectorEndpoint;
+        const samplingRatio = getEnv('OTEL_SAMPLING_RATIO') || getEnv('VITE_OTEL_SAMPLING_RATIO') || getEnv('REACT_APP_OTEL_SAMPLING_RATIO');
+        if (samplingRatio) {
+            const ratio = parseFloat(samplingRatio);
+            if (!isNaN(ratio))
+                config.samplingRatio = ratio;
+        }
+        const logLevel = getEnv('OTEL_LOG_LEVEL') || getEnv('VITE_OTEL_LOG_LEVEL') || getEnv('REACT_APP_OTEL_LOG_LEVEL');
+        if (logLevel) {
+            const level = logLevel.toLowerCase();
+            if (['debug', 'info', 'warn', 'error'].includes(level)) {
+                config.logLevel = level;
+            }
+        }
+        // 获取传播协议格式
+        const propagationFormat = getEnv('OTEL_PROPAGATION_FORMAT') ||
+            getEnv('OTEL_PROPAGATORS') ||
+            getEnv('VITE_OTEL_PROPAGATION_FORMAT') ||
+            getEnv('REACT_APP_OTEL_PROPAGATION_FORMAT');
+        if (propagationFormat) {
+            // 支持逗号分隔的多个格式
+            const formats = propagationFormat.split(',').map(f => f.trim()).filter(f => f);
+            if (formats.length > 0) {
+                // 类型断言：单个格式或格式数组
+                config.propagationFormat = (formats.length === 1 ? formats[0] : formats);
+            }
+        }
+        return config;
+    }
+    /**
+     * 合并配置
+     */
+    function mergeConfig(options) {
+        const envConfig = getEnvConfig();
+        const merged = {
+            ...DEFAULT_CONFIG,
+            ...envConfig,
+            ...options,
+        };
+        // 如果用户明确配置了 propagationFormat，确保不被默认值覆盖
+        if (options?.propagationFormat !== undefined) {
+            merged.propagationFormat = options.propagationFormat;
+        }
+        else if (envConfig.propagationFormat !== undefined) {
+            merged.propagationFormat = envConfig.propagationFormat;
+        }
+        // 合并批量配置
+        if (options?.batchConfig || envConfig.batchConfig) {
+            merged.batchConfig = {
+                ...DEFAULT_CONFIG.batchConfig,
+                ...envConfig.batchConfig,
+                ...options?.batchConfig,
+            };
+        }
+        // 根据数据中心选择 Collector 端点
+        if (merged.datacenter && !options?.collectorEndpoint && !envConfig.collectorEndpoint) {
+            const datacenterEndpoints = {
+                dc1: 'http://collector-dc1.otel.svc.cluster.local:4318/v1/traces',
+                dc2: 'http://collector-dc2.otel.svc.cluster.local:4318/v1/traces',
+                dc3: 'http://collector-dc3.otel.svc.cluster.local:4318/v1/traces',
+            };
+            if (datacenterEndpoints[merged.datacenter]) {
+                merged.collectorEndpoint = datacenterEndpoints[merged.datacenter];
+            }
+        }
+        return merged;
+    }
+    /**
+     * 日志工具
+     */
+    class Logger {
+        constructor(level = 'info') {
+            this.level = level;
+        }
+        setLevel(level) {
+            this.level = level;
+        }
+        shouldLog(level) {
+            const levels = ['debug', 'info', 'warn', 'error'];
+            return levels.indexOf(level) >= levels.indexOf(this.level);
+        }
+        debug(...args) {
+            if (this.shouldLog('debug')) {
+                console.debug('[OTel SDK]', ...args);
+            }
+        }
+        info(...args) {
+            if (this.shouldLog('info')) {
+                console.info('[OTel SDK]', ...args);
+            }
+        }
+        warn(...args) {
+            if (this.shouldLog('warn')) {
+                console.warn('[OTel SDK]', ...args);
+            }
+        }
+        error(...args) {
+            if (this.shouldLog('error')) {
+                console.error('[OTel SDK]', ...args);
+            }
+        }
+    }
+
+    /**
+     * 创建自动 instrumentation 配置
+     */
+    function createInstrumentations(options) {
+        const instrumentations = [];
+        if (!options.enableAutoInstrumentation) {
+            return instrumentations;
+        }
+        // HTTP 追踪
+        if (options.enableHttpTracing) {
+            // Fetch API
+            instrumentations.push(new instrumentationFetch.FetchInstrumentation({
+                propagateTraceHeaderCorsUrls: [/^https?:\/\/.*/],
+                clearTimingResources: true,
+            }));
+            // XMLHttpRequest
+            instrumentations.push(new instrumentationXmlHttpRequest.XMLHttpRequestInstrumentation({
+                propagateTraceHeaderCorsUrls: [/^https?:\/\/.*/],
+                clearTimingResources: true,
+            }));
+        }
+        // 文档加载追踪
+        instrumentations.push(new instrumentationDocumentLoad.DocumentLoadInstrumentation());
+        // 用户交互追踪
+        instrumentations.push(new instrumentationUserInteraction.UserInteractionInstrumentation({
+            enabled: true,
+        }));
+        // 长任务追踪
+        instrumentations.push(new instrumentationLongTask.LongTaskInstrumentation({
+            enabled: true,
+        }));
+        return instrumentations;
+    }
+    /**
+     * Vue Router instrumentation（如果使用 Vue）
+     */
+    function setupVueRouterInstrumentation(router, tracer) {
+        if (!router || !tracer) {
+            return;
+        }
+        // 监听路由变化
+        router.beforeEach((to, from, next) => {
+            const span = tracer.startSpan('route_change', {
+                attributes: {
+                    'route.from': from.path,
+                    'route.to': to.path,
+                    'route.name': to.name || 'unknown',
+                },
+            });
+            // 将 span 存储到路由元信息中
+            to.__otel_span__ = span;
+            next();
+        });
+        router.afterEach((to) => {
+            const span = to.__otel_span__;
+            if (span) {
+                span.setStatus({ code: 1 }); // OK
+                span.end();
+                delete to.__otel_span__;
+            }
+        });
+    }
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    var SUPPRESS_TRACING_KEY = api.createContextKey('OpenTelemetry SDK Context Key SUPPRESS_TRACING');
+    function isTracingSuppressed(context) {
+        return context.getValue(SUPPRESS_TRACING_KEY) === true;
+    }
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    var __values = (undefined && undefined.__values) || function(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    };
+    /** Combines multiple propagators into a single propagator. */
+    var CompositePropagator = /** @class */ (function () {
+        /**
+         * Construct a composite propagator from a list of propagators.
+         *
+         * @param [config] Configuration object for composite propagator
+         */
+        function CompositePropagator(config) {
+            if (config === void 0) { config = {}; }
+            var _a;
+            this._propagators = (_a = config.propagators) !== null && _a !== void 0 ? _a : [];
+            this._fields = Array.from(new Set(this._propagators
+                // older propagators may not have fields function, null check to be sure
+                .map(function (p) { return (typeof p.fields === 'function' ? p.fields() : []); })
+                .reduce(function (x, y) { return x.concat(y); }, [])));
+        }
+        /**
+         * Run each of the configured propagators with the given context and carrier.
+         * Propagators are run in the order they are configured, so if multiple
+         * propagators write the same carrier key, the propagator later in the list
+         * will "win".
+         *
+         * @param context Context to inject
+         * @param carrier Carrier into which context will be injected
+         */
+        CompositePropagator.prototype.inject = function (context, carrier, setter) {
+            var e_1, _a;
+            try {
+                for (var _b = __values(this._propagators), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var propagator = _c.value;
+                    try {
+                        propagator.inject(context, carrier, setter);
+                    }
+                    catch (err) {
+                        api.diag.warn("Failed to inject with " + propagator.constructor.name + ". Err: " + err.message);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        /**
+         * Run each of the configured propagators with the given context and carrier.
+         * Propagators are run in the order they are configured, so if multiple
+         * propagators write the same context key, the propagator later in the list
+         * will "win".
+         *
+         * @param context Context to add values to
+         * @param carrier Carrier from which to extract context
+         */
+        CompositePropagator.prototype.extract = function (context, carrier, getter) {
+            return this._propagators.reduce(function (ctx, propagator) {
+                try {
+                    return propagator.extract(ctx, carrier, getter);
+                }
+                catch (err) {
+                    api.diag.warn("Failed to extract with " + propagator.constructor.name + ". Err: " + err.message);
+                }
+                return ctx;
+            }, context);
+        };
+        CompositePropagator.prototype.fields = function () {
+            // return a new array so our fields cannot be modified
+            return this._fields.slice();
+        };
+        return CompositePropagator;
+    }());
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    var VALID_KEY_CHAR_RANGE = '[_0-9a-z-*/]';
+    var VALID_KEY = "[a-z]" + VALID_KEY_CHAR_RANGE + "{0,255}";
+    var VALID_VENDOR_KEY = "[a-z0-9]" + VALID_KEY_CHAR_RANGE + "{0,240}@[a-z]" + VALID_KEY_CHAR_RANGE + "{0,13}";
+    var VALID_KEY_REGEX = new RegExp("^(?:" + VALID_KEY + "|" + VALID_VENDOR_KEY + ")$");
+    var VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+    var INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+    /**
+     * Key is opaque string up to 256 characters printable. It MUST begin with a
+     * lowercase letter, and can only contain lowercase letters a-z, digits 0-9,
+     * underscores _, dashes -, asterisks *, and forward slashes /.
+     * For multi-tenant vendor scenarios, an at sign (@) can be used to prefix the
+     * vendor name. Vendors SHOULD set the tenant ID at the beginning of the key.
+     * see https://www.w3.org/TR/trace-context/#key
+     */
+    function validateKey(key) {
+        return VALID_KEY_REGEX.test(key);
+    }
+    /**
+     * Value is opaque string up to 256 characters printable ASCII RFC0020
+     * characters (i.e., the range 0x20 to 0x7E) except comma , and =.
+     */
+    function validateValue(value) {
+        return (VALID_VALUE_BASE_REGEX.test(value) &&
+            !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value));
+    }
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    var MAX_TRACE_STATE_ITEMS = 32;
+    var MAX_TRACE_STATE_LEN = 512;
+    var LIST_MEMBERS_SEPARATOR = ',';
+    var LIST_MEMBER_KEY_VALUE_SPLITTER = '=';
+    /**
+     * TraceState must be a class and not a simple object type because of the spec
+     * requirement (https://www.w3.org/TR/trace-context/#tracestate-field).
+     *
+     * Here is the list of allowed mutations:
+     * - New key-value pair should be added into the beginning of the list
+     * - The value of any key can be updated. Modified keys MUST be moved to the
+     * beginning of the list.
+     */
+    var TraceState = /** @class */ (function () {
+        function TraceState(rawTraceState) {
+            this._internalState = new Map();
+            if (rawTraceState)
+                this._parse(rawTraceState);
+        }
+        TraceState.prototype.set = function (key, value) {
+            // TODO: Benchmark the different approaches(map vs list) and
+            // use the faster one.
+            var traceState = this._clone();
+            if (traceState._internalState.has(key)) {
+                traceState._internalState.delete(key);
+            }
+            traceState._internalState.set(key, value);
+            return traceState;
+        };
+        TraceState.prototype.unset = function (key) {
+            var traceState = this._clone();
+            traceState._internalState.delete(key);
+            return traceState;
+        };
+        TraceState.prototype.get = function (key) {
+            return this._internalState.get(key);
+        };
+        TraceState.prototype.serialize = function () {
+            var _this = this;
+            return this._keys()
+                .reduce(function (agg, key) {
+                agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + _this.get(key));
+                return agg;
+            }, [])
+                .join(LIST_MEMBERS_SEPARATOR);
+        };
+        TraceState.prototype._parse = function (rawTraceState) {
+            if (rawTraceState.length > MAX_TRACE_STATE_LEN)
+                return;
+            this._internalState = rawTraceState
+                .split(LIST_MEMBERS_SEPARATOR)
+                .reverse() // Store in reverse so new keys (.set(...)) will be placed at the beginning
+                .reduce(function (agg, part) {
+                var listMember = part.trim(); // Optional Whitespace (OWS) handling
+                var i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+                if (i !== -1) {
+                    var key = listMember.slice(0, i);
+                    var value = listMember.slice(i + 1, part.length);
+                    if (validateKey(key) && validateValue(value)) {
+                        agg.set(key, value);
+                    }
+                }
+                return agg;
+            }, new Map());
+            // Because of the reverse() requirement, trunc must be done after map is created
+            if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
+                this._internalState = new Map(Array.from(this._internalState.entries())
+                    .reverse() // Use reverse same as original tracestate parse chain
+                    .slice(0, MAX_TRACE_STATE_ITEMS));
+            }
+        };
+        TraceState.prototype._keys = function () {
+            return Array.from(this._internalState.keys()).reverse();
+        };
+        TraceState.prototype._clone = function () {
+            var traceState = new TraceState();
+            traceState._internalState = new Map(this._internalState);
+            return traceState;
+        };
+        return TraceState;
+    }());
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    var TRACE_PARENT_HEADER = 'traceparent';
+    var TRACE_STATE_HEADER = 'tracestate';
+    var VERSION = '00';
+    var VERSION_PART = '(?!ff)[\\da-f]{2}';
+    var TRACE_ID_PART = '(?![0]{32})[\\da-f]{32}';
+    var PARENT_ID_PART = '(?![0]{16})[\\da-f]{16}';
+    var FLAGS_PART = '[\\da-f]{2}';
+    var TRACE_PARENT_REGEX = new RegExp("^\\s?(" + VERSION_PART + ")-(" + TRACE_ID_PART + ")-(" + PARENT_ID_PART + ")-(" + FLAGS_PART + ")(-.*)?\\s?$");
+    /**
+     * Parses information from the [traceparent] span tag and converts it into {@link SpanContext}
+     * @param traceParent - A meta property that comes from server.
+     *     It should be dynamically generated server side to have the server's request trace Id,
+     *     a parent span Id that was set on the server's request span,
+     *     and the trace flags to indicate the server's sampling decision
+     *     (01 = sampled, 00 = not sampled).
+     *     for example: '{version}-{traceId}-{spanId}-{sampleDecision}'
+     *     For more information see {@link https://www.w3.org/TR/trace-context/}
+     */
+    function parseTraceParent(traceParent) {
+        var match = TRACE_PARENT_REGEX.exec(traceParent);
+        if (!match)
+            return null;
+        // According to the specification the implementation should be compatible
+        // with future versions. If there are more parts, we only reject it if it's using version 00
+        // See https://www.w3.org/TR/trace-context/#versioning-of-traceparent
+        if (match[1] === '00' && match[5])
+            return null;
+        return {
+            traceId: match[2],
+            spanId: match[3],
+            traceFlags: parseInt(match[4], 16),
+        };
+    }
+    /**
+     * Propagates {@link SpanContext} through Trace Context format propagation.
+     *
+     * Based on the Trace Context specification:
+     * https://www.w3.org/TR/trace-context/
+     */
+    var W3CTraceContextPropagator = /** @class */ (function () {
+        function W3CTraceContextPropagator() {
+        }
+        W3CTraceContextPropagator.prototype.inject = function (context, carrier, setter) {
+            var spanContext = api.trace.getSpanContext(context);
+            if (!spanContext ||
+                isTracingSuppressed(context) ||
+                !api.isSpanContextValid(spanContext))
+                return;
+            var traceParent = VERSION + "-" + spanContext.traceId + "-" + spanContext.spanId + "-0" + Number(spanContext.traceFlags || api.TraceFlags.NONE).toString(16);
+            setter.set(carrier, TRACE_PARENT_HEADER, traceParent);
+            if (spanContext.traceState) {
+                setter.set(carrier, TRACE_STATE_HEADER, spanContext.traceState.serialize());
+            }
+        };
+        W3CTraceContextPropagator.prototype.extract = function (context, carrier, getter) {
+            var traceParentHeader = getter.get(carrier, TRACE_PARENT_HEADER);
+            if (!traceParentHeader)
+                return context;
+            var traceParent = Array.isArray(traceParentHeader)
+                ? traceParentHeader[0]
+                : traceParentHeader;
+            if (typeof traceParent !== 'string')
+                return context;
+            var spanContext = parseTraceParent(traceParent);
+            if (!spanContext)
+                return context;
+            spanContext.isRemote = true;
+            var traceStateHeader = getter.get(carrier, TRACE_STATE_HEADER);
+            if (traceStateHeader) {
+                // If more than one `tracestate` header is found, we merge them into a
+                // single header.
+                var state = Array.isArray(traceStateHeader)
+                    ? traceStateHeader.join(',')
+                    : traceStateHeader;
+                spanContext.traceState = new TraceState(typeof state === 'string' ? state : undefined);
+            }
+            return api.trace.setSpanContext(context, spanContext);
+        };
+        W3CTraceContextPropagator.prototype.fields = function () {
+            return [TRACE_PARENT_HEADER, TRACE_STATE_HEADER];
+        };
+        return W3CTraceContextPropagator;
+    }());
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    /** shared context for storing an extracted b3 debug flag */
+    var B3_DEBUG_FLAG_KEY = api.createContextKey('OpenTelemetry Context Key B3 Debug Flag');
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    /** B3 single-header key */
+    var B3_CONTEXT_HEADER = 'b3';
+    /* b3 multi-header keys */
+    var X_B3_TRACE_ID = 'x-b3-traceid';
+    var X_B3_SPAN_ID = 'x-b3-spanid';
+    var X_B3_SAMPLED = 'x-b3-sampled';
+    var X_B3_PARENT_SPAN_ID = 'x-b3-parentspanid';
+    var X_B3_FLAGS = 'x-b3-flags';
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    var VALID_SAMPLED_VALUES = new Set([true, 'true', 'True', '1', 1]);
+    var VALID_UNSAMPLED_VALUES = new Set([false, 'false', 'False', '0', 0]);
+    function isValidSampledValue(sampled) {
+        return sampled === api.TraceFlags.SAMPLED || sampled === api.TraceFlags.NONE;
+    }
+    function parseHeader(header) {
+        return Array.isArray(header) ? header[0] : header;
+    }
+    function getHeaderValue(carrier, getter, key) {
+        var header = getter.get(carrier, key);
+        return parseHeader(header);
+    }
+    function getTraceId(carrier, getter) {
+        var traceId = getHeaderValue(carrier, getter, X_B3_TRACE_ID);
+        if (typeof traceId === 'string') {
+            return traceId.padStart(32, '0');
+        }
+        return '';
+    }
+    function getSpanId(carrier, getter) {
+        var spanId = getHeaderValue(carrier, getter, X_B3_SPAN_ID);
+        if (typeof spanId === 'string') {
+            return spanId;
+        }
+        return '';
+    }
+    function getDebug(carrier, getter) {
+        var debug = getHeaderValue(carrier, getter, X_B3_FLAGS);
+        return debug === '1' ? '1' : undefined;
+    }
+    function getTraceFlags(carrier, getter) {
+        var traceFlags = getHeaderValue(carrier, getter, X_B3_SAMPLED);
+        var debug = getDebug(carrier, getter);
+        if (debug === '1' || VALID_SAMPLED_VALUES.has(traceFlags)) {
+            return api.TraceFlags.SAMPLED;
+        }
+        if (traceFlags === undefined || VALID_UNSAMPLED_VALUES.has(traceFlags)) {
+            return api.TraceFlags.NONE;
+        }
+        // This indicates to isValidSampledValue that this is not valid
+        return;
+    }
+    /**
+     * Propagator for the B3 multiple-header HTTP format.
+     * Based on: https://github.com/openzipkin/b3-propagation
+     */
+    var B3MultiPropagator = /** @class */ (function () {
+        function B3MultiPropagator() {
+        }
+        B3MultiPropagator.prototype.inject = function (context, carrier, setter) {
+            var spanContext = api.trace.getSpanContext(context);
+            if (!spanContext ||
+                !api.isSpanContextValid(spanContext) ||
+                isTracingSuppressed(context))
+                return;
+            var debug = context.getValue(B3_DEBUG_FLAG_KEY);
+            setter.set(carrier, X_B3_TRACE_ID, spanContext.traceId);
+            setter.set(carrier, X_B3_SPAN_ID, spanContext.spanId);
+            // According to the B3 spec, if the debug flag is set,
+            // the sampled flag shouldn't be propagated as well.
+            if (debug === '1') {
+                setter.set(carrier, X_B3_FLAGS, debug);
+            }
+            else if (spanContext.traceFlags !== undefined) {
+                // We set the header only if there is an existing sampling decision.
+                // Otherwise we will omit it => Absent.
+                setter.set(carrier, X_B3_SAMPLED, (api.TraceFlags.SAMPLED & spanContext.traceFlags) === api.TraceFlags.SAMPLED
+                    ? '1'
+                    : '0');
+            }
+        };
+        B3MultiPropagator.prototype.extract = function (context, carrier, getter) {
+            var traceId = getTraceId(carrier, getter);
+            var spanId = getSpanId(carrier, getter);
+            var traceFlags = getTraceFlags(carrier, getter);
+            var debug = getDebug(carrier, getter);
+            if (api.isValidTraceId(traceId) &&
+                api.isValidSpanId(spanId) &&
+                isValidSampledValue(traceFlags)) {
+                context = context.setValue(B3_DEBUG_FLAG_KEY, debug);
+                return api.trace.setSpanContext(context, {
+                    traceId: traceId,
+                    spanId: spanId,
+                    isRemote: true,
+                    traceFlags: traceFlags,
+                });
+            }
+            return context;
+        };
+        B3MultiPropagator.prototype.fields = function () {
+            return [
+                X_B3_TRACE_ID,
+                X_B3_SPAN_ID,
+                X_B3_FLAGS,
+                X_B3_SAMPLED,
+                X_B3_PARENT_SPAN_ID,
+            ];
+        };
+        return B3MultiPropagator;
+    }());
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    var __read = (undefined && undefined.__read) || function (o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    };
+    var B3_CONTEXT_REGEX = /((?:[0-9a-f]{16}){1,2})-([0-9a-f]{16})(?:-([01d](?![0-9a-f])))?(?:-([0-9a-f]{16}))?/;
+    var PADDING = '0'.repeat(16);
+    var SAMPLED_VALUES = new Set(['d', '1']);
+    var DEBUG_STATE = 'd';
+    function convertToTraceId128(traceId) {
+        return traceId.length === 32 ? traceId : "" + PADDING + traceId;
+    }
+    function convertToTraceFlags(samplingState) {
+        if (samplingState && SAMPLED_VALUES.has(samplingState)) {
+            return api.TraceFlags.SAMPLED;
+        }
+        return api.TraceFlags.NONE;
+    }
+    /**
+     * Propagator for the B3 single-header HTTP format.
+     * Based on: https://github.com/openzipkin/b3-propagation
+     */
+    var B3SinglePropagator = /** @class */ (function () {
+        function B3SinglePropagator() {
+        }
+        B3SinglePropagator.prototype.inject = function (context, carrier, setter) {
+            var spanContext = api.trace.getSpanContext(context);
+            if (!spanContext ||
+                !api.isSpanContextValid(spanContext) ||
+                isTracingSuppressed(context))
+                return;
+            var samplingState = context.getValue(B3_DEBUG_FLAG_KEY) || spanContext.traceFlags & 0x1;
+            var value = spanContext.traceId + "-" + spanContext.spanId + "-" + samplingState;
+            setter.set(carrier, B3_CONTEXT_HEADER, value);
+        };
+        B3SinglePropagator.prototype.extract = function (context, carrier, getter) {
+            var header = getter.get(carrier, B3_CONTEXT_HEADER);
+            var b3Context = Array.isArray(header) ? header[0] : header;
+            if (typeof b3Context !== 'string')
+                return context;
+            var match = b3Context.match(B3_CONTEXT_REGEX);
+            if (!match)
+                return context;
+            var _a = __read(match, 4), extractedTraceId = _a[1], spanId = _a[2], samplingState = _a[3];
+            var traceId = convertToTraceId128(extractedTraceId);
+            if (!api.isValidTraceId(traceId) || !api.isValidSpanId(spanId))
+                return context;
+            var traceFlags = convertToTraceFlags(samplingState);
+            if (samplingState === DEBUG_STATE) {
+                context = context.setValue(B3_DEBUG_FLAG_KEY, samplingState);
+            }
+            return api.trace.setSpanContext(context, {
+                traceId: traceId,
+                spanId: spanId,
+                isRemote: true,
+                traceFlags: traceFlags,
+            });
+        };
+        B3SinglePropagator.prototype.fields = function () {
+            return [B3_CONTEXT_HEADER];
+        };
+        return B3SinglePropagator;
+    }());
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    /** Enumeration of B3 inject encodings */
+    var B3InjectEncoding;
+    (function (B3InjectEncoding) {
+        B3InjectEncoding[B3InjectEncoding["SINGLE_HEADER"] = 0] = "SINGLE_HEADER";
+        B3InjectEncoding[B3InjectEncoding["MULTI_HEADER"] = 1] = "MULTI_HEADER";
+    })(B3InjectEncoding || (B3InjectEncoding = {}));
+
+    /*
+     * Copyright The OpenTelemetry Authors
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *      https://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    /**
+     * Propagator that extracts B3 context in both single and multi-header variants,
+     * with configurable injection format defaulting to B3 single-header. Due to
+     * the asymmetry in injection and extraction formats this is not suitable to
+     * be implemented as a composite propagator.
+     * Based on: https://github.com/openzipkin/b3-propagation
+     */
+    var B3Propagator = /** @class */ (function () {
+        function B3Propagator(config) {
+            if (config === void 0) { config = {}; }
+            this._b3MultiPropagator = new B3MultiPropagator();
+            this._b3SinglePropagator = new B3SinglePropagator();
+            if (config.injectEncoding === B3InjectEncoding.MULTI_HEADER) {
+                this._inject = this._b3MultiPropagator.inject;
+                this._fields = this._b3MultiPropagator.fields();
+            }
+            else {
+                this._inject = this._b3SinglePropagator.inject;
+                this._fields = this._b3SinglePropagator.fields();
+            }
+        }
+        B3Propagator.prototype.inject = function (context, carrier, setter) {
+            if (isTracingSuppressed(context)) {
+                return;
+            }
+            this._inject(context, carrier, setter);
+        };
+        B3Propagator.prototype.extract = function (context, carrier, getter) {
+            var header = getter.get(carrier, B3_CONTEXT_HEADER);
+            var b3Context = Array.isArray(header) ? header[0] : header;
+            if (b3Context) {
+                return this._b3SinglePropagator.extract(context, carrier, getter);
+            }
+            else {
+                return this._b3MultiPropagator.extract(context, carrier, getter);
+            }
+        };
+        B3Propagator.prototype.fields = function () {
+            return this._fields;
+        };
+        return B3Propagator;
+    }());
+
+    /**
+     * Pinpoint 传播器实现
+     * Pinpoint TraceId 格式：serviceName^毫秒时间戳^序列号
+     * 例如：my-service^1704067200000^1
+     *
+     * Pinpoint 使用以下头部：
+     * - Pinpoint-TraceId (serviceName^毫秒时间戳^序列号)
+     * - Pinpoint-SpanId (8字节十六进制)
+     * - Pinpoint-ParentSpanId (8字节十六进制，可选)
+     * - Pinpoint-Sampled (1 或 0)
+     * - Pinpoint-Flags (通常为 0)
+     */
+    class PinpointPropagator {
+        constructor(serviceName = 'unknown-service') {
+            this.FIELDS = [
+                'Pinpoint-TraceId',
+                'Pinpoint-SpanId',
+                'Pinpoint-ParentSpanId',
+                'Pinpoint-Sampled',
+                'Pinpoint-Flags',
+            ];
+            this.sequenceCounter = 0;
+            this.lastTimestamp = 0;
+            this.serviceName = serviceName;
+        }
+        fields() {
+            return [...this.FIELDS];
+        }
+        /**
+         * 生成 Pinpoint 格式的 TraceId: serviceName^毫秒时间戳^序列号
+         */
+        generatePinpointTraceId() {
+            const now = Date.now();
+            // 如果时间戳改变，重置序列号
+            if (now !== this.lastTimestamp) {
+                this.sequenceCounter = 0;
+                this.lastTimestamp = now;
+            }
+            // 序列号递增
+            this.sequenceCounter++;
+            // 格式：serviceName^毫秒时间戳^序列号
+            return `${this.serviceName}^${now}^${this.sequenceCounter}`;
+        }
+        /**
+         * 将字符串转换为十六进制（用于 extract 时转换）
+         */
+        stringToHex(str) {
+            let hex = '';
+            for (let i = 0; i < str.length; i++) {
+                const charCode = str.charCodeAt(i);
+                hex += charCode.toString(16).padStart(2, '0');
+            }
+            return hex;
+        }
+        inject(context, carrier, setter) {
+            // 从 context 中获取当前活动的 span
+            const span = api.trace.getSpan(context);
+            if (!span) {
+                return;
+            }
+            const spanContext = span.spanContext();
+            if (!spanContext || spanContext.traceId === '00000000000000000000000000000000') {
+                return;
+            }
+            const { spanId, traceFlags } = spanContext;
+            // 生成 Pinpoint 格式的 TraceId: serviceName^毫秒时间戳^序列号
+            const pinpointTraceId = this.generatePinpointTraceId();
+            // 将 Pinpoint traceId 添加到 span 属性中，这样在导出时会包含在 traces 数据中
+            span.setAttribute('pinpoint.trace_id', pinpointTraceId);
+            setter.set(carrier, 'Pinpoint-TraceId', pinpointTraceId);
+            setter.set(carrier, 'Pinpoint-SpanId', spanId);
+            setter.set(carrier, 'Pinpoint-Sampled', traceFlags === api.TraceFlags.SAMPLED ? '1' : '0');
+            setter.set(carrier, 'Pinpoint-Flags', '0');
+        }
+        extract(context, carrier, getter) {
+            const traceId = getter.get(carrier, 'Pinpoint-TraceId');
+            const spanId = getter.get(carrier, 'Pinpoint-SpanId');
+            const sampled = getter.get(carrier, 'Pinpoint-Sampled');
+            if (!traceId || !spanId) {
+                return context;
+            }
+            // Pinpoint TraceId 格式：serviceName^毫秒时间戳^序列号
+            // 需要转换为 OpenTelemetry 的 32 字符十六进制格式
+            let otelTraceId;
+            if (traceId.includes('^')) {
+                // Pinpoint 格式，需要转换
+                // 使用哈希方式：将字符串转换为十六进制
+                const hash = this.stringToHex(traceId);
+                // 确保是 32 字符（如果超过则截取，如果不足则补0）
+                otelTraceId = hash.length >= 32
+                    ? hash.substring(0, 32)
+                    : hash.padEnd(32, '0');
+            }
+            else {
+                // 可能是旧的十六进制格式，直接使用
+                otelTraceId = traceId.length === 16
+                    ? '0000000000000000' + traceId
+                    : traceId.padStart(32, '0').substring(0, 32);
+            }
+            const spanContext = {
+                traceId: otelTraceId,
+                spanId: spanId,
+                traceFlags: sampled === '1' ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE,
+                isRemote: true,
+            };
+            // 使用 trace API 设置 span context
+            return api.trace.setSpanContext(context, spanContext);
+        }
+    }
+    /**
+     * 创建传播器
+     */
+    function createPropagators(options) {
+        const propagators = [];
+        // 注意：如果用户明确配置了 propagationFormat，不应该使用默认值
+        const formats = options.propagationFormat !== undefined
+            ? options.propagationFormat
+            : 'w3c';
+        // 处理单个格式或格式数组
+        const formatList = Array.isArray(formats) ? formats : [formats];
+        for (const format of formatList) {
+            const formatLower = format.toLowerCase();
+            switch (formatLower) {
+                case 'w3c':
+                    propagators.push(new W3CTraceContextPropagator());
+                    break;
+                case 'b3':
+                case 'b3multi':
+                    // B3 多头部格式
+                    propagators.push(new B3Propagator({
+                        injectEncoding: B3InjectEncoding.MULTI_HEADER,
+                    }));
+                    break;
+                case 'pinpoint':
+                    // 传递 serviceName 给 PinpointPropagator
+                    propagators.push(new PinpointPropagator(options.serviceName || 'unknown-service'));
+                    break;
+                default:
+                    // 未知格式，使用 W3C 作为后备
+                    propagators.push(new W3CTraceContextPropagator());
+            }
+        }
+        // 添加自定义传播器
+        if (options.propagators?.customPropagators) {
+            propagators.push(...options.propagators.customPropagators);
+        }
+        // 如果只有一个传播器，直接返回；否则使用组合传播器
+        if (propagators.length === 0) {
+            return new W3CTraceContextPropagator();
+        }
+        else if (propagators.length === 1) {
+            return propagators[0];
+        }
+        else {
+            // 使用 CompositePropagator 组合多个传播器
+            return new CompositePropagator({
+                propagators: propagators,
+            });
+        }
+    }
+
+    /**
+     * SDK 实例
+     */
+    class OTelSDK {
+        constructor() {
+            this.provider = null;
+            this.tracer = null;
+            this.config = null;
+            this.initialized = false;
+            this.logger = new Logger('info');
+        }
+        /**
+         * 初始化 SDK
+         */
+        init(options) {
+            if (this.initialized) {
+                this.logger.warn('SDK already initialized, skipping...');
+                return;
+            }
+            try {
+                this.config = mergeConfig(options);
+                this.logger.setLevel(this.config.logLevel || 'info');
+                this.logger.debug('Initializing SDK with config:', this.config);
+                // 1. 创建资源
+                const resource = resources.resourceFromAttributes({
+                    [semanticConventions.ATTR_SERVICE_NAME]: this.config.serviceName || 'unknown-service',
+                    [semanticConventions.ATTR_SERVICE_VERSION]: this.config.serviceVersion || '1.0.0',
+                    'deployment.environment': this.config.environment || 'production',
+                    'datacenter': this.config.datacenter || 'dc1',
+                });
+                // 2. 创建 OTLP exporter
+                const exporter = new exporterTraceOtlpHttp.OTLPTraceExporter({
+                    url: this.config.collectorEndpoint,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+                // 3. 创建 BatchSpanProcessor
+                const batchConfig = this.config.batchConfig || {};
+                const spanProcessor = new sdkTraceWeb.BatchSpanProcessor(exporter, {
+                    maxQueueSize: batchConfig.maxQueueSize || 2048,
+                    maxExportBatchSize: batchConfig.maxExportBatchSize || 512,
+                    scheduledDelayMillis: batchConfig.scheduledDelayMillis || 5000,
+                    exportTimeoutMillis: batchConfig.exportTimeoutMillis || 30000,
+                });
+                // 4. 创建传播器（在 provider 注册之前）
+                const propagator = createPropagators(this.config);
+                const propagationFormat = Array.isArray(this.config.propagationFormat)
+                    ? this.config.propagationFormat.join(',')
+                    : (this.config.propagationFormat || 'w3c');
+                this.logger.debug(`Propagation format: ${propagationFormat}`);
+                // 5. 先设置全局传播器（必须在 provider.register() 之前）
+                // 这样可以确保 provider.register() 不会覆盖我们的传播器设置
+                api.propagation.setGlobalPropagator(propagator);
+                this.logger.debug(`Global propagator set with ${propagationFormat} format(s)`);
+                // 6. 创建 TracerProvider
+                this.provider = new sdkTraceWeb.WebTracerProvider({
+                    resource: resource,
+                    spanProcessors: [spanProcessor],
+                });
+                // 7. 注册 provider（此时全局传播器已经设置，不会被覆盖）
+                this.provider.register();
+                // 8. Provider 已注册，传播器已设置
+                // 9. 获取 tracer
+                this.tracer = this.provider.getTracer(this.config.serviceName || 'unknown-service', this.config.serviceVersion || '1.0.0');
+                // 10. 注册自动 instrumentation（传播器已设置，instrumentation 会使用全局传播器）
+                if (this.config.enableAutoInstrumentation) {
+                    const instrumentations = createInstrumentations(this.config);
+                    if (instrumentations.length > 0) {
+                        instrumentation.registerInstrumentations({
+                            instrumentations: instrumentations,
+                        });
+                        this.logger.debug(`Registered ${instrumentations.length} instrumentations`);
+                    }
+                }
+                // 11. 设置 Vue Router instrumentation（如果提供）
+                if (this.config.framework === 'vue' && this.config.router && this.tracer) {
+                    setupVueRouterInstrumentation(this.config.router, this.tracer);
+                    this.logger.debug('Vue Router instrumentation enabled');
+                }
+                // 12. 设置全局错误捕获
+                this.setupErrorHandling();
+                // 13. 页面卸载时刷新
+                if (typeof window !== 'undefined') {
+                    window.addEventListener('beforeunload', () => {
+                        this.forceFlush();
+                    });
+                }
+                this.initialized = true;
+                this.logger.info('SDK initialized successfully');
+                this.logger.info(`Service: ${this.config.serviceName}`);
+                this.logger.info(`Collector: ${this.config.collectorEndpoint}`);
+            }
+            catch (error) {
+                this.logger.error('Failed to initialize SDK:', error);
+                throw error;
+            }
+        }
+        /**
+         * 设置全局错误处理
+         */
+        setupErrorHandling() {
+            if (typeof window === 'undefined') {
+                return;
+            }
+            // 捕获全局错误
+            window.addEventListener('error', (event) => {
+                const activeSpan = api.trace.getActiveSpan();
+                if (activeSpan) {
+                    activeSpan.recordException(event.error || new Error(event.message));
+                    activeSpan.setStatus({ code: 2, message: event.message });
+                }
+            });
+            // 捕获未处理的 Promise 拒绝
+            window.addEventListener('unhandledrejection', (event) => {
+                const activeSpan = api.trace.getActiveSpan();
+                if (activeSpan) {
+                    activeSpan.recordException(event.reason);
+                    activeSpan.setStatus({ code: 2, message: String(event.reason) });
+                }
+            });
+        }
+        /**
+         * 强制刷新所有 spans
+         */
+        forceFlush() {
+            if (!this.provider) {
+                return Promise.resolve();
+            }
+            return this.provider.forceFlush();
+        }
+        /**
+         * 获取 tracer
+         */
+        getTracer(name, version) {
+            if (!this.tracer) {
+                throw new Error('SDK not initialized. Call init() first.');
+            }
+            return this.tracer;
+        }
+        /**
+         * 获取当前配置
+         */
+        getConfig() {
+            return this.config;
+        }
+        /**
+         * 获取 logger
+         */
+        getLogger() {
+            return this.logger;
+        }
+        /**
+         * 检查是否已初始化
+         */
+        isInitialized() {
+            return this.initialized;
+        }
+    }
+    // 单例实例
+    let sdkInstance = null;
+    /**
+     * 获取 SDK 实例
+     */
+    function getSDK() {
+        if (!sdkInstance) {
+            sdkInstance = new OTelSDK();
+        }
+        return sdkInstance;
+    }
+    /**
+     * 初始化 SDK
+     */
+    function initOTel(options) {
+        const sdk = getSDK();
+        sdk.init(options);
+    }
+    /**
+     * 获取 tracer
+     */
+    function getTracer(name, version) {
+        const sdk = getSDK();
+        return sdk.getTracer(name, version);
+    }
+    /**
+     * 强制刷新
+     */
+    function forceFlush() {
+        const sdk = getSDK();
+        return sdk.forceFlush();
+    }
+
+    /**
+     * Trace API - 简化的追踪接口
+     */
+    const traceAPI = {
+        /**
+         * 获取 tracer
+         */
+        getTracer(name, version) {
+            return getTracer(name, version);
+        },
+        /**
+         * 创建并启动一个 span
+         */
+        startSpan(name, options) {
+            const tracer = getTracer();
+            const span = tracer.startSpan(name, {
+                attributes: options?.attributes || {},
+                kind: options?.kind === 'internal' ? 0 :
+                    options?.kind === 'server' ? 1 :
+                        options?.kind === 'client' ? 2 :
+                            options?.kind === 'producer' ? 3 :
+                                options?.kind === 'consumer' ? 4 : 0,
+                startTime: options?.startTime,
+            });
+            return span;
+        },
+        /**
+         * 在上下文中执行函数并创建 span
+         */
+        withSpan(name, fn, options) {
+            const span = traceAPI.startSpan(name, options);
+            return api.context.with(api.trace.setSpan(api.context.active(), span), () => {
+                try {
+                    const result = fn(span);
+                    if (result instanceof Promise) {
+                        return result
+                            .then((value) => {
+                            span.setStatus({ code: 1 }); // OK
+                            span.end();
+                            return value;
+                        })
+                            .catch((error) => {
+                            span.setStatus({ code: 2, message: error.message }); // ERROR
+                            span.recordException(error);
+                            span.end();
+                            throw error;
+                        });
+                    }
+                    else {
+                        span.setStatus({ code: 1 }); // OK
+                        span.end();
+                        return result;
+                    }
+                }
+                catch (error) {
+                    span.setStatus({ code: 2, message: error?.message || 'Unknown error' }); // ERROR
+                    span.recordException(error);
+                    span.end();
+                    throw error;
+                }
+            });
+        },
+        /**
+         * 异步执行函数并创建 span
+         */
+        async withSpanAsync(name, fn, options) {
+            const span = traceAPI.startSpan(name, options);
+            return api.context.with(api.trace.setSpan(api.context.active(), span), async () => {
+                try {
+                    const result = await fn(span);
+                    span.setStatus({ code: 1 }); // OK
+                    span.end();
+                    return result;
+                }
+                catch (error) {
+                    span.setStatus({ code: 2, message: error?.message || 'Unknown error' }); // ERROR
+                    span.recordException(error);
+                    span.end();
+                    throw error;
+                }
+            });
+        },
+        /**
+         * 获取当前活动的 span
+         */
+        getActiveSpan() {
+            return api.trace.getActiveSpan();
+        },
+        /**
+         * 获取当前 trace ID
+         */
+        getCurrentTraceId() {
+            const span = api.trace.getActiveSpan();
+            if (!span) {
+                return undefined;
+            }
+            const spanContext = span.spanContext();
+            return spanContext.traceId;
+        },
+        /**
+         * 获取当前 span ID
+         */
+        getCurrentSpanId() {
+            const span = api.trace.getActiveSpan();
+            if (!span) {
+                return undefined;
+            }
+            const spanContext = span.spanContext();
+            return spanContext.spanId;
+        },
+    };
+    // 默认导出
+    var index = {
+        init: initOTel,
+        trace: traceAPI,
+        getTracer,
+        forceFlush,
+    };
+    // 为了兼容 CDN 方式，在浏览器环境中暴露到 window
+    if (typeof window !== 'undefined') {
+        window.OTelSDK = {
+            init: initOTel,
+            trace: traceAPI,
+            getTracer,
+            forceFlush,
+        };
+    }
+
+    exports.default = index;
+    exports.forceFlush = forceFlush;
+    exports.getTracer = getTracer;
+    exports.initOTel = initOTel;
+    exports.trace = traceAPI;
+    exports.traceAPI = traceAPI;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.umd.js.map