@ai-setting/roy-agent-cli 1.3.15 → 1.3.16

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

@@ -0,0 +1,291 @@
+/**
+ * @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

@@ -0,0 +1,38 @@
+/**
+ * @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

@@ -0,0 +1,185 @@
+/**
+ * @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

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

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

@@ -0,0 +1,121 @@
+/**
+ * @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

@@ -0,0 +1,29 @@
+/**
+ * @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