coze_lab 0.1.0

package/scripts/openclaw/dist/cozeloop-exporter.js

@@ -0,0 +1,442 @@
+import { trace, context, SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import { BasicTracerProvider, BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { Resource } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_INSTANCE_ID } from "@opentelemetry/semantic-conventions";
+import { hostname } from "os";
+import { basename, join } from "path";
+import { createRequire } from "node:module";
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import https from "https";
+
+const require = createRequire(import.meta.url);
+const { version: PLUGIN_VERSION } = require("../package.json");
+
+// ── Token refresh helpers ─────────────────────────────────────────────────
+const _CLIENT_ID = "56089404009908161803155625287505.app.coze";
+const _COZE_API  = "https://api.coze.cn";
+const _REFRESH_THRESHOLD_MS = 10 * 60 * 1000;
+const _CREDS_PATH = join(homedir(), ".cozeloop", "credentials.json");
+
+function _loadCreds() {
+    try { return JSON.parse(readFileSync(_CREDS_PATH, "utf8")); }
+    catch { return null; }
+}
+
+function _saveCreds(c) {
+    try {
+        mkdirSync(join(homedir(), ".cozeloop"), { recursive: true });
+        writeFileSync(_CREDS_PATH, JSON.stringify(c, null, 2), { mode: 0o600 });
+    } catch { /* non-fatal */ }
+}
+
+async function _refreshToken(refreshTok) {
+    return new Promise((resolve) => {
+        const body = JSON.stringify({ grant_type: "refresh_token", client_id: _CLIENT_ID, refresh_token: refreshTok });
+        const req = https.request(`${_COZE_API}/api/permission/oauth2/token`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+        }, (res) => {
+            let buf = "";
+            res.on("data", c => buf += c);
+            res.on("end", () => {
+                try {
+                    const d = JSON.parse(buf);
+                    if (d.access_token) {
+                        const creds = {
+                            access_token: d.access_token,
+                            refresh_token: d.refresh_token ?? refreshTok,
+                            expires_at: (d.expires_in ?? 0) * 1000,  // unix timestamp in seconds
+                        };
+                        _saveCreds(creds);
+                        resolve(creds.access_token);
+                    } else { resolve(null); }
+                } catch { resolve(null); }
+            });
+        });
+        req.on("error", () => resolve(null));
+        req.setTimeout(10000, () => { req.destroy(); resolve(null); });
+        req.write(body);
+        req.end();
+    });
+}
+
+async function getRefreshedToken(currentAuthorization) {
+    const creds = _loadCreds();
+    if (!creds) return currentAuthorization; // no creds file, keep as-is
+    const remaining = (creds.expires_at ?? 0) - Date.now();
+    if (remaining > _REFRESH_THRESHOLD_MS) return `Bearer ${creds.access_token}`;
+    if (creds.refresh_token) {
+        const newToken = await _refreshToken(creds.refresh_token);
+        if (newToken) return `Bearer ${newToken}`;
+    }
+    return currentAuthorization; // fallback
+}
+// ─────────────────────────────────────────────────────────────────────────
+
+export class CozeloopExporter {
+    config;
+    api;
+    provider = null;
+    tracer = null;
+    initialized = false;
+    initPromise = null;
+    // Per-trace context: keyed by the plugin-level rootSpanId so that
+    // concurrent or overlapping traces never stomp on each other.
+    traceContexts = new Map();
+    openSpans = new Map();
+    // Extra attributes derived from environment variables, applied to every span.
+    envAttributes = {};
+    constructor(api, config) {
+        this.api = api;
+        this.config = config;
+        this.envAttributes = this.parseEnvAttributes();
+    }
+    parseEnvAttributes() {
+        const attrs = {};
+        // COZE_PROJECT_ID -> project_id
+        const projectId = process.env.COZE_PROJECT_ID?.trim();
+        if (projectId) {
+            attrs["project_id"] = projectId;
+        }
+        // COZELOOP_UDF_TAGS -> udf_ prefixed keys
+        const tagsRaw = process.env.COZELOOP_UDF_TAGS?.trim();
+        if (tagsRaw) {
+            const pairs = tagsRaw.split(",");
+            for (const pair of pairs) {
+                const eqIdx = pair.indexOf("=");
+                if (eqIdx < 0) {
+                    this.api.logger.error(`[CozeloopTrace] Invalid COZELOOP_UDF_TAGS entry (missing '='): "${pair}"`);
+                    continue;
+                }
+                const key = pair.substring(0, eqIdx);
+                const value = pair.substring(eqIdx + 1);
+                // Validate: key and value must not contain '=' or ','
+                if (key.includes("=") || key.includes(",")) {
+                    this.api.logger.error(`[CozeloopTrace] Invalid COZELOOP_UDF_TAGS key contains '=' or ',': "${key}"`);
+                    continue;
+                }
+                if (value.includes("=") || value.includes(",")) {
+                    this.api.logger.error(`[CozeloopTrace] Invalid COZELOOP_UDF_TAGS value contains '=' or ',': "${value}"`);
+                    continue;
+                }
+                if (!key) {
+                    this.api.logger.error(`[CozeloopTrace] Invalid COZELOOP_UDF_TAGS entry (empty key): "${pair}"`);
+                    continue;
+                }
+                attrs[`udf_${key}`] = value;
+            }
+        }
+        return attrs;
+    }
+    async refreshAuthIfNeeded() {
+        const fresh = await getRefreshedToken(this.config.authorization);
+        if (fresh && fresh !== this.config.authorization) {
+            this.api.logger.info("[CozeloopTrace] Token refreshed, re-initializing exporter...");
+            this.config.authorization = fresh;
+            // Reset so initialize() re-creates the exporter with the new token
+            this.initialized = false;
+            this.initPromise = null;
+            if (this.provider) {
+                try { await this.provider.shutdown(); } catch { /* ignore */ }
+                this.provider = null;
+                this.tracer = null;
+            }
+        }
+    }
+    async ensureInitialized() {
+        if (this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = this.initialize();
+        await this.initPromise;
+    }
+    async initialize() {
+        this.api.logger.info(`[CozeloopTrace] Initializing exporter...`);
+        const instanceName = this.config.serviceName || basename(process.cwd()) || "openclaw-agent";
+        const instanceId = `${instanceName}@${hostname()}:${process.pid}`;
+        const resource = new Resource({
+            [ATTR_SERVICE_NAME]: this.config.serviceName,
+            [ATTR_SERVICE_INSTANCE_ID]: instanceId,
+            "host.name": hostname(),
+        });
+        const authorization = this.config.authorization;
+        const workspaceId = this.config.workspaceId;
+        this.api.logger.info(`[CozeloopTrace] Using authorization, workspaceId=${workspaceId}, tokenLength=${authorization?.length}`);
+        const exporter = new OTLPTraceExporter({
+            url: `${this.config.endpoint}/v1/traces`,
+            headers: {
+                "Authorization": authorization,
+                "cozeloop-workspace-id": workspaceId,
+            },
+        });
+        this.provider = new BasicTracerProvider({ resource });
+        this.provider.addSpanProcessor(new BatchSpanProcessor(exporter, {
+            maxQueueSize: 100,
+            maxExportBatchSize: this.config.batchSize || 10,
+            scheduledDelayMillis: this.config.batchInterval || 5000,
+        }));
+        // Do NOT call this.provider.register() — it sets the global TracerProvider
+        // singleton, so if the plugin is activated more than once (e.g. gateway +
+        // plugins subsystem), the second instance would silently get a NOOP tracer
+        // while its hooks override those of the first instance, causing all trace
+        // operations to become no-ops.  Instead, obtain the tracer directly from
+        // our own provider instance.
+        this.tracer = this.provider.getTracer("openclaw-cozeloop-trace", PLUGIN_VERSION);
+        this.initialized = true;
+        this.api.logger.info(`[CozeloopTrace] Exporter initialized with Authorization, workspaceId=${workspaceId}`);
+    }
+    async startSpan(spanData, spanId) {
+        try {
+            await this.ensureInitialized();
+            this.doStartSpan(spanData, spanId);
+        }
+        catch (err) {
+            this.api.logger.error(`[CozeloopTrace] Failed to start span: ${err}`);
+        }
+    }
+    doStartSpan(spanData, spanId) {
+        if (!this.tracer)
+            return;
+        const spanKind = this.getSpanKind(spanData.type);
+        const isRoot = !spanData.parentSpanId;
+        const isAgent = spanData.type === "agent";
+        // Resolve parent context:
+        // - Root spans: no parent, use active context.
+        // - Agent/child spans: look up traceContexts by parentSpanId (which is
+        //   always the rootSpanId set by index.ts createSpan / ensureRootSpan).
+        const traceCtx = spanData.parentSpanId
+            ? this.traceContexts.get(spanData.parentSpanId)
+            : undefined;
+        if (!isRoot && !traceCtx && this.config.debug) {
+            const keys = Array.from(this.traceContexts.keys());
+            this.api.logger.info(`[CozeloopTrace] doStartSpan() cannot find parent context: ` +
+                `parentSpanId=${spanData.parentSpanId}, spanName=${spanData.name}, type=${spanData.type}, ` +
+                `traceContextKeys=[${keys.join(",")}]`);
+        }
+        let parentContext;
+        if (isRoot) {
+            parentContext = context.active();
+        }
+        else if (isAgent) {
+            parentContext = traceCtx?.rootContext || context.active();
+        }
+        else {
+            parentContext = traceCtx?.agentContext || traceCtx?.rootContext || context.active();
+        }
+        const runtimeTag = {
+            language: "nodejs",
+            library: "openclaw",
+        };
+        if (process.env.COZELOOP_SCENE) {
+            runtimeTag.scene = process.env.COZELOOP_SCENE;
+        }
+        const systemTagRuntime = JSON.stringify(runtimeTag);
+        const span = this.tracer.startSpan(spanData.name, {
+            kind: spanKind,
+            startTime: spanData.startTime,
+            attributes: {
+                "cozeloop.span_type": spanData.type,
+                "cozeloop.system_tag_runtime": systemTagRuntime,
+                ...this.envAttributes,
+                ...this.flattenAttributes(spanData.attributes),
+            },
+        }, parentContext);
+        if (isRoot) {
+            const rootContext = trace.setSpan(context.active(), span);
+            this.traceContexts.set(spanId, { rootSpan: span, rootContext });
+            if (this.config.debug) {
+                const sc = span.spanContext();
+                this.api.logger.info(`[CozeloopTrace] Created ROOT span: name=${spanData.name}, traceId=${sc.traceId}, spanId=${sc.spanId}`);
+            }
+        }
+        if (isAgent && traceCtx) {
+            traceCtx.agentSpan = span;
+            traceCtx.agentContext = trace.setSpan(traceCtx.rootContext, span);
+            if (this.config.debug) {
+                const sc = span.spanContext();
+                this.api.logger.info(`[CozeloopTrace] Created AGENT span: name=${spanData.name}, traceId=${sc.traceId}, spanId=${sc.spanId}`);
+            }
+        }
+        this.setSpanInputOutput(span, spanData);
+        this.openSpans.set(spanId, span);
+        if (this.config.debug && !isRoot && !isAgent) {
+            const spanContext = span.spanContext();
+            this.api.logger.info(`[CozeloopTrace] Started span: name=${spanData.name}, type=${spanData.type}, ` +
+                `traceId=${spanContext.traceId}, spanId=${spanContext.spanId}`);
+        }
+    }
+    endSpanById(spanId, endTime, additionalAttrs, output, input) {
+        const span = this.openSpans.get(spanId);
+        if (!span) {
+            if (this.config.debug) {
+                this.api.logger.info(`[CozeloopTrace] Span not found for ending: spanId=${spanId}`);
+            }
+            return;
+        }
+        if (additionalAttrs) {
+            for (const [key, value] of Object.entries(additionalAttrs)) {
+                if (value !== undefined && value !== null) {
+                    span.setAttribute(key, value);
+                }
+            }
+        }
+        if (input !== undefined) {
+            const inputStr = typeof input === "string" ? input : JSON.stringify(input);
+            span.setAttribute("cozeloop.input", inputStr.substring(0, 3200000));
+        }
+        if (output !== undefined) {
+            const outputStr = typeof output === "string" ? output : JSON.stringify(output);
+            span.setAttribute("cozeloop.output", outputStr.substring(0, 3200000));
+        }
+        span.setStatus({ code: SpanStatusCode.OK });
+        span.end(endTime || Date.now());
+        this.openSpans.delete(spanId);
+        if (this.config.debug) {
+            const sc = span.spanContext();
+            this.api.logger.info(`[CozeloopTrace] Ended span: spanId=${spanId}, traceId=${sc.traceId}`);
+        }
+    }
+    async export(spanData) {
+        try {
+            await this.ensureInitialized();
+            if (!this.tracer)
+                return;
+            const spanKind = this.getSpanKind(spanData.type);
+            const isRoot = !spanData.parentSpanId;
+            const isAgent = spanData.type === "agent";
+            const traceCtx = spanData.parentSpanId
+                ? this.traceContexts.get(spanData.parentSpanId)
+                : undefined;
+            if (!isRoot && !traceCtx) {
+                // Only warn for span types that are expected to be inside a trace
+                // (agent, model, tool). message/session/gateway spans may fire before
+                // the root span is created and that is normal.
+                const criticalTypes = new Set(["agent", "model", "tool"]);
+                if (criticalTypes.has(spanData.type) && this.config.debug) {
+                    const keys = Array.from(this.traceContexts.keys());
+                    this.api.logger.info(`[CozeloopTrace] export() cannot find parent context: ` +
+                        `parentSpanId=${spanData.parentSpanId}, spanName=${spanData.name}, type=${spanData.type}, ` +
+                        `traceContextKeys=[${keys.join(",")}]`);
+                }
+            }
+            let parentContext;
+            if (isRoot) {
+                parentContext = context.active();
+            }
+            else if (isAgent) {
+                parentContext = traceCtx?.rootContext || context.active();
+            }
+            else {
+                parentContext = traceCtx?.agentContext || traceCtx?.rootContext || context.active();
+            }
+            const runtimeTag = {
+                language: "nodejs",
+                library: "openclaw",
+            };
+            if (process.env.COZELOOP_SCENE) {
+                runtimeTag.scene = process.env.COZELOOP_SCENE;
+            }
+            const systemTagRuntime = JSON.stringify(runtimeTag);
+            const span = this.tracer.startSpan(spanData.name, {
+                kind: spanKind,
+                startTime: spanData.startTime,
+                attributes: {
+                    "cozeloop.span_type": spanData.type,
+                    "cozeloop.system_tag_runtime": systemTagRuntime,
+                    ...this.envAttributes,
+                    ...this.flattenAttributes(spanData.attributes),
+                },
+            }, parentContext);
+            if (isRoot) {
+                const rootContext = trace.setSpan(context.active(), span);
+                const spanId = spanData.spanId || "export-root";
+                this.traceContexts.set(spanId, { rootSpan: span, rootContext });
+                if (this.config.debug) {
+                    const sc = span.spanContext();
+                    this.api.logger.info(`[CozeloopTrace] Created ROOT span: name=${spanData.name}, traceId=${sc.traceId}, spanId=${sc.spanId}`);
+                }
+            }
+            this.setSpanInputOutput(span, spanData);
+            const hasError = spanData.attributes["error"] === true || spanData.attributes["tool.error"] === true;
+            if (hasError) {
+                span.setStatus({ code: SpanStatusCode.ERROR });
+            }
+            else {
+                span.setStatus({ code: SpanStatusCode.OK });
+            }
+            span.end(spanData.endTime || Date.now());
+            if (this.config.debug) {
+                const spanContext = span.spanContext();
+                this.api.logger.info(`[CozeloopTrace] Created span: name=${spanData.name}, type=${spanData.type}, ` +
+                    `traceId=${spanContext.traceId}, spanId=${spanContext.spanId}, isRoot=${isRoot}`);
+            }
+        }
+        catch (err) {
+            this.api.logger.error(`[CozeloopTrace] Failed to export span: ${err}`);
+        }
+    }
+    setSpanInputOutput(span, spanData) {
+        if (spanData.input !== undefined) {
+            const inputStr = typeof spanData.input === "string"
+                ? spanData.input
+                : JSON.stringify(spanData.input);
+            span.setAttribute("cozeloop.input", inputStr.substring(0, 3200000));
+        }
+        if (spanData.output !== undefined) {
+            const outputStr = typeof spanData.output === "string"
+                ? spanData.output
+                : JSON.stringify(spanData.output);
+            span.setAttribute("cozeloop.output", outputStr.substring(0, 3200000));
+        }
+    }
+    hasTraceContext(rootSpanId) {
+        return this.traceContexts.has(rootSpanId);
+    }
+    endTrace(rootSpanId) {
+        if (rootSpanId) {
+            this.traceContexts.delete(rootSpanId);
+        }
+        else {
+            this.traceContexts.clear();
+            this.openSpans.clear();
+        }
+        if (this.config.debug) {
+            this.api.logger.info(`[CozeloopTrace] Trace ended, context cleared${rootSpanId ? ` for rootSpanId=${rootSpanId}` : ' (all)'}`);
+        }
+    }
+    getSpanKind(type) {
+        switch (type) {
+            case "entry":
+            case "gateway":
+                return SpanKind.SERVER;
+            case "model":
+                return SpanKind.CLIENT;
+            case "tool":
+                return SpanKind.CLIENT;
+            default:
+                return SpanKind.INTERNAL;
+        }
+    }
+    flattenAttributes(attrs) {
+        const result = {};
+        for (const [key, value] of Object.entries(attrs)) {
+            if (value !== undefined && value !== null) {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    async flush() {
+        if (this.provider) {
+            await this.provider.forceFlush();
+        }
+    }
+    async dispose() {
+        if (this.provider) {
+            await this.provider.shutdown();
+        }
+    }
+}