chinalife-otel-web-sdk 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,1425 @@
+import { createContextKey, diag, trace, isSpanContextValid, TraceFlags, isValidTraceId, isValidSpanId, propagation, context } from '@opentelemetry/api';
+import { BatchSpanProcessor, WebTracerProvider } from '@opentelemetry/sdk-trace-web';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import { registerInstrumentations } from '@opentelemetry/instrumentation';
+import { FetchInstrumentation } from '@opentelemetry/instrumentation-fetch';
+import { XMLHttpRequestInstrumentation } from '@opentelemetry/instrumentation-xml-http-request';
+import { DocumentLoadInstrumentation } from '@opentelemetry/instrumentation-document-load';
+import { UserInteractionInstrumentation } from '@opentelemetry/instrumentation-user-interaction';
+import { LongTaskInstrumentation } from '@opentelemetry/instrumentation-long-task';
+
+/**
+ * 默认配置
+ */
+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 FetchInstrumentation({
+            propagateTraceHeaderCorsUrls: [/^https?:\/\/.*/],
+            clearTimingResources: true,
+        }));
+        // XMLHttpRequest
+        instrumentations.push(new XMLHttpRequestInstrumentation({
+            propagateTraceHeaderCorsUrls: [/^https?:\/\/.*/],
+            clearTimingResources: true,
+        }));
+    }
+    // 文档加载追踪
+    instrumentations.push(new DocumentLoadInstrumentation());
+    // 用户交互追踪
+    instrumentations.push(new UserInteractionInstrumentation({
+        enabled: true,
+    }));
+    // 长任务追踪
+    instrumentations.push(new 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 = 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) {
+                    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) {
+                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 = trace.getSpanContext(context);
+        if (!spanContext ||
+            isTracingSuppressed(context) ||
+            !isSpanContextValid(spanContext))
+            return;
+        var traceParent = VERSION + "-" + spanContext.traceId + "-" + spanContext.spanId + "-0" + Number(spanContext.traceFlags || 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 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 = 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 === TraceFlags.SAMPLED || sampled === 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 TraceFlags.SAMPLED;
+    }
+    if (traceFlags === undefined || VALID_UNSAMPLED_VALUES.has(traceFlags)) {
+        return 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 = trace.getSpanContext(context);
+        if (!spanContext ||
+            !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, (TraceFlags.SAMPLED & spanContext.traceFlags) === 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 (isValidTraceId(traceId) &&
+            isValidSpanId(spanId) &&
+            isValidSampledValue(traceFlags)) {
+            context = context.setValue(B3_DEBUG_FLAG_KEY, debug);
+            return 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 TraceFlags.SAMPLED;
+    }
+    return 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 = trace.getSpanContext(context);
+        if (!spanContext ||
+            !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 (!isValidTraceId(traceId) || !isValidSpanId(spanId))
+            return context;
+        var traceFlags = convertToTraceFlags(samplingState);
+        if (samplingState === DEBUG_STATE) {
+            context = context.setValue(B3_DEBUG_FLAG_KEY, samplingState);
+        }
+        return 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 = 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 === 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' ? TraceFlags.SAMPLED : TraceFlags.NONE,
+            isRemote: true,
+        };
+        // 使用 trace API 设置 span context
+        return 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 = resourceFromAttributes({
+                [ATTR_SERVICE_NAME]: this.config.serviceName || 'unknown-service',
+                [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 OTLPTraceExporter({
+                url: this.config.collectorEndpoint,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            // 3. 创建 BatchSpanProcessor
+            const batchConfig = this.config.batchConfig || {};
+            const spanProcessor = new 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() 不会覆盖我们的传播器设置
+            propagation.setGlobalPropagator(propagator);
+            this.logger.debug(`Global propagator set with ${propagationFormat} format(s)`);
+            // 6. 创建 TracerProvider
+            this.provider = new 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) {
+                    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 = 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 = 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 context.with(trace.setSpan(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 context.with(trace.setSpan(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 trace.getActiveSpan();
+    },
+    /**
+     * 获取当前 trace ID
+     */
+    getCurrentTraceId() {
+        const span = trace.getActiveSpan();
+        if (!span) {
+            return undefined;
+        }
+        const spanContext = span.spanContext();
+        return spanContext.traceId;
+    },
+    /**
+     * 获取当前 span ID
+     */
+    getCurrentSpanId() {
+        const span = 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,
+    };
+}
+
+export { index as default, forceFlush, getTracer, initOTel, traceAPI as trace, traceAPI };
+//# sourceMappingURL=index.esm.js.map