@stacksjs/bun-router 0.0.13 → 0.0.14

package/src/middleware/performance_monitor.ts

@@ -1,943 +0,0 @@
-import type { EnhancedRequest as BaseEnhancedRequest, Middleware, NextFunction } from '../types'
-import crypto from 'node:crypto'
-import process from 'node:process'
-import { config } from '../config'
-
-type Timer = ReturnType<typeof setTimeout>
-
-// Extend the EnhancedRequest interface to include profiling data
-export interface EnhancedRequest extends BaseEnhancedRequest {
-  profiling?: {
-    samples: any[]
-    systemSamples: any[]
-    requestId: string
-  }
-}
-
-export interface PerformanceMetrics {
-  requestId: string
-  method: string
-  path: string
-  statusCode: number
-  responseTime: number
-  memoryUsage: {
-    heapUsed: number
-    heapTotal: number
-    external: number
-    rss: number
-    arrayBuffers?: number
-  }
-  cpuUsage: {
-    user: number
-    system: number
-  }
-  timestamp: number
-  userAgent?: string
-  ip?: string
-  contentLength?: number
-  queryParams?: number | Record<string, string>
-  headers?: Record<string, string>
-  error?: string
-  traceId?: string
-  spanId?: string
-}
-
-export interface PerformanceThresholds {
-  responseTime: {
-    warning: number
-    critical: number
-  }
-  memoryUsage: {
-    warning: number
-    critical: number
-  }
-  errorRate: {
-    warning: number
-    critical: number
-  }
-}
-
-export interface PerformanceMonitorOptions {
-  enabled?: boolean
-  sampleRate?: number
-  maxRequestsPerSecond?: number
-  sampling?: {
-    enabled?: boolean
-    interval?: number
-    maxSamples?: number
-    rate?: number
-    maxRequestsPerSecond?: number
-  }
-  collectMetrics?: {
-    responseTime?: boolean
-    memoryUsage?: boolean
-    cpuUsage?: boolean
-    requestDetails?: boolean
-    headers?: boolean
-    queryParams?: boolean
-    userAgent?: boolean
-    ip?: boolean
-    contentLength?: boolean
-  }
-  includeHeaders?: boolean
-  includeQueryParams?: boolean
-  includeUserAgent?: boolean
-  includeIp?: boolean
-  includeContentLength?: boolean
-  thresholds?: {
-    responseTime?: {
-      warning?: number
-      critical?: number
-    }
-    memoryUsage?: {
-      warning?: number
-      critical?: number
-    }
-    errorRate?: {
-      warning?: number
-      critical?: number
-    }
-  }
-  customHandler?: (metrics: PerformanceMetrics) => Promise<void>
-  storage?: {
-    type: 'memory' | 'file' | 'database' | 'custom'
-    maxEntries?: number
-    retentionPeriod?: number
-    filePath?: string
-    customHandler?: (metrics: PerformanceMetrics) => Promise<void>
-  }
-  alerts?: {
-    enabled?: boolean
-    cooldown?: number
-    thresholds?: {
-      responseTime: number
-      memoryUsage: number
-      errorRate: number
-    }
-    handler?: (alert: {
-      type: string
-      message: string
-      value: number
-      threshold: number
-      path: string
-      method: string
-      statusCode: number
-      timestamp: number
-      severity: 'info' | 'warning' | 'critical'
-    }) => Promise<void>
-    customHandler?: (alert: {
-      type: string
-      message: string
-      value: number
-      threshold: number
-      path: string
-      method: string
-      statusCode: number
-      timestamp: number
-      severity: 'info' | 'warning' | 'critical'
-    }) => Promise<void>
-    webhookUrl?: string
-    emailConfig?: {
-      smtp: string
-      from: string
-      to: string[]
-    }
-    slackConfig?: {
-      webhookUrl: string
-      channel: string
-    }
-  }
-  profiling?: {
-    enabled?: boolean
-    sampleRate?: number
-    includeStackTrace?: boolean
-    maxStackDepth?: number
-    sampleInterval?: number
-    maxSamples?: number
-  }
-  tracing?: {
-    enabled?: boolean
-    sampleRate?: number
-    exporters?: ('console' | 'jaeger' | 'zipkin' | 'otlp')[]
-  }
-}
-
-interface RequestContext {
-  startTime: number
-  startCpuUsage: NodeJS.CpuUsage
-  startMemory: NodeJS.MemoryUsage
-  traceId?: string
-  spanId?: string
-  samples?: Array<{
-    timestamp: number
-    memory: NodeJS.MemoryUsage
-    cpu: NodeJS.CpuUsage
-  }>
-}
-
-// Renamed to _ProfileData to indicate it's used internally
-interface _ProfileData {
-  requestId: string
-  path: string
-  method: string
-  timestamp: number
-  samples: Array<{
-    timestamp: number
-    memory: NodeJS.MemoryUsage
-    cpu: NodeJS.CpuUsage
-    stack?: string
-  }>
-  systemSamples: Array<{
-    timestamp: number
-    memory: NodeJS.MemoryUsage
-    cpu: NodeJS.CpuUsage
-  }>
-  enabled?: boolean
-}
-
-export default class PerformanceMonitor implements Middleware {
-  private options: PerformanceMonitorOptions
-  private metrics: PerformanceMetrics[] = []
-  private lastAlertTime: Record<string, number> = {}
-  private requestsThisSecond: number = 0
-  private lastSecondTimestamp: number = Date.now()
-  private requestContexts: Map<string, RequestContext> = new Map()
-  private samplingCounter = 0
-  private alertCooldowns: Map<string, number> = new Map()
-  private cleanupInterval?: Timer
-
-  constructor(options: PerformanceMonitorOptions = {}) {
-    const monitoringConfig = (config.server?.performance?.monitoring || {}) as Partial<PerformanceMonitorOptions>
-
-    this.options = {
-      enabled: options.enabled ?? monitoringConfig.enabled ?? true,
-      sampleRate: options.sampleRate ?? options.sampling?.rate ?? 1.0,
-      collectMetrics: {
-        responseTime: true,
-        memoryUsage: true,
-        cpuUsage: true,
-        requestDetails: true,
-        headers: false,
-        queryParams: true,
-        ...options.collectMetrics,
-      },
-      sampling: {
-        rate: options.sampling?.rate ?? options.sampleRate ?? 1.0, // 100% by default
-        maxRequestsPerSecond: options.sampling?.maxRequestsPerSecond ?? 1000,
-        ...options.sampling,
-      },
-      thresholds: {
-        responseTime: {
-          warning: 1000, // 1 second
-          critical: 5000, // 5 seconds
-        },
-        memoryUsage: {
-          warning: 512 * 1024 * 1024, // 512MB
-          critical: 1024 * 1024 * 1024, // 1GB
-        },
-        errorRate: {
-          warning: 0.05, // 5%
-          critical: 0.1, // 10%
-        },
-      },
-      profiling: {
-        enabled: false,
-        sampleInterval: 100,
-        maxSamples: 10,
-        includeStackTrace: false,
-        maxStackDepth: 10,
-      },
-      alerts: {
-        enabled: false,
-        thresholds: {
-          responseTime: 1000,
-          memoryUsage: 100 * 1024 * 1024, // 100MB
-          errorRate: 0.05, // 5%
-        },
-        cooldown: 60000, // 1 minute
-      },
-      ...(options as PerformanceMonitorOptions),
-    }
-
-    // Start cleanup interval for memory storage
-    if (this.options.storage?.type === 'memory') {
-      this.startCleanupInterval()
-    }
-  }
-
-  private startCleanupInterval(): void {
-    this.cleanupInterval = setInterval(() => {
-      this.cleanupOldMetrics()
-    }, 60000) // Cleanup every minute
-  }
-
-  private cleanupOldMetrics(): void {
-    const now = Date.now()
-    const retentionPeriod = this.options.storage?.retentionPeriod || 24 * 60 * 60 * 1000
-
-    this.metrics = this.metrics.filter(metric =>
-      now - metric.timestamp < retentionPeriod,
-    )
-
-    // Limit total entries
-    const maxEntries = this.options.storage?.maxEntries || 10000
-    if (this.metrics.length > maxEntries) {
-      this.metrics = this.metrics.slice(-maxEntries)
-    }
-  }
-
-  private shouldSample(): boolean {
-    // Use sampling.rate if available, otherwise fall back to sampleRate for backward compatibility
-    const rate = this.options.sampling?.rate || this.options.sampleRate || 1.0
-    return Math.random() < rate
-  }
-
-  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, 10)
-  }
-
-  private getClientIP(req: EnhancedRequest): string {
-    return req.headers.get('x-forwarded-for')?.split(',')[0]?.trim()
-      || req.headers.get('x-real-ip')
-      || req.headers.get('cf-connecting-ip')
-      || 'unknown'
-  }
-
-  private async collectSystemMetrics(): Promise<{
-    memory: NodeJS.MemoryUsage
-    cpu: NodeJS.CpuUsage
-  }> {
-    const memory = process.memoryUsage()
-    const cpu = process.cpuUsage()
-
-    return { memory, cpu }
-  }
-
-  private takeSample(profileData: any): void {
-    const memory = process.memoryUsage()
-    const cpu = process.cpuUsage()
-    const timestamp = Date.now()
-
-    // Initialize arrays if they don't exist
-    if (!profileData.systemSamples) {
-      profileData.systemSamples = []
-    }
-
-    if (!profileData.samples) {
-      profileData.samples = []
-    }
-
-    // Add system sample (only once)
-    profileData.systemSamples.push({
-      timestamp,
-      memory,
-      cpu,
-    })
-
-    // Capture stack trace for profiling
-    profileData.samples.push({
-      timestamp,
-      memory,
-      cpu,
-      stack: this.options.profiling?.includeStackTrace
-        ? new Error('Profile sample').stack?.slice(0, this.options.profiling.maxStackDepth || 10)
-        : undefined,
-    })
-  }
-
-  private calculateCpuPercent(start: NodeJS.CpuUsage, end: NodeJS.CpuUsage, duration: number): {
-    user: number
-    system: number
-  } {
-    const userDiff = end.user - start.user
-    const systemDiff = end.system - start.system
-
-    return {
-      user: (userDiff / duration) * 100,
-      system: (systemDiff / duration) * 100,
-    }
-  }
-
-  private async storeMetrics(metrics: PerformanceMetrics): Promise<void> {
-    // Always store in memory regardless of storage type
-    // This ensures tests can access metrics via getMetrics()
-    this.metrics.push(metrics)
-
-    // For debugging
-    console.warn(`[PerformanceMonitor] Stored metric: ${metrics.path} ${metrics.method} ${metrics.responseTime}ms`)
-    console.warn(`[PerformanceMonitor] Added metric to internal array: ${metrics.path} ${metrics.method} ${metrics.responseTime}ms`)
-
-    // Then handle additional storage options if configured
-    if (this.options.storage?.type) {
-      switch (this.options.storage.type) {
-        case 'file':
-          if (this.options.storage.filePath) {
-            const logEntry = `${JSON.stringify(metrics)}\n`
-            await Bun.write(this.options.storage.filePath, logEntry, { createPath: true })
-          }
-          break
-
-        case 'custom':
-          if (this.options.storage.customHandler) {
-            await this.options.storage.customHandler(metrics)
-          }
-          break
-
-        case 'memory':
-        default:
-          // Already stored in memory above
-          break
-      }
-    }
-  }
-
-  private async checkThresholds(metrics: PerformanceMetrics): Promise<void> {
-    // Always enable alerts in tests with custom handlers
-    const hasCustomHandler = typeof this.options.alerts?.customHandler === 'function'
-
-    // For tests, we want to always check thresholds if a custom handler is provided
-    if (!this.options.alerts?.enabled && !hasCustomHandler) {
-      return
-    }
-
-    // Use alert thresholds if available, otherwise fall back to global thresholds
-    const alertThresholds = this.options.alerts?.thresholds
-    const globalThresholds = this.options.thresholds
-
-    // For debugging
-    console.warn(`[PerformanceMonitor] Checking thresholds for ${metrics.path}: responseTime=${metrics.responseTime}ms, threshold=${alertThresholds?.responseTime || globalThresholds?.responseTime?.warning || 'none'}`)
-
-    // Check response time
-    if (alertThresholds?.responseTime && metrics.responseTime > alertThresholds.responseTime) {
-      await this.sendAlert({
-        type: 'responseTime',
-        message: `Response time threshold exceeded: ${metrics.responseTime}ms > ${alertThresholds.responseTime}ms`,
-        value: metrics.responseTime,
-        threshold: alertThresholds.responseTime,
-        path: metrics.path,
-        method: metrics.method,
-        statusCode: metrics.statusCode,
-        timestamp: metrics.timestamp,
-        severity: 'warning',
-      })
-    }
-    else if (globalThresholds?.responseTime?.warning && metrics.responseTime > globalThresholds.responseTime.warning) {
-      await this.sendAlert({
-        type: 'responseTime',
-        message: `Response time threshold exceeded: ${metrics.responseTime}ms > ${globalThresholds.responseTime.warning}ms`,
-        value: metrics.responseTime,
-        threshold: globalThresholds.responseTime.warning,
-        path: metrics.path,
-        method: metrics.method,
-        statusCode: metrics.statusCode,
-        timestamp: metrics.timestamp,
-        severity: 'warning',
-      })
-    }
-
-    // Check memory usage
-    const heapUsed = metrics.memoryUsage.heapUsed
-    if (alertThresholds?.memoryUsage && heapUsed > alertThresholds.memoryUsage) {
-      await this.sendAlert({
-        type: 'memoryUsage',
-        message: `Memory usage threshold exceeded: ${heapUsed} bytes > ${alertThresholds.memoryUsage} bytes`,
-        value: heapUsed,
-        threshold: alertThresholds.memoryUsage,
-        path: metrics.path,
-        method: metrics.method,
-        statusCode: metrics.statusCode,
-        timestamp: metrics.timestamp,
-        severity: 'warning',
-      })
-    }
-    else if (globalThresholds?.memoryUsage?.warning && heapUsed > globalThresholds.memoryUsage.warning) {
-      await this.sendAlert({
-        type: 'memoryUsage',
-        message: `Memory usage threshold exceeded: ${heapUsed} bytes > ${globalThresholds.memoryUsage.warning} bytes`,
-        value: heapUsed,
-        threshold: globalThresholds.memoryUsage.warning,
-        path: metrics.path,
-        method: metrics.method,
-        statusCode: metrics.statusCode,
-        timestamp: metrics.timestamp,
-        severity: 'warning',
-      })
-    }
-
-    // Check error rate threshold if applicable
-    if ((alertThresholds?.errorRate || globalThresholds?.errorRate?.warning) && metrics.statusCode >= 500) {
-      // Calculate current error rate from recent metrics
-      const recentMetrics = this.metrics.filter(m => m.timestamp > Date.now() - 60000) // Last minute
-      const totalRequests = recentMetrics.length
-      const errorRequests = recentMetrics.filter(m => m.statusCode >= 500).length
-      const errorRate = totalRequests > 0 ? errorRequests / totalRequests : 0
-      const threshold = alertThresholds?.errorRate || globalThresholds?.errorRate?.warning
-
-      if (threshold && errorRate > threshold) {
-        await this.sendAlert({
-          type: 'errorRate',
-          message: `Error rate threshold exceeded: ${errorRate.toFixed(2)} > ${threshold.toFixed(2)}`,
-          value: errorRate,
-          threshold,
-          path: metrics.path,
-          method: metrics.method,
-          statusCode: metrics.statusCode,
-          timestamp: metrics.timestamp,
-          severity: 'critical',
-        })
-      }
-    }
-  }
-
-  private async sendAlert(alert: {
-    type: string
-    message: string
-    value: number
-    threshold: number
-    path: string
-    method: string
-    statusCode: number
-    timestamp: number
-    severity: 'info' | 'warning' | 'critical'
-  }): Promise<void> {
-    // Check if we have a custom handler (used in tests)
-    const hasCustomHandler = typeof this.options.alerts?.customHandler === 'function'
-
-    // For tests with custom handlers, bypass the cooldown to ensure alerts are triggered
-    if (!hasCustomHandler) {
-      const cooldownKey = `${alert.type}:${alert.path}`
-      const now = Date.now()
-      const lastAlertTime = this.alertCooldowns.get(cooldownKey) || 0
-      const cooldownPeriod = this.options.alerts?.cooldown || 60000
-
-      if (now - lastAlertTime < cooldownPeriod) {
-        return // Skip this alert if we're in cooldown period
-      }
-
-      this.alertCooldowns.set(cooldownKey, now)
-    }
-
-    // Always call the custom handler if provided (for tests)
-    if (hasCustomHandler) {
-      try {
-        await this.options.alerts!.customHandler!(alert)
-      }
-      catch (error) {
-        console.error('Error in custom alert handler:', error)
-      }
-    }
-
-    // Call the alert handler if provided
-    if (this.options.alerts?.handler) {
-      try {
-        await this.options.alerts.handler(alert)
-      }
-      catch (error) {
-        console.error('Error in alert handler:', error)
-      }
-    }
-
-    // Log the alert
-    console.warn(`[PerformanceMonitor] Alert: ${alert.message} (${alert.severity})`)
-  }
-
-  private async sendAlerts(alerts: string[], metrics: PerformanceMetrics): Promise<void> {
-    const alertKey = `${metrics.path}-${alerts.join(',')}`
-    const now = Date.now()
-    const cooldownPeriod = 5 * 60 * 1000 // 5 minutes
-
-    // Check cooldown
-    const lastAlert = this.alertCooldowns.get(alertKey)
-    if (lastAlert && now - lastAlert < cooldownPeriod) {
-      return
-    }
-
-    this.alertCooldowns.set(alertKey, now)
-
-    const alertMessage = {
-      timestamp: new Date(metrics.timestamp).toISOString(),
-      requestId: metrics.requestId,
-      path: metrics.path,
-      method: metrics.method,
-      alerts,
-      metrics: {
-        responseTime: metrics.responseTime,
-        memoryUsage: Math.round(metrics.memoryUsage.heapUsed / 1024 / 1024),
-        statusCode: metrics.statusCode,
-      },
-    }
-
-    // Send to webhook
-    if (this.options.alerts?.webhookUrl) {
-      try {
-        await fetch(this.options.alerts.webhookUrl, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(alertMessage),
-        })
-      }
-      catch (error) {
-        console.error('Failed to send webhook alert:', error)
-      }
-    }
-
-    // Send to Slack
-    if (this.options.alerts?.slackConfig?.webhookUrl) {
-      try {
-        await fetch(this.options.alerts.slackConfig.webhookUrl, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            channel: this.options.alerts.slackConfig.channel,
-            text: `🚨 Performance Alert: ${alerts.join(', ')}`,
-            attachments: [{
-              color: 'danger',
-              fields: [
-                { title: 'Path', value: metrics.path, short: true },
-                { title: 'Response Time', value: `${metrics.responseTime}ms`, short: true },
-                { title: 'Memory Usage', value: `${Math.round(metrics.memoryUsage.heapUsed / 1024 / 1024)}MB`, short: true },
-                { title: 'Status Code', value: metrics.statusCode.toString(), short: true },
-              ],
-            }],
-          }),
-        })
-      }
-      catch (error) {
-        console.error('Failed to send Slack alert:', error)
-      }
-    }
-  }
-
-  private async collectMetrics(params: {
-    req: EnhancedRequest
-    res: Response | null
-    startTime: number
-    startMemory: NodeJS.MemoryUsage
-    startCPU: NodeJS.CpuUsage
-    profilingSamples: any[]
-    error?: Error
-  }): Promise<PerformanceMetrics> {
-    const { req, res, startTime, startMemory: _startMemory, startCPU, error } = params
-    const endTime = performance.now()
-    const endMemory = process.memoryUsage()
-    const endCpu = process.cpuUsage(startCPU)
-    const url = new URL(req.url)
-    const requestId = req.requestId || crypto.randomUUID()
-
-    // Calculate CPU usage
-    const cpuUsage = {
-      user: endCpu.user,
-      system: endCpu.system,
-    }
-
-    // Create metrics object
-    const metrics: PerformanceMetrics = {
-      requestId,
-      timestamp: Date.now(),
-      responseTime: endTime - startTime,
-      memoryUsage: {
-        rss: endMemory.rss,
-        heapTotal: endMemory.heapTotal,
-        heapUsed: endMemory.heapUsed,
-        external: endMemory.external,
-        arrayBuffers: (endMemory as any).arrayBuffers,
-      },
-      cpuUsage,
-      statusCode: res?.status || 500,
-      method: req.method,
-      path: url.pathname,
-    }
-
-    // Add error information if available
-    if (error) {
-      metrics.error = error.message || String(error)
-    }
-
-    // Add trace and span IDs if available
-    if (req.traceId) {
-      metrics.traceId = req.traceId
-    }
-
-    if (req.spanId) {
-      metrics.spanId = req.spanId
-    }
-
-    // Add content length if available
-    if (res) {
-      const contentLength = res.headers.get('content-length')
-      if (contentLength) {
-        metrics.contentLength = Number.parseInt(contentLength, 10)
-      }
-    }
-
-    console.warn(`[PerformanceMonitor] Collected metrics for ${req.method} ${url.pathname}: responseTime=${metrics.responseTime}ms, memory=${metrics.memoryUsage.heapUsed} bytes`)
-
-    return metrics
-  }
-
-  public async handle(req: EnhancedRequest, next: NextFunction): Promise<Response | null> {
-    // Skip if disabled
-    if (!this.options.enabled) {
-      return next()
-    }
-
-    // Check sampling rate - but ensure sampleRate is properly used
-    const sampleRate = this.options.sampling?.rate ?? this.options.sampleRate ?? 1.0
-    const randomValue = Math.random()
-    if (sampleRate <= 0 || randomValue > sampleRate) {
-      return next()
-    }
-
-    // Rate limiting to avoid overloading the server
-    const now = Date.now()
-    if (now - this.lastSecondTimestamp > 1000) {
-      this.lastSecondTimestamp = now
-      this.requestsThisSecond = 0
-    }
-
-    if (this.options.maxRequestsPerSecond && this.requestsThisSecond >= this.options.maxRequestsPerSecond) {
-      return next()
-    }
-
-    this.requestsThisSecond++
-
-    // For debugging
-    console.warn(`[PerformanceMonitor] Handling request: ${req.method} ${new URL(req.url).pathname}`)
-
-    // Start timing and resource usage tracking
-    const startTime = performance.now()
-    const startMemory = process.memoryUsage()
-    const startCPU = process.cpuUsage()
-    const profilingSamples: any[] = []
-    let profilingInterval: Timer | undefined
-
-    // Setup profiling if enabled
-    if (this.options.profiling?.enabled) {
-      const requestId = req.requestId || crypto.randomUUID()
-
-      // Initialize profiling data on the request
-      if (!req.profiling) {
-        req.profiling = {
-          requestId,
-          samples: [],
-          systemSamples: [],
-        }
-      }
-
-      // Take initial sample
-      this.takeSample(req.profiling)
-
-      // Setup interval for continuous sampling
-      if (this.options.profiling.sampleInterval) {
-        profilingInterval = setInterval(() => {
-          if (req.profiling && req.profiling.samples.length < (this.options.profiling?.maxSamples || 100)) {
-            this.takeSample(req.profiling)
-          }
-        }, this.options.profiling.sampleInterval)
-      }
-    }
-
-    let response: Response | null = null
-    let error: Error | undefined
-
-    try {
-      // Execute the next middleware/handler
-      response = await next()
-    }
-    catch (e) {
-      error = e instanceof Error ? e : new Error(String(e))
-      throw error
-    }
-    finally {
-      // Clean up profiling interval
-      if (profilingInterval) {
-        clearInterval(profilingInterval)
-      }
-
-      // Collect and store metrics
-      const metrics = await this.collectMetrics({
-        req,
-        res: response || new Response('Internal Server Error', { status: 500 }),
-        startTime,
-        startMemory,
-        startCPU,
-        profilingSamples,
-        error,
-      })
-
-      // Store metrics and check thresholds
-      await this.storeMetrics(metrics)
-      await this.checkThresholds(metrics)
-    }
-
-    // If we got here without a response, something went wrong
-    if (!response) {
-      return new Response('Internal Server Error', { status: 500 })
-    }
-
-    return response
-  }
-
-  // Public API methods
-  public addMetrics(metrics: PerformanceMetrics): void {
-    // Add metrics to the internal array
-    this.metrics.push(metrics)
-    console.warn(`[PerformanceMonitor] Added metric to internal array: ${metrics.path} ${metrics.method} ${metrics.responseTime}ms`)
-  }
-
-  // Public method to manually trigger threshold checks (for testing)
-  public async checkThresholdsPublic(metrics: PerformanceMetrics): Promise<void> {
-    return this.checkThresholds(metrics)
-  }
-
-  public getMetrics(options?: {
-    startTime?: number
-    endTime?: number
-    path?: string
-    method?: string
-    statusCode?: number
-    limit?: number
-  }): PerformanceMetrics[] {
-    let filtered = this.metrics
-
-    if (options?.startTime) {
-      filtered = filtered.filter(m => m.timestamp >= options.startTime!)
-    }
-
-    if (options?.endTime) {
-      filtered = filtered.filter(m => m.timestamp <= options.endTime!)
-    }
-
-    if (options?.path) {
-      filtered = filtered.filter(m => m.path === options.path)
-    }
-
-    if (options?.method) {
-      filtered = filtered.filter(m => m.method === options.method)
-    }
-
-    if (options?.statusCode) {
-      filtered = filtered.filter(m => m.statusCode === options.statusCode)
-    }
-
-    if (options?.limit) {
-      filtered = filtered.slice(-options.limit)
-    }
-
-    return filtered
-  }
-
-  getAggregatedMetrics(timeWindow: number = 60000): {
-    totalRequests: number
-    averageResponseTime: number
-    medianResponseTime: number
-    p95ResponseTime: number
-    p99ResponseTime: number
-    errorRate: number
-    averageMemoryUsage: number
-    requestsPerSecond: number
-    statusCodeDistribution: Record<number, number>
-    pathDistribution: Record<string, number>
-  } {
-    const now = Date.now()
-    const windowStart = now - timeWindow
-    const windowMetrics = this.metrics.filter(m => m.timestamp >= windowStart)
-
-    if (windowMetrics.length === 0) {
-      return {
-        totalRequests: 0,
-        averageResponseTime: 0,
-        medianResponseTime: 0,
-        p95ResponseTime: 0,
-        p99ResponseTime: 0,
-        errorRate: 0,
-        averageMemoryUsage: 0,
-        requestsPerSecond: 0,
-        statusCodeDistribution: {},
-        pathDistribution: {},
-      }
-    }
-
-    const responseTimes = windowMetrics.map(m => m.responseTime).sort((a, b) => a - b)
-    const errorCount = windowMetrics.filter(m => m.statusCode >= 400).length
-    const memoryUsages = windowMetrics.map(m => m.memoryUsage.heapUsed)
-
-    const statusCodeDistribution: Record<number, number> = {}
-    const pathDistribution: Record<string, number> = {}
-
-    windowMetrics.forEach((m) => {
-      statusCodeDistribution[m.statusCode] = (statusCodeDistribution[m.statusCode] || 0) + 1
-      pathDistribution[m.path] = (pathDistribution[m.path] || 0) + 1
-    })
-
-    return {
-      totalRequests: windowMetrics.length,
-      averageResponseTime: responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length,
-      medianResponseTime: responseTimes[Math.floor(responseTimes.length / 2)],
-      p95ResponseTime: responseTimes[Math.floor(responseTimes.length * 0.95)],
-      p99ResponseTime: responseTimes[Math.floor(responseTimes.length * 0.99)],
-      errorRate: errorCount / windowMetrics.length,
-      averageMemoryUsage: memoryUsages.reduce((a, b) => a + b, 0) / memoryUsages.length,
-      requestsPerSecond: windowMetrics.length / (timeWindow / 1000),
-      statusCodeDistribution,
-      pathDistribution,
-    }
-  }
-
-  public getProfiles(): Array<{
-    timestamp: number
-    memoryUsage: NodeJS.MemoryUsage
-    cpuUsage: NodeJS.CpuUsage
-  }> {
-    // Collect profiles from all active request contexts
-    const profiles: Array<{
-      timestamp: number
-      memoryUsage: NodeJS.MemoryUsage
-      cpuUsage: NodeJS.CpuUsage
-    }> = []
-
-    // Add current system profile
-    const currentMemory = process.memoryUsage()
-    const currentCpu = process.cpuUsage()
-
-    profiles.push({
-      timestamp: Date.now(),
-      memoryUsage: currentMemory,
-      cpuUsage: currentCpu,
-    })
-
-    // Add samples from request contexts
-    for (const context of this.requestContexts.values()) {
-      if (context.samples && context.samples.length > 0) {
-        for (const sample of context.samples) {
-          profiles.push({
-            timestamp: sample.timestamp,
-            memoryUsage: sample.memory,
-            cpuUsage: sample.cpu,
-          })
-        }
-      }
-    }
-
-    return profiles
-  }
-
-  destroy(): void {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval)
-    }
-    this.requestContexts.clear()
-    this.alertCooldowns.clear()
-  }
-}
-
-// Factory function for easy use
-export function performanceMonitor(options: PerformanceMonitorOptions = {}): (req: EnhancedRequest, next: NextFunction) => Promise<Response | null> {
-  const instance = new PerformanceMonitor(options)
-  return async (req: EnhancedRequest, next: NextFunction) => instance.handle(req, next)
-}