create-dp-koa 1.1.1 → 1.1.3

package/template/src/annotations/processors/DistributedTracingProcessor.ts

@@ -1,288 +0,0 @@
-/**
- * 企业级分布式追踪注解处理器
- * 提供跨服务的请求追踪和性能分析
- */
-
-import { Context } from 'koa';
-import { AnnotationProcessor } from '@src/framework/decorator/processor/AnnotationProcessor';
-import { logger } from '@src/framework/utils/logger';
-
-export interface TracingConfig {
-    enableTracing?: boolean;
-    traceIdHeader?: string;
-    spanIdHeader?: string;
-    parentSpanIdHeader?: string;
-    samplingRate?: number;
-    exportToJaeger?: boolean;
-    exportToZipkin?: boolean;
-    customTags?: Record<string, string>;
-}
-
-export interface TraceSpan {
-    traceId: string;
-    spanId: string;
-    parentSpanId?: string;
-    operationName: string;
-    startTime: number;
-    endTime?: number;
-    duration?: number;
-    tags: Record<string, any>;
-    logs: TraceLog[];
-    status: 'started' | 'completed' | 'error';
-    serviceName: string;
-    componentName: string;
-}
-
-export interface TraceLog {
-    timestamp: number;
-    level: 'info' | 'warn' | 'error';
-    message: string;
-    fields?: Record<string, any>;
-}
-
-export class DistributedTracingProcessor implements AnnotationProcessor {
-    readonly name = 'DistributedTracing';
-    readonly priority = 3;
-
-    private activeSpans: Map<string, TraceSpan> = new Map();
-    private completedSpans: TraceSpan[] = [];
-    private samplingRate: number = 1.0;
-
-    constructor() {
-        // 从环境变量读取采样率
-        this.samplingRate = parseFloat(process.env.TRACING_SAMPLING_RATE || '1.0');
-    }
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: TracingConfig,
-        callParams: any[]
-    ): Promise<boolean> {
-        const config = annotationData || {};
-        
-        if (!config.enableTracing) return true;
-
-        // 决定是否采样
-        if (!this.shouldSample()) {
-            return true;
-        }
-
-        // 获取或创建追踪上下文
-        const traceContext = this.getOrCreateTraceContext(ctx, config);
-        
-        // 创建新的 Span
-        const span = this.createSpan(traceContext, controller, methodName, config);
-        
-        // 存储到上下文
-        ctx.state.traceSpan = span;
-        ctx.state.traceContext = traceContext;
-
-        // 添加追踪头到响应
-        ctx.set('X-Trace-Id', span.traceId);
-        ctx.set('X-Span-Id', span.spanId);
-
-        // 记录开始日志
-        this.addSpanLog(span, 'info', 'Span started', {
-            controller: controller.constructor.name,
-            method: methodName,
-            traceId: span.traceId,
-            spanId: span.spanId
-        });
-
-        logger.info(`[${this.name}] 开始追踪: ${span.operationName}`, {
-            traceId: span.traceId,
-            spanId: span.spanId,
-            parentSpanId: span.parentSpanId
-        });
-
-        return true;
-    }
-
-    async postProcess(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        response: any
-    ): Promise<void> {
-        const span = ctx.state.traceSpan;
-        if (!span) return;
-
-        // 完成 Span
-        span.endTime = Date.now();
-        span.duration = span.endTime - span.startTime;
-        span.status = 'completed';
-
-        // 添加响应信息到标签
-        span.tags['http.status_code'] = ctx.status;
-        span.tags['response.size'] = JSON.stringify(response).length;
-        span.tags['response.type'] = typeof response;
-
-        // 记录完成日志
-        this.addSpanLog(span, 'info', 'Span completed', {
-            duration: span.duration,
-            statusCode: ctx.status,
-            responseSize: span.tags['response.size']
-        });
-
-        // 移动到已完成列表
-        this.activeSpans.delete(span.spanId);
-        this.completedSpans.push(span);
-
-        // 导出到外部系统
-        await this.exportSpan(span);
-
-        logger.info(`[${this.name}] 完成追踪: ${span.operationName}`, {
-            traceId: span.traceId,
-            spanId: span.spanId,
-            duration: `${span.duration}ms`
-        });
-    }
-
-    private shouldSample(): boolean {
-        return Math.random() < this.samplingRate;
-    }
-
-    private getOrCreateTraceContext(ctx: Context, config: TracingConfig): any {
-        const traceIdHeader = config.traceIdHeader || 'X-Trace-Id';
-        const spanIdHeader = config.spanIdHeader || 'X-Span-Id';
-        const parentSpanIdHeader = config.parentSpanIdHeader || 'X-Parent-Span-Id';
-
-        // 尝试从请求头获取现有的追踪上下文
-        const traceId = ctx.get(traceIdHeader) || this.generateTraceId();
-        const parentSpanId = ctx.get(parentSpanIdHeader);
-
-        return {
-            traceId,
-            parentSpanId,
-            headers: {
-                traceIdHeader,
-                spanIdHeader,
-                parentSpanIdHeader
-            }
-        };
-    }
-
-    private createSpan(traceContext: any, controller: any, methodName: string, config: TracingConfig): TraceSpan {
-        const spanId = this.generateSpanId();
-        const operationName = `${controller.constructor.name}.${methodName}`;
-
-        const span: TraceSpan = {
-            traceId: traceContext.traceId,
-            spanId,
-            parentSpanId: traceContext.parentSpanId,
-            operationName,
-            startTime: Date.now(),
-            tags: {
-                'component': 'controller',
-                'controller.name': controller.constructor.name,
-                'method.name': methodName,
-                'service.name': process.env.SERVICE_NAME || 'koa-framework',
-                'http.method': 'GET', // 这里应该从 ctx 获取
-                'http.url': '', // 这里应该从 ctx 获取
-                ...config.customTags
-            },
-            logs: [],
-            status: 'started',
-            serviceName: process.env.SERVICE_NAME || 'koa-framework',
-            componentName: 'controller'
-        };
-
-        this.activeSpans.set(spanId, span);
-        return span;
-    }
-
-    private addSpanLog(span: TraceSpan, level: TraceLog['level'], message: string, fields?: Record<string, any>): void {
-        span.logs.push({
-            timestamp: Date.now(),
-            level,
-            message,
-            fields
-        });
-    }
-
-    private async exportSpan(span: TraceSpan): Promise<void> {
-        try {
-            // 导出到 Jaeger
-            if (process.env.JAEGER_ENDPOINT) {
-                await this.exportToJaeger(span);
-            }
-
-            // 导出到 Zipkin
-            if (process.env.ZIPKIN_ENDPOINT) {
-                await this.exportToZipkin(span);
-            }
-
-            // 导出到自定义系统
-            if (process.env.CUSTOM_TRACING_ENDPOINT) {
-                await this.exportToCustom(span);
-            }
-        } catch (error) {
-            logger.error(`[${this.name}] 导出追踪数据失败:`, error as Error);
-        }
-    }
-
-    private async exportToJaeger(span: TraceSpan): Promise<void> {
-        // 这里应该实现 Jaeger 导出逻辑
-        logger.debug(`[${this.name}] 导出到 Jaeger: ${span.traceId}`);
-    }
-
-    private async exportToZipkin(span: TraceSpan): Promise<void> {
-        // 这里应该实现 Zipkin 导出逻辑
-        logger.debug(`[${this.name}] 导出到 Zipkin: ${span.traceId}`);
-    }
-
-    private async exportToCustom(span: TraceSpan): Promise<void> {
-        // 这里应该实现自定义系统导出逻辑
-        logger.debug(`[${this.name}] 导出到自定义系统: ${span.traceId}`);
-    }
-
-    private generateTraceId(): string {
-        return Math.random().toString(36).substring(2, 15) + 
-               Math.random().toString(36).substring(2, 15);
-    }
-
-    private generateSpanId(): string {
-        return Math.random().toString(36).substring(2, 15);
-    }
-
-    /**
-     * 获取追踪统计信息
-     */
-    getTracingStats(): any {
-        const activeCount = this.activeSpans.size;
-        const completedCount = this.completedSpans.length;
-        
-        const avgDuration = completedCount > 0 
-            ? this.completedSpans.reduce((sum, span) => sum + (span.duration || 0), 0) / completedCount
-            : 0;
-
-        return {
-            activeSpans: activeCount,
-            completedSpans: completedCount,
-            averageDuration: avgDuration,
-            samplingRate: this.samplingRate
-        };
-    }
-
-    /**
-     * 获取指定追踪的所有 Span
-     */
-    getTraceSpans(traceId: string): TraceSpan[] {
-        return this.completedSpans.filter(span => span.traceId === traceId);
-    }
-
-    /**
-     * 清理过期的 Span
-     */
-    cleanupExpiredSpans(maxAge: number = 3600000): void { // 1小时
-        const cutoffTime = Date.now() - maxAge;
-        
-        this.completedSpans = this.completedSpans.filter(span => 
-            span.startTime > cutoffTime
-        );
-
-        logger.info(`[${this.name}] 清理过期 Span 完成，保留 ${this.completedSpans.length} 个 Span`);
-    }
-}

package/template/src/annotations/processors/EnterprisePerformanceProcessor.ts

@@ -1,189 +0,0 @@
-/**
- * 企业级性能监控注解处理器
- * 提供详细的性能指标、监控和告警
- */
-
-import { Context } from 'koa';
-import { AnnotationProcessor } from '@src/framework/decorator/processor/AnnotationProcessor';
-import { logger } from '@src/framework/utils/logger';
-
-export interface PerformanceMetrics {
-    executionTime: number;
-    memoryUsage: {
-        rss: number;
-        heapUsed: number;
-        heapTotal: number;
-        external: number;
-    };
-    cpuUsage?: number;
-    requestSize?: number;
-    responseSize?: number;
-}
-
-export interface PerformanceConfig {
-    maxExecutionTime?: number;
-    maxMemoryUsage?: number;
-    enableMetrics?: boolean;
-    enableAlerts?: boolean;
-    alertThresholds?: {
-        executionTime?: number;
-        memoryUsage?: number;
-        errorRate?: number;
-    };
-}
-
-export class EnterprisePerformanceProcessor implements AnnotationProcessor {
-    readonly name = 'EnterprisePerformance';
-    readonly priority = 1; // 最高优先级
-
-    private metrics: Map<string, PerformanceMetrics[]> = new Map();
-    private alertThresholds: Map<string, PerformanceConfig> = new Map();
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: PerformanceConfig,
-        callParams: any[]
-    ): Promise<boolean> {
-        const startTime = process.hrtime.bigint();
-        const startMemory = process.memoryUsage();
-        const startCpu = process.cpuUsage();
-
-        // 存储性能监控数据
-        ctx.state.performanceMonitor = {
-            startTime,
-            startMemory,
-            startCpu,
-            methodName: `${controller.constructor.name}.${methodName}`,
-            config: annotationData || {},
-            requestSize: ctx.request.length || 0
-        };
-
-        // 记录开始时间
-        logger.info(`[${this.name}] 开始性能监控: ${controller.constructor.name}.${methodName}`);
-
-        return true;
-    }
-
-    async postProcess(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        response: any
-    ): Promise<void> {
-        const monitor = ctx.state.performanceMonitor;
-        if (!monitor) return;
-
-        const endTime = process.hrtime.bigint();
-        const endMemory = process.memoryUsage();
-        const endCpu = process.cpuUsage();
-
-        // 计算性能指标
-        const executionTime = Number(endTime - monitor.startTime) / 1000000; // 毫秒
-        const memoryDelta = {
-            rss: endMemory.rss - monitor.startMemory.rss,
-            heapUsed: endMemory.heapUsed - monitor.startMemory.heapUsed,
-            heapTotal: endMemory.heapTotal - monitor.startMemory.heapTotal,
-            external: endMemory.external - monitor.startMemory.external
-        };
-
-        const cpuDelta = {
-            user: endCpu.user - monitor.startCpu.user,
-            system: endCpu.system - monitor.startCpu.system
-        };
-
-        const metrics: PerformanceMetrics = {
-            executionTime,
-            memoryUsage: memoryDelta,
-            cpuUsage: (cpuDelta.user + cpuDelta.system) / 1000000, // 微秒转毫秒
-            requestSize: monitor.requestSize,
-            responseSize: JSON.stringify(response).length
-        };
-
-        // 存储指标
-        this.storeMetrics(monitor.methodName, metrics);
-
-        // 检查告警阈值
-        this.checkAlerts(monitor.methodName, metrics, monitor.config);
-
-        // 记录性能日志
-        logger.info(`[${this.name}] 性能指标: ${monitor.methodName}`, {
-            executionTime: `${executionTime.toFixed(2)}ms`,
-            memoryUsage: `${(memoryDelta.heapUsed / 1024 / 1024).toFixed(2)}MB`,
-            cpuUsage: `${metrics.cpuUsage?.toFixed(2)}ms`,
-            requestSize: `${metrics.requestSize}B`,
-            responseSize: `${metrics.responseSize}B`
-        });
-
-        // 清理上下文
-        delete ctx.state.performanceMonitor;
-    }
-
-    private storeMetrics(methodName: string, metrics: PerformanceMetrics): void {
-        if (!this.metrics.has(methodName)) {
-            this.metrics.set(methodName, []);
-        }
-
-        const methodMetrics = this.metrics.get(methodName)!;
-        methodMetrics.push(metrics);
-
-        // 只保留最近100条记录
-        if (methodMetrics.length > 100) {
-            methodMetrics.shift();
-        }
-    }
-
-    private checkAlerts(methodName: string, metrics: PerformanceMetrics, config: PerformanceConfig): void {
-        const thresholds = config.alertThresholds || {};
-        
-        // 执行时间告警
-        if (thresholds.executionTime && metrics.executionTime > thresholds.executionTime) {
-            logger.warn(`[${this.name}] ⚠️ 执行时间告警: ${methodName}`, {
-                executionTime: `${metrics.executionTime.toFixed(2)}ms`,
-                threshold: `${thresholds.executionTime}ms`
-            });
-        }
-
-        // 内存使用告警
-        if (thresholds.memoryUsage && Math.abs(metrics.memoryUsage.heapUsed) > thresholds.memoryUsage * 1024 * 1024) {
-            logger.warn(`[${this.name}] ⚠️ 内存使用告警: ${methodName}`, {
-                memoryUsage: `${(metrics.memoryUsage.heapUsed / 1024 / 1024).toFixed(2)}MB`,
-                threshold: `${thresholds.memoryUsage}MB`
-            });
-        }
-    }
-
-    /**
-     * 获取性能统计
-     */
-    getPerformanceStats(methodName?: string): any {
-        if (methodName) {
-            const metrics = this.metrics.get(methodName) || [];
-            return this.calculateStats(metrics);
-        }
-
-        const allStats: any = {};
-        this.metrics.forEach((metrics, name) => {
-            allStats[name] = this.calculateStats(metrics);
-        });
-        return allStats;
-    }
-
-    private calculateStats(metrics: PerformanceMetrics[]): any {
-        if (metrics.length === 0) return null;
-
-        const executionTimes = metrics.map(m => m.executionTime);
-        const memoryUsages = metrics.map(m => m.memoryUsage.heapUsed);
-
-        return {
-            count: metrics.length,
-            avgExecutionTime: executionTimes.reduce((a, b) => a + b, 0) / executionTimes.length,
-            maxExecutionTime: Math.max(...executionTimes),
-            minExecutionTime: Math.min(...executionTimes),
-            avgMemoryUsage: memoryUsages.reduce((a, b) => a + b, 0) / memoryUsages.length,
-            maxMemoryUsage: Math.max(...memoryUsages),
-            minMemoryUsage: Math.min(...memoryUsages)
-        };
-    }
-}

package/template/src/annotations/processors/PerformanceMonitorProcessor.ts

@@ -1,101 +0,0 @@
-import { Context } from 'koa';
-import { AnnotationProcessor } from '@src/framework/decorator/processor/AnnotationProcessor';
-import { isDebug } from '@src/framework/utils/function';
-
-/**
- * 性能监控注解处理器
- * 监控方法执行时间、内存使用等性能指标
- */
-export class PerformanceMonitorProcessor implements AnnotationProcessor {
-    readonly name = 'PerformanceMonitor';
-    readonly priority = 8; // 高优先级，在日志记录之前执行
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: any,
-        callParams: any[]
-    ): Promise<boolean> {
-        const startTime = process.hrtime.bigint();
-        const startMemory = process.memoryUsage();
-        
-        // 只在调试模式下输出详细日志
-        if (isDebug()) {
-            console.log(`[${this.name}] 开始性能监控: ${controller.constructor.name}.${methodName}`);
-            console.log(`[${this.name}] 配置参数:`, annotationData);
-        }
-        
-        // 将性能监控数据存储到上下文中
-        ctx.state.performanceMonitor = {
-            startTime,
-            startMemory,
-            methodName: `${controller.constructor.name}.${methodName}`,
-            config: annotationData || {}
-        };
-        
-        return true;
-    }
-
-    /**
-     * 后置处理方法
-     * 在控制器方法执行完成后自动调用
-     */
-    async postProcess(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        response: any
-    ): Promise<void> {
-        this.logPerformance(ctx);
-    }
-
-    /**
-     * 记录性能监控结果
-     */
-    private logPerformance(ctx: Context): void {
-        const monitor = ctx.state.performanceMonitor;
-        if (!monitor) {
-            return;
-        }
-
-        const endTime = process.hrtime.bigint();
-        const endMemory = process.memoryUsage();
-        
-        // 计算执行时间（纳秒转毫秒）
-        const executionTime = Number(endTime - monitor.startTime) / 1000000;
-        
-        // 计算内存使用变化
-        const memoryDelta = {
-            rss: endMemory.rss - monitor.startMemory.rss,
-            heapUsed: endMemory.heapUsed - monitor.startMemory.heapUsed,
-            heapTotal: endMemory.heapTotal - monitor.startMemory.heapTotal,
-            external: endMemory.external - monitor.startMemory.external
-        };
-
-        // 只在调试模式下输出详细日志
-        if (isDebug()) {
-            console.log(`[PerformanceMonitor] 性能监控结果: ${monitor.methodName}`);
-            console.log(`[PerformanceMonitor] 执行时间: ${executionTime.toFixed(2)}ms`);
-            console.log(`[PerformanceMonitor] 内存使用变化:`, {
-                rss: `${(memoryDelta.rss / 1024 / 1024).toFixed(2)}MB`,
-                heapUsed: `${(memoryDelta.heapUsed / 1024 / 1024).toFixed(2)}MB`,
-                heapTotal: `${(memoryDelta.heapTotal / 1024 / 1024).toFixed(2)}MB`,
-                external: `${(memoryDelta.external / 1024 / 1024).toFixed(2)}MB`
-            });
-        }
-
-        // 性能警告（始终输出）
-        const config = monitor.config;
-        if (config.maxExecutionTime && executionTime > config.maxExecutionTime) {
-            console.warn(`[PerformanceMonitor] ⚠️ 执行时间超过阈值: ${executionTime.toFixed(2)}ms > ${config.maxExecutionTime}ms`);
-        }
-
-        if (config.maxMemoryUsage && Math.abs(memoryDelta.heapUsed) > config.maxMemoryUsage * 1024 * 1024) {
-            console.warn(`[PerformanceMonitor] ⚠️ 内存使用变化过大: ${(memoryDelta.heapUsed / 1024 / 1024).toFixed(2)}MB`);
-        }
-
-        // 清理上下文
-        delete ctx.state.performanceMonitor;
-    }
-}