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

package/dist/core/src/env/log-trace/decorator-otel.test.js

@@ -0,0 +1,204 @@
+/**
+ * @fileoverview @Traced 装饰器 OTel 集成测试
+ *
+ * 使用 OpenTelemetry 方式测试装饰器功能
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { TracedAs, wrapFunction } from "./decorator.js";
+import { getTracerProvider, resetTracerProvider } from "./opentelemetry/tracer-provider.js";
+describe("@Traced Decorator (OTel)", () => {
+    let tracer;
+    let provider;
+    beforeEach(async () => {
+        resetTracerProvider();
+        provider = getTracerProvider();
+        await provider.initialize();
+        tracer = provider.getTracer('test-decorator');
+    });
+    afterEach(() => {
+        resetTracerProvider();
+    });
+    describe("wrapFunction - 非 async 函数", () => {
+        test("should wrap a sync function and create span", async () => {
+            const fn = (a, b) => a + b;
+            const wrapped = wrapFunction(fn, "add");
+            const result = wrapped(1, 2);
+            expect(result).toBe(3);
+            // 验证函数正常工作，span 创建和结束都应该成功
+        });
+        test("should record sync function result", async () => {
+            const fn = () => ({ data: "test" });
+            const wrapped = wrapFunction(fn, "getData", { recordResult: true });
+            const result = wrapped();
+            expect(result).toEqual({ data: "test" });
+        });
+        test("should record sync function error", async () => {
+            const fn = () => {
+                throw new Error("sync error");
+            };
+            const wrapped = wrapFunction(fn, "syncErrorFn", { recordError: true });
+            expect(() => wrapped()).toThrow("sync error");
+        });
+        test("should support methods with parameters", async () => {
+            class TestService {
+                methodWithParams(a, b) {
+                    return `${a}-${b}`;
+                }
+            }
+            __decorate([
+                TracedAs('method-with-params'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Number, String]),
+                __metadata("design:returntype", String)
+            ], TestService.prototype, "methodWithParams", null);
+            const service = new TestService();
+            const result = service.methodWithParams(1, 'test');
+            expect(result).toBe('1-test');
+        });
+        test("should support async methods", async () => {
+            class TestService {
+                async asyncMethod() {
+                    return 'async result';
+                }
+            }
+            __decorate([
+                TracedAs('async-method'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", Promise)
+            ], TestService.prototype, "asyncMethod", null);
+            const service = new TestService();
+            const result = await service.asyncMethod();
+            expect(result).toBe('async result');
+        });
+    });
+    describe("nesting", () => {
+        test("should maintain context across nested decorated methods", async () => {
+            // 装饰器内部使用 getTracerProvider().getTracer("decorator")
+            // 我们获取同一个 tracer 来检查上下文
+            const decoratorTracer = getTracerProvider().getTracer("decorator");
+            class TestService {
+                parent() {
+                    return this.child();
+                }
+                child() {
+                    return 'child result';
+                }
+            }
+            __decorate([
+                TracedAs('parent'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", String)
+            ], TestService.prototype, "parent", null);
+            __decorate([
+                TracedAs('child'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", String)
+            ], TestService.prototype, "child", null);
+            const service = new TestService();
+            const result = service.parent();
+            expect(result).toBe('child result');
+            // 验证嵌套调用正常工作（函数返回正确结果）
+            // 上下文在 span.end() 后会被清除
+        });
+        test("should handle deeply nested decorated methods", async () => {
+            class TestService {
+                level1() {
+                    return this.level2();
+                }
+                level2() {
+                    return this.level3();
+                }
+                level3() {
+                    return 'deep result';
+                }
+            }
+            __decorate([
+                TracedAs('level1'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", String)
+            ], TestService.prototype, "level1", null);
+            __decorate([
+                TracedAs('level2'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", String)
+            ], TestService.prototype, "level2", null);
+            __decorate([
+                TracedAs('level3'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", String)
+            ], TestService.prototype, "level3", null);
+            const service = new TestService();
+            const result = service.level1();
+            expect(result).toBe('deep result');
+        });
+    });
+    describe("span attributes", () => {
+        test("should record method args as params", async () => {
+            class TestService {
+                withArgs(a, b) {
+                    return `${a}-${b}`;
+                }
+            }
+            __decorate([
+                TracedAs('with-args'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Number, String]),
+                __metadata("design:returntype", String)
+            ], TestService.prototype, "withArgs", null);
+            const service = new TestService();
+            const result = service.withArgs(42, 'hello');
+            expect(result).toBe('42-hello');
+        });
+        test("should maintain span tree in storage after nested calls", async () => {
+            // 捕获第一个 span 的 traceId
+            let capturedTraceId;
+            class TestService {
+                outer() {
+                    // 捕获开始时的 traceId
+                    const current = tracer.getCurrentContext();
+                    if (current && !capturedTraceId) {
+                        capturedTraceId = current.traceId;
+                    }
+                    return this.inner();
+                }
+                inner() {
+                    return 'inner';
+                }
+            }
+            __decorate([
+                TracedAs('outer'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", String)
+            ], TestService.prototype, "outer", null);
+            __decorate([
+                TracedAs('inner'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", String)
+            ], TestService.prototype, "inner", null);
+            const service = new TestService();
+            service.outer();
+            // 验证函数调用正常工作
+            // 注意：由于装饰器使用 getTracerProvider().getTracer("decorator")
+            // 而测试使用 getTracerProvider().getTracer('test-decorator')
+            // 可能不是同一个实例，但调用应该仍然正常工作
+        });
+    });
+});
+//# sourceMappingURL=decorator-otel.test.js.map

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

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview @Traced 装饰器实现
+ *
+ * 提供函数包装和装饰器来自动创建 Span
+ * 支持注解到 async 函数和非 async 函数上
+ * 使用 OpenTelemetry 标准方式
+ */
+export interface TracedOptions {
+    name?: string;
+    recordParams?: boolean;
+    recordResult?: boolean;
+    recordError?: boolean;
+    log?: boolean;
+    maxLogSize?: number;
+    paramFilter?: (args: any[], argNames?: string[]) => Record<string, any>;
+}
+/**
+ * @Traced 装饰器工厂
+ */
+export declare function Traced(options?: TracedOptions): <T extends (...args: any[]) => any>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+/**
+ * @TracedAs 装饰器工厂 - 使用自定义名称
+ */
+export declare function TracedAs(name: string, options?: Omit<TracedOptions, "name">): <T extends (...args: any[]) => any>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+/**
+ * @TracedLightweight 装饰器工厂 - 轻量级追踪
+ */
+export declare function TracedLightweight(options?: {
+    log?: boolean;
+    maxLogSize?: number;
+}): <T extends (...args: any[]) => any>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+/**
+ * 包装函数以自动创建 Span
+ *
+ * 同时支持 async 函数和非 async 函数：
+ * - async 函数：自动检测 Promise 并正确处理
+ * - 非 async 函数：同步执行，直接返回结果
+ */
+export declare function wrapFunction<T extends (...args: any[]) => any>(fn: T, name: string, options?: {
+    recordParams?: boolean;
+    recordResult?: boolean;
+    recordError?: boolean;
+    log?: boolean;
+    maxLogSize?: number;
+    paramFilter?: (args: any[], argNames?: string[]) => Record<string, any>;
+}): T;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/core/src/env/log-trace/decorator.js

@@ -0,0 +1,190 @@
+/**
+ * @fileoverview @Traced 装饰器实现
+ *
+ * 提供函数包装和装饰器来自动创建 Span
+ * 支持注解到 async 函数和非 async 函数上
+ * 使用 OpenTelemetry 标准方式
+ */
+import { getTracerProvider } from "./opentelemetry/tracer-provider.js";
+import { createLogger, simplifyFilePath, getMaxOutput } from "./logger.js";
+/**
+ * @Traced 装饰器工厂
+ */
+export function Traced(options) {
+    return function (target, propertyKey, descriptor) {
+        const originalFn = descriptor.value;
+        const spanName = options?.name || propertyKey;
+        descriptor.value = wrapFunction(originalFn, spanName, {
+            recordParams: options?.recordParams ?? true,
+            recordResult: options?.recordResult ?? false,
+            recordError: options?.recordError ?? true,
+            log: options?.log ?? false,
+            maxLogSize: options?.maxLogSize,
+            paramFilter: options?.paramFilter,
+        });
+        return descriptor;
+    };
+}
+/**
+ * @TracedAs 装饰器工厂 - 使用自定义名称
+ */
+export function TracedAs(name, options) {
+    return Traced({ name, ...options });
+}
+/**
+ * @TracedLightweight 装饰器工厂 - 轻量级追踪
+ */
+export function TracedLightweight(options) {
+    return Traced({ recordParams: false, recordResult: false, log: options?.log ?? false, maxLogSize: options?.maxLogSize });
+}
+/**
+ * 包装函数以自动创建 Span
+ *
+ * 同时支持 async 函数和非 async 函数：
+ * - async 函数：自动检测 Promise 并正确处理
+ * - 非 async 函数：同步执行，直接返回结果
+ */
+export function wrapFunction(fn, name, options) {
+    const shouldLog = options?.log ?? false;
+    const getMaxLogSize = () => {
+        if (options?.maxLogSize !== undefined) {
+            return options.maxLogSize;
+        }
+        const configMaxOutput = getMaxOutput();
+        return configMaxOutput !== undefined ? configMaxOutput : 500;
+    };
+    const truncate = (obj) => {
+        if (obj === undefined)
+            return undefined;
+        if (obj === null)
+            return null;
+        const maxLogSize = getMaxLogSize();
+        let str;
+        try {
+            str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
+        }
+        catch (e) {
+            str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+        }
+        if (maxLogSize > 0 && str.length > maxLogSize) {
+            return str.slice(0, maxLogSize) + " [TRUNCATED]";
+        }
+        try {
+            return JSON.parse(str);
+        }
+        catch {
+            return str;
+        }
+    };
+    const truncateString = (obj) => {
+        if (obj === undefined)
+            return "undefined";
+        if (obj === null)
+            return "null";
+        const maxLogSize = getMaxLogSize();
+        let str;
+        try {
+            str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
+        }
+        catch (e) {
+            str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+        }
+        return maxLogSize > 0 && str.length > maxLogSize ? str.slice(0, maxLogSize) + " [TRUNCATED]" : str;
+    };
+    const TRACE_LOG_PREFIX = "[TRACE]";
+    const getCallerLocation = () => {
+        const originalLimit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 15;
+        const err = new Error();
+        Error.captureStackTrace(err, getCallerLocation);
+        const stack = err.stack?.split("\n") || [];
+        Error.stackTraceLimit = originalLimit;
+        for (let i = 1; i < stack.length; i++) {
+            const line = stack[i];
+            if (line.includes("decorator.ts") || line.includes("decorator.js") || line.includes("logFn") || line.includes("getCallerLocation"))
+                continue;
+            const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
+            if (match) {
+                const filePath = match[1];
+                if (!filePath || filePath === "native")
+                    continue;
+                const relativePath = simplifyFilePath(filePath);
+                return `${relativePath}:${match[2]}`;
+            }
+        }
+        return "";
+    };
+    const logFn = (event, argsOrData, callerLocation) => {
+        if (!shouldLog)
+            return;
+        const logger = createLogger("traced:" + name);
+        const tag = event === "enter" ? ">>>" : event === "quit" ? "<<<" : "!!!";
+        const prefix = `${TRACE_LOG_PREFIX} ${tag} ${name}`;
+        const originalFnLocation = callerLocation || getCallerLocation();
+        const logMessage = (msg, data) => {
+            if (data !== undefined) {
+                logger.info(`${prefix} ${msg}: ${truncateString(data)}`, { callerLocation: originalFnLocation });
+            }
+            else {
+                logger.info(`${prefix} ${msg}`, { callerLocation: originalFnLocation });
+            }
+        };
+        if (event === "enter") {
+            logMessage("enter", argsOrData);
+        }
+        else if (event === "quit") {
+            logMessage("quit", options?.recordResult ? argsOrData : undefined);
+        }
+        else {
+            logMessage("error", argsOrData);
+        }
+    };
+    // 包装函数 - 支持 async 和非 async 函数
+    return function (...args) {
+        // 获取 OTel Tracer
+        const tracer = getTracerProvider().getTracer("roy-tracer");
+        const attributes = {};
+        if (options?.recordParams !== false) {
+            if (options?.paramFilter) {
+                attributes["params"] = truncate(options.paramFilter(args));
+            }
+            else {
+                attributes["params"] = truncate(args);
+            }
+        }
+        // 在 enter 时获取调用位置并保存
+        const callerLocation = getCallerLocation();
+        logFn("enter", args, callerLocation);
+        // 启动 OTel Span
+        const span = tracer.startSpan(name, { attributes });
+        try {
+            const result = fn.call(this, ...args);
+            // 处理 Promise
+            if (result && typeof result === 'object' && typeof result.then === 'function') {
+                return result.then((resolved) => {
+                    span.setAttribute('result', JSON.stringify(truncate(resolved)));
+                    span.end(resolved);
+                    logFn("quit", options?.recordResult ? resolved : undefined, callerLocation);
+                    return resolved;
+                }, (rejected) => {
+                    span.setAttribute('error', String(rejected));
+                    span.end(undefined, rejected instanceof Error ? rejected : new Error(String(rejected)));
+                    logFn("error", rejected.message, callerLocation);
+                    throw rejected;
+                });
+            }
+            // 同步方法
+            span.setAttribute('result', JSON.stringify(truncate(result)));
+            span.end(result);
+            logFn("quit", options?.recordResult ? result : undefined, callerLocation);
+            return result;
+        }
+        catch (error) {
+            span.setAttribute('error', String(error));
+            span.end(undefined, error instanceof Error ? error : new Error(String(error)));
+            logFn("error", error.message, callerLocation);
+            throw error;
+        }
+    };
+}
+//# sourceMappingURL=decorator.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Log & Trace 模块导出
+ *
+ * OpenTelemetry 标准接口
+ */
+export { type Span, type SpanContext, type SpanAttributes, type TraceInfo, type SpanStorage, type ITraceContext, type LogLevel, type LoggerConfig, type ILogger, type TraceContextOptions, } from "./types";
+export { SpanKind, SpanStatus } from "./types";
+export { SQLiteSpanStorage } from "./span-storage";
+export { LogTraceComponent, type LogTraceConfig, type LogTraceComponentOptions, LogTraceConfigSchema, getDefaultLogDir, getDefaultSpanDbPath, } from "./log-trace-component";
+export { OTelTracerProvider, getTracerProvider, resetTracerProvider, type OTelTracer, type OTelSpan, type SpanOptions, } from "./opentelemetry/tracer-provider";
+export { propagation, serialize, parse, type ExtractedContext, } from "./opentelemetry/propagation";
+export { injectToEnv, injectToEnvWithContext, injectToEnvFromCarrier, getTraceparentHeader, type EnvCarrier, } from "./opentelemetry/propagation-env";
+export { createLogger, setQuietMode, isQuietMode, setConfigComponent as setLoggerConfigComponent, getLogLevel, getLogLevels, getLogDir, getLogFile, setLogDirOverride, getLogDirOverride, simplifyFilePath, getMaxOutput, } from "./logger";
+export { TracedAs, Traced, TracedLightweight, wrapFunction, type TracedOptions } from "./decorator";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/log-trace/index.js

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview Log & Trace 模块导出
+ *
+ * OpenTelemetry 标准接口
+ */
+export { SpanKind, SpanStatus } from "./types.js";
+// Storage
+export { SQLiteSpanStorage } from "./span-storage.js";
+// Component
+export { LogTraceComponent, LogTraceConfigSchema, getDefaultLogDir, getDefaultSpanDbPath, } from "./log-trace-component.js";
+// OpenTelemetry Tracer Provider
+export { OTelTracerProvider, getTracerProvider, resetTracerProvider, } from "./opentelemetry/tracer-provider.js";
+// OpenTelemetry Propagation
+export { propagation, serialize, parse, } from "./opentelemetry/propagation.js";
+export { injectToEnv, injectToEnvWithContext, injectToEnvFromCarrier, getTraceparentHeader, } from "./opentelemetry/propagation-env.js";
+// Logger
+export { createLogger, setQuietMode, isQuietMode, setConfigComponent as setLoggerConfigComponent, getLogLevel, getLogLevels, getLogDir, getLogFile, setLogDirOverride, getLogDirOverride, simplifyFilePath, getMaxOutput, } from "./logger.js";
+// Decorator
+export { TracedAs, Traced, TracedLightweight, wrapFunction } from "./decorator.js";
+//# sourceMappingURL=index.js.map