@ai-setting/roy-agent-core 1.3.9 → 1.3.11

package/src/env/log-trace/opentelemetry/integration.test.ts

@@ -1,668 +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,
-  type OTelSpan,
-} from './tracer-provider';
-import { propagation, serialize, parse } from './propagation';
-import { SQLiteSpanStorage } from '../span-storage';
-import type { Span } from '../types';
-
-const execAsync = promisify(exec);
-
-// ============================================================================
-// Test Utilities
-// ============================================================================
-
-/**
- * 扁平化 span 树为数组
- */
-function flattenSpans(spans: Span[]): Span[] {
-  const result: Span[] = [];
-  
-  function traverse(node: Span) {
-    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: Span[], name: string): Span | undefined {
-  const flat = flattenSpans(spans);
-  return flat.find(s => s.name === name);
-}
-
-/**
- * 验证 span 树的父子关系
- */
-function expectParentChildRelation(spans: Span[], childName: string, expectedParentName: string) {
-  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: string,
-  traceparent: string,
-  extraEnv?: Record<string, string>
-): Promise<{ stdout: string; stderr: string; exitCode: number }> {
-  const env: Record<string, string> = { ...process.env } as Record<string, string>;
-  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: any) {
-    return {
-      stdout: error.stdout || '',
-      stderr: error.stderr || error.message,
-      exitCode: error.code || 1,
-    };
-  }
-}
-
-/**
- * 创建临时 SQLite 数据库用于测试
- */
-function createTempDb(): { path: string; cleanup: () => void } {
-  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: OTelTracerProvider;
-  let tempDb: { path: string; cleanup: () => void };
-
-  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: Record<string, string | undefined> = {};
-    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: Record<string, string | undefined> = {
-      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: OTelSpan[] = [];
-    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: Record<string, string | undefined> = {};
-    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: Record<string, string | undefined> = { 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: { path: string; cleanup: () => void };
-
-  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: Record<string, string | undefined> = { 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: string | undefined;
-    let lastSpanId: string | undefined;
-    
-    // 创建多层嵌套 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();
-  });
-});

package/src/env/log-trace/opentelemetry/mod.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';