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

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

@@ -1,291 +0,0 @@
-/**
- * @fileoverview OTelTracerProvider 测试
- *
- * 测试 OpenTelemetry TracerProvider 实现：
- * - 单例模式
- * - 获取 Tracer
- * - 启动/结束 Span
- * - 上下文注入环境变量
- */
-import { describe, test, expect, beforeEach, afterEach, vi } from 'bun:test';
-import { OTelTracerProvider, getTracerProvider, } from "./tracer-provider.js";
-import { parse } from "./propagation.js";
-// 模拟 span-storage
-vi.mock('../span-storage', () => ({
-    SQLiteSpanStorage: vi.fn().mockImplementation(() => ({
-        initialize: vi.fn().mockResolvedValue(undefined),
-        save: vi.fn(),
-        findByTraceId: vi.fn().mockReturnValue([]),
-        findBySpanId: vi.fn(),
-        listTraces: vi.fn().mockReturnValue([]),
-        deleteByTraceId: vi.fn(),
-        close: vi.fn(),
-    })),
-}));
-describe('OTelTracerProvider', () => {
-    let provider;
-    beforeEach(() => {
-        provider = new OTelTracerProvider();
-    });
-    afterEach(() => {
-        provider.shutdown();
-    });
-    describe('singleton', () => {
-        test('should return singleton instance', () => {
-            const instance1 = getTracerProvider();
-            const instance2 = getTracerProvider();
-            expect(instance1).toBe(instance2);
-        });
-        test('should allow reset for testing', () => {
-            const instance1 = getTracerProvider();
-            provider.shutdown();
-            // Reset and get new instance
-            const instance2 = getTracerProvider();
-            // They should be the same instance (singleton)
-            expect(instance1).toBe(instance2);
-        });
-    });
-    describe('getTracer', () => {
-        test('should return a tracer with given name', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            expect(tracer).toBeDefined();
-            expect(tracer.name).toBe('test-tracer');
-        });
-        test('should return same tracer for same name', async () => {
-            await provider.initialize();
-            const tracer1 = provider.getTracer('test-tracer');
-            const tracer2 = provider.getTracer('test-tracer');
-            expect(tracer1).toBe(tracer2);
-        });
-        test('should return different tracers for different names', async () => {
-            await provider.initialize();
-            const tracer1 = provider.getTracer('tracer-a');
-            const tracer2 = provider.getTracer('tracer-b');
-            expect(tracer1).not.toBe(tracer2);
-            expect(tracer1.name).toBe('tracer-a');
-            expect(tracer2.name).toBe('tracer-b');
-        });
-        test('should include version when provided', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer', '1.0.0');
-            expect(tracer.name).toBe('test-tracer');
-            expect(tracer.version).toBe('1.0.0');
-        });
-    });
-    describe('startSpan', () => {
-        test('should start a new span with name', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            const span = tracer.startSpan('my-span');
-            expect(span).toBeDefined();
-            expect(span.name).toBe('my-span');
-            expect(span.spanContext).toBeDefined();
-            expect(span.spanContext.traceId).toBeDefined();
-            expect(span.spanContext.spanId).toBeDefined();
-        });
-        test('should generate unique spanId for each span', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            const span1 = tracer.startSpan('span-1');
-            const span2 = tracer.startSpan('span-2');
-            expect(span1.spanContext.spanId).not.toBe(span2.spanContext.spanId);
-        });
-        test('should set parentSpanId from current context', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            const parentSpan = tracer.startSpan('parent-span');
-            const childSpan = tracer.startSpan('child-span');
-            expect(childSpan.spanContext.parentSpanId).toBe(parentSpan.spanContext.spanId);
-        });
-        test('should end span with result', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            const span = tracer.startSpan('my-span');
-            span.end({ data: 'test result' });
-            expect(span.endTime).toBeDefined();
-        });
-        test('should end span with error', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            const span = tracer.startSpan('my-span');
-            const error = new Error('test error');
-            span.end(undefined, error);
-            expect(span.endTime).toBeDefined();
-            expect(span.error).toBe(error.message);
-        });
-        test('should set attributes', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            const span = tracer.startSpan('my-span', {
-                attributes: { key1: 'value1', key2: 123 },
-            });
-            expect(span.attributes).toEqual({ key1: 'value1', key2: 123 });
-        });
-    });
-    describe('injectToEnv', () => {
-        test('should inject current span context to env', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            const span = tracer.startSpan('my-span');
-            const env = {};
-            tracer.injectToEnv(env);
-            expect(env['TRACEPARENT']).toBeDefined();
-            expect(env['TRACEPARENT']).toMatch(/^00-[0-9a-f]{32}-[0-9a-f]{16}-01$/);
-        });
-        test('should include traceId in injected env', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            const span = tracer.startSpan('my-span');
-            const env = {};
-            tracer.injectToEnv(env);
-            const parsed = parse(env['TRACEPARENT']);
-            expect(parsed).toBeDefined();
-            expect(parsed.traceId).toBe(span.spanContext.traceId);
-            expect(parsed.spanId).toBe(span.spanContext.spanId);
-        });
-    });
-    describe('context propagation', () => {
-        test('should propagate context across nested spans', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            const span1 = tracer.startSpan('span-1');
-            expect(span1.spanContext.parentSpanId).toBeUndefined(); // root span
-            const span2 = tracer.startSpan('span-2');
-            expect(span2.spanContext.parentSpanId).toBe(span1.spanContext.spanId);
-            const span3 = tracer.startSpan('span-3');
-            expect(span3.spanContext.parentSpanId).toBe(span2.spanContext.spanId);
-            span3.end();
-            span2.end();
-            span1.end();
-            // Verify traceId is same for all spans
-            expect(span1.spanContext.traceId).toBe(span2.spanContext.traceId);
-            expect(span2.spanContext.traceId).toBe(span3.spanContext.traceId);
-        });
-        test('should restore parentSpanId in currentContext after ending span', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            // Start and end root span
-            const span1 = tracer.startSpan('span-1');
-            expect(span1.spanContext.parentSpanId).toBeUndefined();
-            const span1Id = span1.spanContext.spanId;
-            span1.end();
-            // After ending root span, currentContext should be undefined (no active spans)
-            expect(tracer.getCurrentContext()).toBeUndefined();
-            // Start a new span - it should be a new root (no parent)
-            const span2 = tracer.startSpan('span-2');
-            expect(span2.spanContext.traceId).not.toBe(span1.spanContext.traceId);
-            expect(span2.spanContext.parentSpanId).toBeUndefined();
-            span2.end();
-        });
-        test('should restore correct context after ending child span', async () => {
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            // Start root span
-            const rootSpan = tracer.startSpan('root-span');
-            const rootSpanId = rootSpan.spanContext.spanId;
-            expect(rootSpan.spanContext.parentSpanId).toBeUndefined();
-            // Start child span
-            const childSpan = tracer.startSpan('child-span');
-            const childSpanId = childSpan.spanContext.spanId;
-            expect(childSpan.spanContext.parentSpanId).toBe(rootSpanId);
-            // End child span
-            childSpan.end();
-            // After ending child, currentContext should have parentSpanId pointing to root
-            const ctxAfterChild = tracer.getCurrentContext();
-            expect(ctxAfterChild).toBeDefined();
-            expect(ctxAfterChild.traceId).toBe(rootSpan.spanContext.traceId);
-            expect(ctxAfterChild.spanId).toBe(rootSpanId);
-            expect(ctxAfterChild.parentSpanId).toBeUndefined(); // root span has no parent
-            // Start another child of root - should have correct parentSpanId
-            const childSpan2 = tracer.startSpan('child-span-2');
-            expect(childSpan2.spanContext.parentSpanId).toBe(rootSpanId);
-            // End all
-            childSpan2.end();
-            rootSpan.end();
-        });
-    });
-    describe('initialize from environment', () => {
-        test('should restore context from TRACEPARENT env', async () => {
-            // Set up parent trace
-            const parentTraceId = '0af7651916cd43dd8448eb211c80319c';
-            const parentSpanId = 'b7ad6b7169203331';
-            // Simulate environment with TRACEPARENT
-            const originalEnv = process.env.TRACEPARENT;
-            process.env.TRACEPARENT = `00-${parentTraceId}-${parentSpanId}-01`;
-            try {
-                await provider.initialize();
-                const tracer = provider.getTracer('test-tracer');
-                const span = tracer.startSpan('child-span');
-                expect(span.spanContext.traceId).toBe(parentTraceId);
-                expect(span.spanContext.parentSpanId).toBe(parentSpanId);
-            }
-            finally {
-                process.env.TRACEPARENT = originalEnv;
-            }
-        });
-    });
-    describe('cross-process context propagation', () => {
-        test('should preserve traceId when parent span is not in activeSpans', async () => {
-            // 模拟跨进程场景：
-            // 1. 主进程创建 root span
-            // 2. bash tool 创建 child span 并将其 spanId 传给子进程
-            // 3. 子进程结束时，主进程的 child span 已经不在 activeSpans 中
-            // 4. 此时应该保留 traceId，而不是清空上下文
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            // 主进程创建 root span (模拟 agent.component.executeTool)
-            const rootSpan = tracer.startSpan('root-span');
-            const rootSpanId = rootSpan.spanContext.spanId;
-            const traceId = rootSpan.spanContext.traceId;
-            // 主进程创建 child span (模拟 bash tool)
-            const childSpan = tracer.startSpan('bash: ls');
-            const childSpanId = childSpan.spanContext.spanId;
-            // child span 的 parent 是 root span
-            expect(childSpan.spanContext.parentSpanId).toBe(rootSpanId);
-            expect(childSpan.spanContext.traceId).toBe(traceId);
-            // 结束 child span（模拟子进程完成）
-            childSpan.end();
-            // 关键验证：结束 child span 后，即使 root span 仍在 activeSpans 中，
-            // currentContext 应该恢复为 root span 的上下文
-            const ctxAfterChild = tracer.getCurrentContext();
-            expect(ctxAfterChild).toBeDefined();
-            expect(ctxAfterChild.traceId).toBe(traceId);
-            expect(ctxAfterChild.spanId).toBe(rootSpanId);
-            // 结束 root span
-            rootSpan.end();
-            // 验证：root span 结束后，currentContext 被清空
-            expect(tracer.getCurrentContext()).toBeUndefined();
-        });
-        test('should preserve traceId when ending span with non-existent parent', async () => {
-            // 模拟跨进程场景：子进程结束时找不到父 span
-            // 这是修复的关键场景
-            await provider.initialize();
-            const tracer = provider.getTracer('test-tracer');
-            // 创建父 span (在主进程中)
-            const parentSpan = tracer.startSpan('parent-span');
-            const parentSpanId = parentSpan.spanContext.spanId;
-            const traceId = parentSpan.spanContext.traceId;
-            // 创建子 span (模拟 bash tool 创建的 span)
-            const childSpan = tracer.startSpan('bash-span');
-            expect(childSpan.spanContext.parentSpanId).toBe(parentSpanId);
-            // 模拟跨进程场景：从 activeSpans 中移除父 span
-            // 这模拟了子进程无法访问主进程 activeSpans 的情况
-            // 手动从 activeSpans 中删除父 span
-            tracer.activeSpans.delete(parentSpanId);
-            // 结束子 span（此时父 span 不在 activeSpans 中）
-            childSpan.end();
-            // 关键验证：currentContext 应该保留 traceId，而不是被清空
-            // 这样后续创建的 span 能继承 traceId
-            const ctxAfterEnd = tracer.getCurrentContext();
-            expect(ctxAfterEnd).toBeDefined();
-            expect(ctxAfterEnd.traceId).toBe(traceId);
-            // 创建新 span，应该继承 traceId（而不是创建新的根）
-            const newSpan = tracer.startSpan('new-span');
-            expect(newSpan.spanContext.traceId).toBe(traceId);
-            newSpan.end();
-            parentSpan.end();
-        });
-    });
-});
-//# sourceMappingURL=tracer-provider.test.js.map

package/dist/core/src/env/log-trace/span-storage.d.ts

@@ -1,38 +0,0 @@
-/**
- * @fileoverview Span Storage 实现
- *
- * 提供 SQLiteSpanStorage 一种实现，用于持久化存储 span 数据
- */
-import { type Span, type SpanStorage, type TraceInfo } from "./types";
-export type { SpanStorage, TraceInfo } from "./types";
-/**
- * SQLite 存储实现
- *
- * 使用 Bun 内置的 bun:sqlite 模块进行持久化存储
- *
- * 注意：此实现仅支持 SQLite 文件存储，不支持 :memory: 模式
- * WAL 模式默认启用以支持跨进程并发访问
- */
-export declare class SQLiteSpanStorage implements SpanStorage {
-    private db;
-    private dbPath;
-    private initialized;
-    /**
-     * 创建 SQLiteSpanStorage 实例
-     *
-     * @param dbPath SQLite 数据库文件路径（必填）
-     * @throws Error 如果 dbPath 为空或为 :memory:
-     */
-    constructor(dbPath: string);
-    initialize(): Promise<void>;
-    save(span: Span): void;
-    saveBatch(spans: Span[]): void;
-    findByTraceId(traceId: string): Span[];
-    findBySpanId(spanId: string): Span | undefined;
-    listTraces(limit?: number): TraceInfo[];
-    deleteByTraceId(traceId: string): void;
-    close(): void;
-    private rowToSpan;
-    private buildTree;
-}
-//# sourceMappingURL=span-storage.d.ts.map

package/dist/core/src/env/log-trace/span-storage.js

@@ -1,185 +0,0 @@
-/**
- * @fileoverview Span Storage 实现
- *
- * 提供 SQLiteSpanStorage 一种实现，用于持久化存储 span 数据
- */
-// ============================================================================
-// SQLiteSpanStorage
-// ============================================================================
-/**
- * SQLite 存储实现
- *
- * 使用 Bun 内置的 bun:sqlite 模块进行持久化存储
- *
- * 注意：此实现仅支持 SQLite 文件存储，不支持 :memory: 模式
- * WAL 模式默认启用以支持跨进程并发访问
- */
-export class SQLiteSpanStorage {
-    db = null;
-    dbPath;
-    initialized = false;
-    /**
-     * 创建 SQLiteSpanStorage 实例
-     *
-     * @param dbPath SQLite 数据库文件路径（必填）
-     * @throws Error 如果 dbPath 为空或为 :memory:
-     */
-    constructor(dbPath) {
-        // 验证：dbPath 必填，且不能是 :memory:
-        if (!dbPath) {
-            throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
-        }
-        if (dbPath === ":memory:") {
-            throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
-        }
-        this.dbPath = dbPath;
-    }
-    async initialize() {
-        if (this.initialized)
-            return;
-        // 使用 Bun 内置的 bun:sqlite
-        const { Database } = require("bun:sqlite");
-        // 确保目录存在
-        const fs = require("fs");
-        const path = require("path");
-        const dir = path.dirname(this.dbPath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        this.db = new Database(this.dbPath);
-        // 启用 WAL 模式以支持更好的并发写入
-        // WAL (Write-Ahead Logging) 允许读操作与写操作并发执行
-        // WAL 模式支持跨进程访问，是本实现的核心特性
-        this.db.run("PRAGMA journal_mode=WAL");
-        // 设置 busy_timeout 以处理锁冲突（5秒）
-        this.db.run("PRAGMA busy_timeout=5000");
-        // 使用 NORMAL 同步模式，平衡性能和数据安全
-        this.db.run("PRAGMA synchronous=NORMAL");
-        // 创建表
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS span (
-        span_id TEXT PRIMARY KEY,
-        trace_id TEXT NOT NULL,
-        parent_span_id TEXT,
-        name TEXT NOT NULL,
-        kind TEXT NOT NULL,
-        status TEXT NOT NULL,
-        start_time INTEGER NOT NULL,
-        end_time INTEGER,
-        attributes TEXT,
-        result TEXT,
-        error TEXT,
-        time_created INTEGER NOT NULL
-      )
-    `);
-        this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
-        this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
-        this.initialized = true;
-    }
-    save(span) {
-        if (!this.db)
-            return;
-        const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO span 
-      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        // result 处理：如果已经是字符串，直接存储；否则 stringify
-        const resultValue = span.result !== undefined && span.result !== null
-            ? (typeof span.result === "string" ? span.result : JSON.stringify(span.result))
-            : null;
-        stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
-    }
-    saveBatch(spans) {
-        for (const span of spans) {
-            this.save(span);
-        }
-    }
-    findByTraceId(traceId) {
-        if (!this.db)
-            return [];
-        const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
-        return this.buildTree(rows.map(this.rowToSpan));
-    }
-    findBySpanId(spanId) {
-        if (!this.db)
-            return undefined;
-        const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
-        return row ? this.rowToSpan(row) : undefined;
-    }
-    listTraces(limit = 10) {
-        if (!this.db)
-            return [];
-        const rows = this.db.prepare(`
-      SELECT trace_id, 
-             MIN(start_time) as start_time,
-             MAX(end_time) as end_time,
-             COUNT(*) as span_count
-      FROM span 
-      GROUP BY trace_id 
-      ORDER BY start_time DESC 
-      LIMIT ?
-    `).all(limit);
-        return rows.map((row) => ({
-            traceId: row.trace_id,
-            rootSpanName: "unknown",
-            startTime: row.start_time,
-            endTime: row.end_time,
-            duration: row.end_time - row.start_time,
-            spanCount: row.span_count,
-            status: "ok",
-        }));
-    }
-    deleteByTraceId(traceId) {
-        if (this.db) {
-            this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
-        }
-    }
-    close() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-        }
-    }
-    rowToSpan(row) {
-        return {
-            traceId: row.trace_id,
-            spanId: row.span_id,
-            parentSpanId: row.parent_span_id,
-            name: row.name,
-            kind: row.kind,
-            status: row.status,
-            startTime: row.start_time,
-            endTime: row.end_time,
-            attributes: row.attributes ? JSON.parse(row.attributes) : {},
-            // result 保持原样存储，不进行额外的 parse
-            // 如果原来是对象，会被序列化为字符串存储
-            // 如果原来就是字符串（已经是序列化的），也会保持原样
-            result: row.result || undefined,
-            error: row.error || undefined,
-        };
-    }
-    buildTree(spans) {
-        const spanMap = new Map();
-        const roots = [];
-        for (const span of spans) {
-            spanMap.set(span.spanId, { ...span, children: [] });
-        }
-        for (const span of spanMap.values()) {
-            if (span.parentSpanId) {
-                const parent = spanMap.get(span.parentSpanId);
-                if (parent) {
-                    parent.children.push(span);
-                }
-                else {
-                    roots.push(span);
-                }
-            }
-            else {
-                roots.push(span);
-            }
-        }
-        return roots;
-    }
-}
-//# sourceMappingURL=span-storage.js.map

package/dist/core/src/env/log-trace/span-storage.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * @fileoverview SQLiteSpanStorage WAL 模式测试
- */
-export {};
-//# sourceMappingURL=span-storage.test.d.ts.map

package/dist/core/src/env/log-trace/span-storage.test.js

@@ -1,121 +0,0 @@
-/**
- * @fileoverview SQLiteSpanStorage WAL 模式测试
- */
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { SQLiteSpanStorage } from "./span-storage.js";
-import { join } from 'path';
-import { mkdtempSync, rmSync } from 'fs';
-import os from 'os';
-describe('SQLiteSpanStorage with WAL', () => {
-    let storage;
-    let tempDir;
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(os.tmpdir(), 'span-storage-test-'));
-        storage = new SQLiteSpanStorage(join(tempDir, 'traces.db'));
-    });
-    afterEach(() => {
-        storage.close();
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-    describe('WAL mode', () => {
-        test('should enable WAL journal mode', async () => {
-            await storage.initialize();
-            // WAL mode should be enabled
-            // We can verify by checking the database journal mode
-            const spans = storage.findBySpanId('non-existent');
-            expect(spans).toBeUndefined();
-        });
-        test('should save and retrieve spans', async () => {
-            await storage.initialize();
-            const span = {
-                traceId: 'trace-123',
-                spanId: 'span-456',
-                parentSpanId: undefined,
-                name: 'test-span',
-                kind: 'internal',
-                status: 'ok',
-                startTime: Date.now(),
-                endTime: Date.now() + 100,
-                attributes: { key: 'value' },
-            };
-            storage.save(span);
-            const retrieved = storage.findBySpanId('span-456');
-            expect(retrieved).toBeDefined();
-            expect(retrieved.name).toBe('test-span');
-            expect(retrieved.traceId).toBe('trace-123');
-        });
-        test('should handle concurrent writes', async () => {
-            await storage.initialize();
-            // Simulate concurrent writes
-            const promises = [];
-            for (let i = 0; i < 10; i++) {
-                const span = {
-                    traceId: 'trace-concurrent',
-                    spanId: `span-concurrent-${i}`,
-                    parentSpanId: undefined,
-                    name: `concurrent-span-${i}`,
-                    kind: 'internal',
-                    status: 'ok',
-                    startTime: Date.now(),
-                    attributes: {},
-                };
-                promises.push(Promise.resolve(storage.save(span)));
-            }
-            await Promise.all(promises);
-            // All spans should be saved
-            const traces = storage.findByTraceId('trace-concurrent');
-            expect(traces.length).toBeGreaterThanOrEqual(10);
-        });
-        test('should save batch of spans', async () => {
-            await storage.initialize();
-            const spans = Array.from({ length: 5 }, (_, i) => ({
-                traceId: 'trace-batch',
-                spanId: `span-batch-${i}`,
-                parentSpanId: undefined,
-                name: `batch-span-${i}`,
-                kind: 'internal',
-                status: 'ok',
-                startTime: Date.now(),
-                attributes: {},
-            }));
-            storage.saveBatch(spans);
-            const traces = storage.findByTraceId('trace-batch');
-            expect(traces.length).toBe(5);
-        });
-        test('should list traces', async () => {
-            await storage.initialize();
-            // Save some spans
-            for (let i = 0; i < 5; i++) {
-                storage.save({
-                    traceId: `trace-list-${i}`,
-                    spanId: `span-list-${i}`,
-                    parentSpanId: undefined,
-                    name: `list-span-${i}`,
-                    kind: 'internal',
-                    status: 'ok',
-                    startTime: Date.now(),
-                    attributes: {},
-                });
-            }
-            const traces = storage.listTraces(10);
-            expect(traces.length).toBeGreaterThanOrEqual(5);
-        });
-        test('should delete by traceId', async () => {
-            await storage.initialize();
-            storage.save({
-                traceId: 'trace-to-delete',
-                spanId: 'span-to-delete',
-                parentSpanId: undefined,
-                name: 'delete-span',
-                kind: 'internal',
-                status: 'ok',
-                startTime: Date.now(),
-                attributes: {},
-            });
-            storage.deleteByTraceId('trace-to-delete');
-            const retrieved = storage.findBySpanId('span-to-delete');
-            expect(retrieved).toBeUndefined();
-        });
-    });
-});
-//# sourceMappingURL=span-storage.test.js.map

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

@@ -1,29 +0,0 @@
-/**
- * @fileoverview Trace Context 实现
- *
- * 基于 AsyncLocalStorage 的轻量级追踪上下文实现
- */
-import { AsyncLocalStorage } from "async_hooks";
-import { type SpanContext, type ITraceContext, type TraceContextOptions } from "./types";
-interface RequestContextData {
-    requestId: string;
-    sessionId?: string;
-    timestamp: number;
-    spanContext?: SpanContext;
-}
-declare const contextStore: AsyncLocalStorage<RequestContextData>;
-export { contextStore };
-/**
- * 获取当前 TraceContext 实例
- */
-export declare function getTraceContext(): ITraceContext;
-/**
- * 设置 TraceContext 实现（用于测试或替换）
- */
-export declare function setTraceContext(impl: ITraceContext): void;
-/**
- * 初始化 TraceContext
- */
-export declare function initTraceContext(options?: TraceContextOptions): ITraceContext;
-export type { ITraceContext, TraceContextOptions } from "./types";
-//# sourceMappingURL=trace-context.d.ts.map