route-claudecode/dist/logging/request-tracker.js

Advanced routing and transformation system for Claude Code outputs to multiple AI providers

"use strict";
/**
 * 请求跟踪器 - 专门处理请求生命周期跟踪
 * 整合原有的RequestBasedLogger功能
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.RequestTracker = void 0;
class RequestTracker {
    logger;
    activeSessions = new Map();
    constructor(logger) {
        this.logger = logger;
    }
    startRequest(requestId, port, provider, model, data) {
        const session = {
            requestId,
            startTime: Date.now(),
            stages: [],
            provider,
            model,
            port
        };
        this.activeSessions.set(requestId, session);
        this.logger.logRequest(requestId, 'START', 'Request started', {
            provider,
            model,
            port,
            ...data
        });
    }
    logStage(requestId, stage, data, duration) {
        const session = this.activeSessions.get(requestId);
        if (!session) {
            this.logger.warn(`Request ${requestId} not found for stage logging`, { stage });
            return;
        }
        const stageEntry = {
            stage,
            timestamp: Date.now(),
            duration,
            data
        };
        session.stages.push(stageEntry);
        this.logger.logPipeline(stage, `Stage: ${stage}`, data, requestId);
    }
    logToolCall(requestId, toolName, data, error) {
        const message = error ? `Tool call failed: ${toolName}` : `Tool call: ${toolName}`;
        this.logger.logToolCall(message, { toolName, error, ...data }, requestId, 'tool_call');
    }
    logStreaming(requestId, chunkIndex, data) {
        // 只在debug级别记录chunk信息，避免INFO级别刷屏
        this.logger.debug(`Chunk ${chunkIndex}`, data, requestId, 'streaming');
    }
    completeRequest(requestId, status, data) {
        const session = this.activeSessions.get(requestId);
        if (!session) {
            this.logger.warn(`Request ${requestId} not found for completion`);
            return;
        }
        const endTime = Date.now();
        const totalDuration = endTime - session.startTime;
        session.endTime = endTime;
        this.logger.logResponse(requestId, status || 200, {
            totalDuration,
            stagesCount: session.stages.length,
            provider: session.provider,
            model: session.model,
            ...data
        }, totalDuration);
        this.logger.logPerformance('request_complete', totalDuration, {
            requestId,
            stagesCount: session.stages.length,
            provider: session.provider,
            model: session.model
        }, requestId);
        this.activeSessions.delete(requestId);
    }
    getActiveRequests() {
        return Array.from(this.activeSessions.keys());
    }
    getRequestSession(requestId) {
        return this.activeSessions.get(requestId);
    }
    cleanupOldSessions(maxAgeMs = 300000) {
        const now = Date.now();
        let cleaned = 0;
        for (const [requestId, session] of this.activeSessions) {
            if (now - session.startTime > maxAgeMs) {
                this.logger.warn(`Cleaning up old request session: ${requestId}`);
                this.activeSessions.delete(requestId);
                cleaned++;
            }
        }
        return cleaned;
    }
}
exports.RequestTracker = RequestTracker;
//# sourceMappingURL=request-tracker.js.map