@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

package/dist/core/src/env/log-trace/opentelemetry/integration.test.js

@@ -1,535 +0,0 @@
-/**
- * @fileoverview Cross-process Span Tree 集成测试
- *
- * 验证跨进程 span tree 完整性：
- * 1. 主进程启动 span（设置 traceId 和 parentSpanId）
- * 2. 通过 bash 工具启动子进程（传递 TRACEPARENT）
- * 3. 子进程创建子 span
- * 4. 验证 span tree 完整性（主 span + 子 span 串联）
- *
- * 注意：本测试文件独立运行，使用真实的 SQLite 存储。
- * 不与 tracer-provider.test.ts 一起运行，因为后者使用 vi.mock 模拟存储。
- *
- * 运行方式：
- *   bun test packages/core/src/env/log-trace/opentelemetry/integration.test.ts
- *
- * 不要与其他 opentelemetry 测试一起运行，否则 vi.mock 会影响本测试。
- */
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { OTelTracerProvider, } from "./tracer-provider.js";
-import { propagation, serialize, parse } from "./propagation.js";
-import { SQLiteSpanStorage } from "../span-storage.js";
-const execAsync = promisify(exec);
-// ============================================================================
-// Test Utilities
-// ============================================================================
-/**
- * 扁平化 span 树为数组
- */
-function flattenSpans(spans) {
-    const result = [];
-    function traverse(node) {
-        result.push(node);
-        if (node.children) {
-            for (const child of node.children) {
-                traverse(child);
-            }
-        }
-    }
-    for (const span of spans) {
-        traverse(span);
-    }
-    return result;
-}
-/**
- * 从 span 树中查找指定名称的 span
- */
-function findSpanByName(spans, name) {
-    const flat = flattenSpans(spans);
-    return flat.find(s => s.name === name);
-}
-/**
- * 验证 span 树的父子关系
- */
-function expectParentChildRelation(spans, childName, expectedParentName) {
-    const flat = flattenSpans(spans);
-    const child = flat.find(s => s.name === childName);
-    const parent = flat.find(s => s.name === expectedParentName);
-    expect(child).toBeDefined();
-    expect(parent).toBeDefined();
-    expect(child.parentSpanId).toBe(parent.spanId);
-}
-/**
- * 执行带 trace context 的 bash 命令
- *
- * @param command 要执行的命令
- * @param traceparent W3C TRACEPARENT 字符串
- * @param env 额外环境变量
- * @returns 执行结果
- */
-async function execWithTraceparent(command, traceparent, extraEnv) {
-    const env = { ...process.env };
-    env['TRACEPARENT'] = traceparent;
-    if (extraEnv) {
-        Object.assign(env, extraEnv);
-    }
-    try {
-        const { stdout, stderr } = await execAsync(command, {
-            env,
-            timeout: 10000,
-        });
-        return { stdout, stderr, exitCode: 0 };
-    }
-    catch (error) {
-        return {
-            stdout: error.stdout || '',
-            stderr: error.stderr || error.message,
-            exitCode: error.code || 1,
-        };
-    }
-}
-/**
- * 创建临时 SQLite 数据库用于测试
- */
-function createTempDb() {
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'otel-test-'));
-    const dbPath = path.join(tempDir, 'test.sqlite');
-    return {
-        path: dbPath,
-        cleanup: () => {
-            try {
-                fs.unlinkSync(dbPath);
-                fs.rmdirSync(tempDir);
-            }
-            catch {
-                // 忽略清理错误
-            }
-        },
-    };
-}
-// ============================================================================
-// Integration Tests
-// ============================================================================
-describe('Cross-process Span Tree', () => {
-    let provider;
-    let tempDb;
-    beforeEach(async () => {
-        // 清除环境变量中的 trace context，避免继承外部上下文
-        delete process.env['TRACEPARENT'];
-        delete process.env['TRACE_ID'];
-        delete process.env['LOG_TRACE_REQUEST_ID'];
-        tempDb = createTempDb();
-        provider = new OTelTracerProvider(new SQLiteSpanStorage(tempDb.path));
-        await provider.initialize();
-    });
-    afterEach(() => {
-        provider.shutdown();
-        tempDb.cleanup();
-    });
-    test('should maintain trace continuity in single process', async () => {
-        // 主进程创建父 span
-        const tracer = provider.getTracer('test-tracer');
-        const parentSpan = tracer.startSpan('parent-span');
-        // 获取 span context 并序列化
-        const parentContext = parentSpan.spanContext;
-        const traceparent = serialize(parentContext);
-        // 验证序列化格式
-        expect(traceparent).toMatch(/^00-[0-9a-f]{32}-[0-9a-f]{16}-01$/);
-        // 解析回上下文
-        const parsed = parse(traceparent);
-        expect(parsed).toBeDefined();
-        expect(parsed.traceId).toBe(parentContext.traceId);
-        expect(parsed.spanId).toBe(parentContext.spanId);
-        // 注意：parsed 返回的 spanId 对应发送方的 spanId（用作接收方的 parentSpanId）
-        // 创建子 span（同一 tracer，自动继承父上下文）
-        const childSpan = tracer.startSpan('child-span');
-        expect(childSpan.spanContext.traceId).toBe(parentContext.traceId);
-        expect(childSpan.spanContext.parentSpanId).toBe(parentContext.spanId);
-        // 结束 span
-        childSpan.end();
-        parentSpan.end();
-        // 验证存储中的 span
-        // 注意：findByTraceId 返回的是树结构，需要扁平化
-        const storage = provider.getStorage();
-        const spanTree = storage.findByTraceId(parentContext.traceId);
-        const spans = flattenSpans(spanTree);
-        expect(spans.length).toBe(2);
-        // 验证 parent-child 关系
-        const storedParent = spans.find(s => s.name === 'parent-span');
-        const storedChild = spans.find(s => s.name === 'child-span');
-        expect(storedParent).toBeDefined();
-        expect(storedChild).toBeDefined();
-        expect(storedChild.parentSpanId).toBe(storedParent.spanId);
-    });
-    test('should inject TRACEPARENT to environment', async () => {
-        const tracer = provider.getTracer('test-tracer');
-        const span = tracer.startSpan('test-span');
-        const env = {};
-        tracer.injectToEnv(env);
-        expect(env['TRACEPARENT']).toBeDefined();
-        // 验证格式
-        const parsed = parse(env['TRACEPARENT']);
-        expect(parsed).toBeDefined();
-        expect(parsed.traceId).toBe(span.spanContext.traceId);
-        span.end();
-    });
-    test('should extract TRACEPARENT from environment', async () => {
-        // 模拟从环境变量提取
-        const carrier = {
-            TRACEPARENT: '00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01',
-        };
-        const extracted = propagation.extract(carrier);
-        expect(extracted).toBeDefined();
-        expect(extracted.traceId).toBe('0af7651916cd43dd8448eb211c80319c');
-        expect(extracted.spanId).toBe('b7ad6b7169203331');
-    });
-    test('should maintain trace continuity across bash subprocess', async () => {
-        // 1. 主进程创建父 span
-        const tracer = provider.getTracer('test-tracer');
-        const parentSpan = tracer.startSpan('parent-span');
-        const parentContext = parentSpan.spanContext;
-        const traceparent = serialize(parentContext);
-        // 2. 通过子进程执行命令（使用相同数据库路径）
-        const childResult = await execWithTraceparent(`sqlite3 "${tempDb.path}" "SELECT * FROM span WHERE trace_id = '${parentContext.traceId}'"`, traceparent);
-        // 3. 子进程内部应该能够创建子 span
-        // 由于子进程是新进程，它会初始化自己的 provider
-        // 但我们可以通过检查当前进程的存储来验证
-        parentSpan.end();
-        // 4. 验证 span tree - 在主进程的存储中应该有父 span
-        const storage = provider.getStorage();
-        const spanTree = storage.findByTraceId(parentContext.traceId);
-        const spans = flattenSpans(spanTree);
-        // 主进程至少有父 span
-        expect(spans.length).toBeGreaterThanOrEqual(1);
-        const storedParent = spans.find(s => s.name === 'parent-span');
-        expect(storedParent).toBeDefined();
-        expect(storedParent.spanId).toBe(parentContext.spanId);
-    });
-    test.skip('should create nested spans in same trace', async () => {
-        // Skip: This test has a known issue with span parent-child relationship in nested calls
-        // The basic nesting functionality works (verified by decorator-otel.test.ts)
-        const tracer = provider.getTracer('test-tracer');
-        // 创建三层嵌套 span
-        const span1 = tracer.startSpan('level-1');
-        const span2 = tracer.startSpan('level-2');
-        const span3 = tracer.startSpan('level-3');
-        expect(span3.spanContext.traceId).toBe(span1.spanContext.traceId);
-        expect(span2.spanContext.parentSpanId).toBe(span1.spanContext.spanId);
-        expect(span3.spanContext.parentSpanId).toBe(span2.spanContext.spanId);
-        span3.end();
-        span2.end();
-        span1.end();
-        // 验证存储
-        const storage = provider.getStorage();
-        const spanTree = storage.findByTraceId(span1.spanContext.traceId);
-        const spans = flattenSpans(spanTree);
-        expect(spans.length).toBe(3);
-        // 验证树结构
-        const level1 = spans.find(s => s.name === 'level-1');
-        const level2 = spans.find(s => s.name === 'level-2');
-        const level3 = spans.find(s => s.name === 'level-3');
-        expect(level1.parentSpanId || undefined).toBeUndefined(); // 根 span
-        expect(level2.parentSpanId).toBe(level1.spanId);
-        expect(level3.parentSpanId).toBe(level2.spanId);
-    });
-    test('should handle concurrent spans', async () => {
-        const tracer = provider.getTracer('test-tracer');
-        // 创建多个并发的根 span
-        // 注意：由于 tracer 维护单一 currentContext，连续 startSpan 会创建嵌套 span
-        // 要创建独立的根 span，需要先结束当前 span
-        const spans = [];
-        for (let i = 0; i < 3; i++) {
-            const span = tracer.startSpan(`concurrent-span-${i}`);
-            spans.push(span);
-            span.end(); // 结束当前 span 以创建新的根 span
-        }
-        // 结束所有 span
-        spans.forEach(span => span.end());
-        // 验证存储中有 3 个不同的 trace
-        const storage = provider.getStorage();
-        const traceIds = new Set(spans.map(s => s.spanContext.traceId));
-        expect(traceIds.size).toBe(3);
-        spans.forEach(span => {
-            const spanTree = storage.findByTraceId(span.spanContext.traceId);
-            const stored = flattenSpans(spanTree);
-            expect(stored.length).toBe(1);
-        });
-    });
-    test('should serialize and parse traceparent correctly', () => {
-        // 测试各种边界情况
-        const testCases = [
-            { traceId: '1', spanId: '1', expectedTraceId: '00000000000000000000000000000001' },
-            { traceId: '0af7651916cd43dd8448eb211c80319c', spanId: 'b7ad6b7169203331', expectedTraceId: '0af7651916cd43dd8448eb211c80319c' },
-            { traceId: 'ffffffffffffffffffffffffffffffff', spanId: 'ffffffffffffffff', expectedTraceId: 'ffffffffffffffffffffffffffffffff' },
-        ];
-        testCases.forEach(({ traceId, spanId, expectedTraceId }) => {
-            const context = { traceId, spanId, parentSpanId: undefined };
-            const traceparent = serialize(context);
-            expect(traceparent).toMatch(/^00-[0-9a-f]{32}-[0-9a-f]{16}-01$/);
-            const parsed = parse(traceparent);
-            expect(parsed.traceId).toBe(expectedTraceId);
-            expect(parsed.spanId).toBe(spanId.padStart(16, '0'));
-        });
-    });
-    test('should handle invalid traceparent gracefully', () => {
-        const invalidTraceparents = [
-            '',
-            'invalid',
-            '00-',
-            '00-0af7651916cd43dd8448eb211c80319c',
-            '01-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01', // wrong version
-            '00-0af7651916cd43dd8448eb211c80319-b7ad6b7169203331-01', // wrong traceId length
-            '00-0af7651916cd43dd8448eb211c80319c-b7ad6b716920333-01', // wrong spanId length
-            '00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-0g', // invalid hex
-        ];
-        invalidTraceparents.forEach(traceparent => {
-            const result = parse(traceparent);
-            expect(result).toBeUndefined();
-        });
-    });
-    test('should support roundtrip inject/extract', () => {
-        const original = {
-            traceId: '0af7651916cd43dd8448eb211c80319c',
-            spanId: 'b7ad6b7169203331',
-            parentSpanId: 'a1b2c3d4e5f67890',
-        };
-        const carrier = {};
-        propagation.inject(carrier, original);
-        expect(carrier['TRACEPARENT']).toBe('00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01');
-        const extracted = propagation.extract(carrier);
-        expect(extracted).toBeDefined();
-        expect(extracted.traceId).toBe(original.traceId);
-        // extract returns ExtractedContext with spanId field (sender's spanId)
-        expect(extracted.spanId).toBe(original.spanId);
-    });
-    test('should create child span from extracted context', async () => {
-        // 模拟从环境变量接收到外部 trace context
-        const externalTraceparent = '00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01';
-        const carrier = { TRACEPARENT: externalTraceparent };
-        const extracted = propagation.extract(carrier);
-        expect(extracted).toBeDefined();
-        expect(extracted.traceId).toBe('0af7651916cd43dd8448eb211c80319c');
-        expect(extracted.spanId).toBe('b7ad6b7169203331');
-        // 使用提取的上下文创建子 span
-        const tracer = provider.getTracer('test-tracer');
-        const childSpan = tracer.startSpan('child-from-external', {
-            parent: {
-                traceId: extracted.traceId,
-                spanId: '0000000000000000', // 子进程需要生成自己的 spanId
-                parentSpanId: extracted.spanId, // 使用外部 spanId 作为父
-            },
-        });
-        expect(childSpan.spanContext.traceId).toBe(extracted.traceId);
-        expect(childSpan.spanContext.parentSpanId).toBe(extracted.spanId);
-        childSpan.end();
-        // 验证存储
-        const storage = provider.getStorage();
-        const spanTree = storage.findByTraceId(extracted.traceId);
-        const spans = flattenSpans(spanTree);
-        expect(spans.length).toBe(1);
-        const storedChild = spans.find(s => s.name === 'child-from-external');
-        expect(storedChild).toBeDefined();
-        expect(storedChild.parentSpanId).toBe(extracted.spanId);
-    });
-    test('should track span timing correctly', async () => {
-        const tracer = provider.getTracer('test-tracer');
-        const startTime = Date.now();
-        const span = tracer.startSpan('timed-span');
-        expect(span.startTime).toBeGreaterThanOrEqual(startTime);
-        // 模拟一些处理时间
-        await new Promise(resolve => setTimeout(resolve, 50));
-        span.end();
-        expect(span.endTime).toBeGreaterThan(span.startTime);
-        expect(span.endTime).toBeLessThanOrEqual(Date.now());
-        expect(span.endTime - span.startTime).toBeGreaterThanOrEqual(50);
-    });
-    test('should handle span with error', async () => {
-        const tracer = provider.getTracer('test-tracer');
-        const span = tracer.startSpan('error-span');
-        const error = new Error('Test error message');
-        span.end(undefined, error);
-        expect(span.error).toBe('Test error message');
-        // 验证存储
-        const storage = provider.getStorage();
-        const spanTree = storage.findByTraceId(span.spanContext.traceId);
-        const spans = flattenSpans(spanTree);
-        const storedSpan = spans.find(s => s.name === 'error-span');
-        expect(storedSpan).toBeDefined();
-        expect(storedSpan.error).toBe('Test error message');
-    });
-    test('should preserve span attributes', async () => {
-        const tracer = provider.getTracer('test-tracer');
-        const span = tracer.startSpan('attr-span', {
-            attributes: {
-                'user.id': '12345',
-                'request.method': 'GET',
-                'request.count': 42,
-                'request.success': true,
-            },
-        });
-        expect(span.attributes['user.id']).toBe('12345');
-        expect(span.attributes['request.method']).toBe('GET');
-        expect(span.attributes['request.count']).toBe(42);
-        expect(span.attributes['request.success']).toBe(true);
-        span.setAttribute('additional.key', 'additional-value');
-        expect(span.attributes['additional.key']).toBe('additional-value');
-        span.end();
-        // 验证存储
-        const storage = provider.getStorage();
-        const spanTree = storage.findByTraceId(span.spanContext.traceId);
-        const spans = flattenSpans(spanTree);
-        const storedSpan = spans.find(s => s.name === 'attr-span');
-        expect(storedSpan).toBeDefined();
-        expect(storedSpan.attributes['user.id']).toBe('12345');
-        expect(storedSpan.attributes['request.count']).toBe(42);
-    });
-    test('should list traces correctly', async () => {
-        const tracer = provider.getTracer('test-tracer');
-        // 创建多个独立的根 span（每个 span 结束后再创建下一个）
-        const span1 = tracer.startSpan('span-a');
-        span1.end();
-        const span2 = tracer.startSpan('span-b');
-        span2.end();
-        const span3 = tracer.startSpan('span-c');
-        span3.end();
-        // 列出 traces
-        const traces = provider.getStorage().listTraces(10);
-        // 应该至少有 3 个不同的 trace
-        expect(traces.length).toBeGreaterThanOrEqual(3);
-        // 验证每个 trace 有正确的 span 数量
-        const span1Trace = traces.find(t => t.traceId === span1.spanContext.traceId);
-        expect(span1Trace).toBeDefined();
-        expect(span1Trace.spanCount).toBe(1);
-    });
-});
-// ============================================================================
-// Cross-Process Scenario Tests
-// ============================================================================
-describe('Cross-Process Scenario', () => {
-    let tempDb;
-    beforeEach(() => {
-        tempDb = createTempDb();
-    });
-    afterEach(() => {
-        tempDb.cleanup();
-    });
-    test('should simulate parent-child process with shared SQLite storage', async () => {
-        // 这个测试模拟真实场景：
-        // 1. 主进程创建父 span
-        // 2. 通过 bash 启动子进程，子进程继承 trace context
-        // 3. 验证两个进程的 span 都在同一个 trace 中
-        // === 主进程 ===
-        const provider1 = new OTelTracerProvider(new SQLiteSpanStorage(tempDb.path));
-        await provider1.initialize();
-        const tracer1 = provider1.getTracer('parent-process');
-        const parentSpan = tracer1.startSpan('parent-process-span', {
-            attributes: {
-                'process.type': 'parent',
-                'process.pid': process.pid,
-            },
-        });
-        const traceId = parentSpan.spanContext.traceId;
-        const parentSpanId = parentSpan.spanContext.spanId;
-        const traceparent = serialize(parentSpan.spanContext);
-        // 结束父 span
-        parentSpan.end();
-        provider1.shutdown();
-        // === 子进程 ===
-        // 使用相同的数据库路径创建新的 provider
-        // 注意：这模拟了通过 bash 启动新进程的场景
-        const provider2 = new OTelTracerProvider(new SQLiteSpanStorage(tempDb.path));
-        await provider2.initialize();
-        // 从环境变量恢复上下文
-        const carrier = { TRACEPARENT: traceparent };
-        const extracted = propagation.extract(carrier);
-        expect(extracted).toBeDefined();
-        expect(extracted.traceId).toBe(traceId);
-        expect(extracted.spanId).toBe(parentSpanId);
-        // 创建子 span
-        const tracer2 = provider2.getTracer('child-process');
-        const childSpan = tracer2.startSpan('child-process-span', {
-            parent: {
-                traceId: extracted.traceId,
-                spanId: '0000000000000000', // 子进程生成新的 spanId
-                parentSpanId: extracted.spanId,
-            },
-            attributes: {
-                'process.type': 'child',
-                'parent_span_id': parentSpanId,
-            },
-        });
-        expect(childSpan.spanContext.traceId).toBe(traceId);
-        expect(childSpan.spanContext.parentSpanId).toBe(parentSpanId);
-        childSpan.end();
-        provider2.shutdown();
-        // === 验证 span tree ===
-        // 使用第三个 provider 来查询（模拟查询工具）
-        const provider3 = new OTelTracerProvider(new SQLiteSpanStorage(tempDb.path));
-        await provider3.initialize();
-        const storage = provider3.getStorage();
-        const spanTree = storage.findByTraceId(traceId);
-        const spans = flattenSpans(spanTree);
-        expect(spans.length).toBe(2);
-        const storedParent = spans.find(s => s.name === 'parent-process-span');
-        const storedChild = spans.find(s => s.name === 'child-process-span');
-        expect(storedParent).toBeDefined();
-        expect(storedChild).toBeDefined();
-        expect(storedChild.parentSpanId).toBe(storedParent.spanId);
-        expect(storedParent.parentSpanId || undefined).toBeUndefined(); // 根 span
-        provider3.shutdown();
-    });
-    test('should handle deeply nested cross-process spans', async () => {
-        const MAX_DEPTH = 5;
-        const provider = new OTelTracerProvider(new SQLiteSpanStorage(tempDb.path));
-        await provider.initialize();
-        let currentTraceId;
-        let lastSpanId;
-        // 创建多层嵌套 span
-        for (let i = 0; i < MAX_DEPTH; i++) {
-            const tracer = provider.getTracer(`level-${i}-tracer`);
-            // 为第一个 span 不提供 parent，后续 span 使用前一个 span 的 spanId 作为 parent
-            const parent = lastSpanId ? {
-                traceId: currentTraceId,
-                spanId: '0000000000000000', // 这个会被忽略，parentSpanId 来自 currentContext
-                parentSpanId: lastSpanId, // 使用上一个 span 的 spanId 作为父
-            } : undefined;
-            const span = tracer.startSpan(`level-${i}-span`, {
-                parent,
-                attributes: {
-                    'level': i,
-                    'max_depth': MAX_DEPTH,
-                },
-            });
-            if (!currentTraceId) {
-                currentTraceId = span.spanContext.traceId;
-            }
-            lastSpanId = span.spanContext.spanId;
-            span.end();
-        }
-        // 验证所有 span 在同一个 trace 中
-        const storage = provider.getStorage();
-        const spanTree = storage.findByTraceId(currentTraceId);
-        const spans = flattenSpans(spanTree);
-        expect(spans.length).toBe(MAX_DEPTH);
-        // 验证层级关系
-        for (let i = 0; i < MAX_DEPTH; i++) {
-            const span = spans.find(s => s.name === `level-${i}-span`);
-            expect(span).toBeDefined();
-            if (i === 0) {
-                // 第一个 span 是根 span，parentSpanId 应该是 undefined 或 null
-                expect(span.parentSpanId || undefined).toBeUndefined();
-            }
-            else {
-                const parentSpan = spans.find(s => s.name === `level-${i - 1}-span`);
-                expect(span.parentSpanId).toBe(parentSpan.spanId);
-            }
-        }
-        provider.shutdown();
-    });
-});
-//# sourceMappingURL=integration.test.js.map

package/dist/core/src/env/log-trace/opentelemetry/mod.d.ts

@@ -1,25 +0,0 @@
-/**
- * @fileoverview OpenTelemetry 模块统一导出
- *
- * @example
- * import { getTracerProvider, propagation } from './opentelemetry/mod';
- *
- * // 初始化
- * const provider = getTracerProvider();
- * await provider.initialize();
- *
- * // 获取 Tracer
- * const tracer = provider.getTracer('my-service');
- *
- * // 启动 Span
- * const span = tracer.startSpan('my-operation');
- *
- * // 注入到环境变量
- * const env: Record<string, string | undefined> = {};
- * tracer.injectToEnv(env);
- * process.env = { ...process.env, ...env };
- */
-export { OTelTracerProvider, getTracerProvider, resetTracerProvider, type OTelTracer, type OTelSpan, type SpanOptions } from './tracer-provider';
-export { propagation, serialize, parse, type ExtractedContext } from './propagation';
-export { injectToEnv, injectToEnvWithContext, injectToEnvFromCarrier, getTraceparentHeader, type EnvCarrier } from './propagation-env';
-//# sourceMappingURL=mod.d.ts.map

package/dist/core/src/env/log-trace/opentelemetry/mod.js

@@ -1,25 +0,0 @@
-/**
- * @fileoverview OpenTelemetry 模块统一导出
- *
- * @example
- * import { getTracerProvider, propagation } from "./opentelemetry/mod.js";
- *
- * // 初始化
- * const provider = getTracerProvider();
- * await provider.initialize();
- *
- * // 获取 Tracer
- * const tracer = provider.getTracer('my-service');
- *
- * // 启动 Span
- * const span = tracer.startSpan('my-operation');
- *
- * // 注入到环境变量
- * const env: Record<string, string | undefined> = {};
- * tracer.injectToEnv(env);
- * process.env = { ...process.env, ...env };
- */
-export { OTelTracerProvider, getTracerProvider, resetTracerProvider } from "./tracer-provider.js";
-export { propagation, serialize, parse } from "./propagation.js";
-export { injectToEnv, injectToEnvWithContext, injectToEnvFromCarrier, getTraceparentHeader } from "./propagation-env.js";
-//# sourceMappingURL=mod.js.map

package/dist/core/src/env/log-trace/opentelemetry/propagation-env.d.ts

@@ -1,82 +0,0 @@
-/**
- * @fileoverview Propagation Env Module
- *
- * 提供便捷的环境变量注入功能，用于在子进程执行时传递 trace context。
- *
- * @example
- * ```typescript
- * import { injectToEnv, injectToEnvWithContext } from './propagation-env';
- *
- * // 在 Bash 工具中执行子进程前：
- * const traceEnv = injectToEnv();  // 从当前 OTelTracerProvider 获取并注入
- * const options = {
- *   env: { ...process.env, ...traceEnv, ...env },
- * };
- * spawn(command, args, options);
- * ```
- */
-import type { SpanContext } from "../types";
-/**
- * 环境变量对象类型
- */
-export type EnvCarrier = Record<string, string | undefined>;
-/**
- * 从当前 OTelTracerProvider 获取上下文并注入到环境变量
- *
- * 这是一个便捷函数，封装了常见的注入模式：
- * 1. 从全局 TracerProvider 获取当前 Tracer
- * 2. 获取当前 span context
- * 3. 注入到目标环境变量
- *
- * @param env 目标环境变量对象（默认：{}）
- * @returns 注入了 TRACEPARENT 的环境变量对象
- *
- * @example
- * ```typescript
- * const env = injectToEnv({ PATH: '/usr/bin' });
- * // env.TRACEPARENT = '00-{traceId}-{spanId}-01'
- * // env.PATH = '/usr/bin'
- * ```
- */
-export declare function injectToEnv(env?: EnvCarrier): EnvCarrier;
-/**
- * 将指定的 SpanContext 直接注入到环境变量
- *
- * 与 injectToEnv 不同，这个函数不需要访问全局 TracerProvider，
- * 直接使用传入的 SpanContext 进行注入。
- *
- * @param env 目标环境变量对象
- * @param context 要注入的 SpanContext
- * @returns 注入了 TRACEPARENT 的环境变量对象
- *
- * @example
- * ```typescript
- * const span = tracer.startSpan('my-span');
- * const env = injectToEnvWithContext({}, span.spanContext);
- * ```
- */
-export declare function injectToEnvWithContext(env: EnvCarrier, context: SpanContext): EnvCarrier;
-/**
- * 从源环境变量 carrier 复制 TRACEPARENT 到目标 carrier
- *
- * 用于将一个环境变量对象中的 trace context 传递到另一个：
- * - 从 process.env 复制到子进程的环境变量
- * - 从父进程环境变量复制到子进程环境变量
- *
- * @param target 目标 carrier（将被修改）
- * @param source 源 carrier
- * @returns 目标 carrier
- *
- * @example
- * ```typescript
- * // 在 fork 子进程时继承父进程的 trace context
- * const childEnv = injectToEnvFromCarrier({}, process.env);
- * ```
- */
-export declare function injectToEnvFromCarrier(target: EnvCarrier, source: EnvCarrier): EnvCarrier;
-/**
- * 获取 TRACEPARENT 字段名
- */
-export declare function getTraceparentHeader(): string;
-export type { SpanContext } from "../types";
-//# sourceMappingURL=propagation-env.d.ts.map