create-fluxstack 1.0.13 → 1.0.15

package/core/utils/logger/middleware.ts

@@ -0,0 +1,253 @@
+/**
+ * FluxStack Logger Middleware Integration
+ * Easy integration with Elysia and other frameworks
+ */
+
+import type { Logger } from './index'
+import { RequestLogger, PerformanceLogger } from './performance'
+
+/**
+ * Enhanced logger middleware for Elysia
+ */
+export function createElysiaLoggerMiddleware(logger: Logger) {
+  const requestLogger = new RequestLogger(logger)
+  const performanceLogger = new PerformanceLogger(logger)
+
+  return {
+    // Before request handler
+    beforeHandle: ({ request, set }: any) => {
+      const method = request.method
+      const url = new URL(request.url)
+      const path = url.pathname
+      const userAgent = request.headers.get('user-agent')
+      const ip = request.headers.get('x-forwarded-for') || 
+                 request.headers.get('x-real-ip') || 
+                 'unknown'
+
+      // Start request tracking
+      const requestId = requestLogger.startRequest(method, path, {
+        userAgent,
+        ip,
+        query: Object.fromEntries(url.searchParams),
+        headers: Object.fromEntries(request.headers.entries())
+      })
+
+      // Add request context to set for access in handlers
+      set.requestId = requestId
+      set.logger = requestLogger.childLogger(requestId)
+      set.performance = performanceLogger
+
+      // Start overall request timer
+      performanceLogger.startTimer(`request:${requestId}`, {
+        method,
+        path
+      })
+    },
+
+    // After request handler
+    afterHandle: ({ request, response, set }: any) => {
+      if (set.requestId) {
+        const status = response?.status || 200
+        
+        // End request tracking
+        requestLogger.endRequest(set.requestId, status, {
+          responseSize: response?.headers?.get('content-length'),
+          contentType: response?.headers?.get('content-type')
+        })
+
+        // End request timer
+        performanceLogger.endTimer(`request:${set.requestId}`)
+      }
+    },
+
+    // Error handler
+    onError: ({ request, error, set }: any) => {
+      if (set.requestId) {
+        requestLogger.errorRequest(set.requestId, error)
+        performanceLogger.endTimer(`request:${set.requestId}`)
+      }
+
+      // Log the error with context
+      logger.error('Request error', {
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        },
+        request: {
+          method: request.method,
+          url: request.url
+        }
+      })
+    }
+  }
+}
+
+/**
+ * Database query logging middleware
+ */
+export function createDatabaseLoggerMiddleware(logger: Logger) {
+  const performanceLogger = new PerformanceLogger(logger)
+
+  return {
+    beforeQuery: (query: string, params?: any[]) => {
+      const queryId = `query:${Date.now()}:${Math.random().toString(36).substr(2, 9)}`
+      
+      logger.debug('Executing database query', {
+        type: 'db_query_start',
+        queryId,
+        query: query.replace(/\s+/g, ' ').trim(),
+        params
+      })
+
+      performanceLogger.startTimer(queryId, {
+        query: query.substring(0, 100) + (query.length > 100 ? '...' : ''),
+        paramCount: params?.length || 0
+      })
+
+      return queryId
+    },
+
+    afterQuery: (queryId: string, result?: any) => {
+      const duration = performanceLogger.endTimer(queryId)
+      
+      logger.debug('Database query completed', {
+        type: 'db_query_end',
+        queryId,
+        duration,
+        rowCount: result?.rowCount || result?.length || 0
+      })
+    },
+
+    onQueryError: (queryId: string, error: Error) => {
+      performanceLogger.endTimer(queryId)
+      
+      logger.error('Database query failed', {
+        type: 'db_query_error',
+        queryId,
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        }
+      })
+    }
+  }
+}
+
+/**
+ * Plugin execution logging
+ */
+export function createPluginLoggerMiddleware(logger: Logger) {
+  const performanceLogger = new PerformanceLogger(logger)
+
+  return {
+    beforePluginExecution: (pluginName: string, hook: string, context?: any) => {
+      const executionId = `plugin:${pluginName}:${hook}:${Date.now()}`
+      
+      logger.debug(`Executing plugin hook: ${pluginName}.${hook}`, {
+        type: 'plugin_execution_start',
+        plugin: pluginName,
+        hook,
+        executionId,
+        context
+      })
+
+      performanceLogger.startTimer(executionId, {
+        plugin: pluginName,
+        hook
+      })
+
+      return executionId
+    },
+
+    afterPluginExecution: (executionId: string, result?: any) => {
+      const duration = performanceLogger.endTimer(executionId)
+      
+      logger.debug('Plugin hook execution completed', {
+        type: 'plugin_execution_end',
+        executionId,
+        duration,
+        success: true
+      })
+    },
+
+    onPluginError: (executionId: string, pluginName: string, hook: string, error: Error) => {
+      performanceLogger.endTimer(executionId)
+      
+      logger.error(`Plugin hook execution failed: ${pluginName}.${hook}`, {
+        type: 'plugin_execution_error',
+        plugin: pluginName,
+        hook,
+        executionId,
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        }
+      })
+    }
+  }
+}
+
+/**
+ * Build process logging
+ */
+export function createBuildLoggerMiddleware(logger: Logger) {
+  const performanceLogger = new PerformanceLogger(logger)
+
+  return {
+    beforeBuild: (target: string, config?: any) => {
+      const buildId = `build:${target}:${Date.now()}`
+      
+      logger.info(`Starting build process for ${target}`, {
+        type: 'build_start',
+        target,
+        buildId,
+        config
+      })
+
+      performanceLogger.startTimer(buildId, { target })
+      performanceLogger.logMemoryUsage(`build-start-${target}`)
+
+      return buildId
+    },
+
+    afterBuild: (buildId: string, result: any) => {
+      const duration = performanceLogger.endTimer(buildId)
+      performanceLogger.logMemoryUsage(`build-end`)
+      
+      logger.info('Build process completed', {
+        type: 'build_end',
+        buildId,
+        duration,
+        success: true,
+        result
+      })
+    },
+
+    onBuildError: (buildId: string, error: Error) => {
+      performanceLogger.endTimer(buildId)
+      performanceLogger.logMemoryUsage(`build-error`)
+      
+      logger.error('Build process failed', {
+        type: 'build_error',
+        buildId,
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        }
+      })
+    },
+
+    logBuildStep: (buildId: string, step: string, details?: any) => {
+      logger.info(`Build step: ${step}`, {
+        type: 'build_step',
+        buildId,
+        step,
+        details
+      })
+    }
+  }
+}

package/core/utils/logger/performance.ts

@@ -0,0 +1,384 @@
+/**
+ * FluxStack Performance and Request Logging
+ * Utilities for measuring and logging performance metrics
+ */
+
+import { randomUUID } from 'crypto'
+import type { Logger } from './index'
+
+export interface RequestContext {
+  id: string
+  method: string
+  path: string
+  userAgent?: string
+  ip?: string
+  startTime: number
+  endTime?: number
+  duration?: number
+  status?: number
+  error?: Error
+  meta?: any
+}
+
+export interface PerformanceTimer {
+  label: string
+  startTime: number
+  endTime?: number
+  duration?: number
+  meta?: any
+}
+
+/**
+ * Request correlation and contextual logging
+ */
+export class RequestLogger {
+  private logger: Logger
+  private activeRequests: Map<string, RequestContext> = new Map()
+
+  constructor(logger: Logger) {
+    this.logger = logger
+  }
+
+  /**
+   * Start tracking a request
+   */
+  startRequest(method: string, path: string, meta?: any): string {
+    const id = randomUUID()
+    const context: RequestContext = {
+      id,
+      method,
+      path,
+      startTime: Date.now(),
+      meta
+    }
+
+    this.activeRequests.set(id, context)
+    
+    // Log request start
+    this.logger.child({ requestId: id }).info(`→ ${method} ${path}`, {
+      type: 'request_start',
+      method,
+      path,
+      ...meta
+    })
+
+    return id
+  }
+
+  /**
+   * End tracking a request
+   */
+  endRequest(id: string, status: number, meta?: any): void {
+    const context = this.activeRequests.get(id)
+    if (!context) return
+
+    const endTime = Date.now()
+    const duration = endTime - context.startTime
+
+    context.endTime = endTime
+    context.duration = duration
+    context.status = status
+
+    // Determine log level based on status and duration
+    const logLevel = this.getRequestLogLevel(status, duration)
+    const statusEmoji = this.getStatusEmoji(status)
+    
+    // Log request completion
+    this.logger.child({ requestId: id })[logLevel](
+      `← ${context.method} ${context.path} ${statusEmoji} ${status} (${duration}ms)`,
+      {
+        type: 'request_end',
+        method: context.method,
+        path: context.path,
+        status,
+        duration,
+        ...context.meta,
+        ...meta
+      }
+    )
+
+    // Clean up
+    this.activeRequests.delete(id)
+  }
+
+  /**
+   * Log request error
+   */
+  errorRequest(id: string, error: Error, status?: number): void {
+    const context = this.activeRequests.get(id)
+    if (!context) return
+
+    const endTime = Date.now()
+    const duration = endTime - context.startTime
+    const finalStatus = status || 500
+
+    context.endTime = endTime
+    context.duration = duration
+    context.status = finalStatus
+    context.error = error
+
+    // Log request error
+    this.logger.child({ requestId: id }).error(
+      `✗ ${context.method} ${context.path} ${finalStatus} (${duration}ms)`,
+      {
+        type: 'request_error',
+        method: context.method,
+        path: context.path,
+        status: finalStatus,
+        duration,
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        },
+        ...context.meta
+      }
+    )
+
+    // Clean up
+    this.activeRequests.delete(id)
+  }
+
+  /**
+   * Get request context for correlation
+   */
+  getRequestContext(id: string): RequestContext | undefined {
+    return this.activeRequests.get(id)
+  }
+
+  /**
+   * Create child logger with request context
+   */
+  childLogger(id: string, additionalContext?: any): Logger {
+    const context = this.activeRequests.get(id)
+    if (!context) {
+      return this.logger.child({ requestId: id, ...additionalContext })
+    }
+
+    return this.logger.child({
+      requestId: id,
+      method: context.method,
+      path: context.path,
+      ...additionalContext
+    })
+  }
+
+  private getRequestLogLevel(status: number, duration: number): 'info' | 'warn' | 'error' {
+    if (status >= 500) return 'error'
+    if (status >= 400) return 'warn'
+    if (duration > 5000) return 'warn' // Slow requests
+    return 'info'
+  }
+
+  private getStatusEmoji(status: number): string {
+    if (status >= 500) return '💥'
+    if (status >= 400) return '⚠️'
+    if (status >= 300) return '↩️'
+    if (status >= 200) return '✅'
+    return '❓'
+  }
+}
+
+/**
+ * Performance timing utilities
+ */
+export class PerformanceLogger {
+  private logger: Logger
+  private timers: Map<string, PerformanceTimer> = new Map()
+
+  constructor(logger: Logger) {
+    this.logger = logger
+  }
+
+  /**
+   * Start a performance timer
+   */
+  startTimer(label: string, meta?: any): void {
+    const timer: PerformanceTimer = {
+      label,
+      startTime: performance.now(),
+      meta
+    }
+
+    this.timers.set(label, timer)
+    
+    this.logger.debug(`⏱️  Started timer: ${label}`, {
+      type: 'timer_start',
+      label,
+      ...meta
+    })
+  }
+
+  /**
+   * End a performance timer
+   */
+  endTimer(label: string, meta?: any): number | undefined {
+    const timer = this.timers.get(label)
+    if (!timer) {
+      this.logger.warn(`Timer not found: ${label}`)
+      return undefined
+    }
+
+    const endTime = performance.now()
+    const duration = endTime - timer.startTime
+
+    timer.endTime = endTime
+    timer.duration = duration
+
+    // Determine log level based on duration
+    const logLevel = this.getTimerLogLevel(duration)
+    const durationEmoji = this.getDurationEmoji(duration)
+
+    this.logger[logLevel](`${durationEmoji} Timer ${label}: ${duration.toFixed(2)}ms`, {
+      type: 'timer_end',
+      label,
+      duration,
+      ...timer.meta,
+      ...meta
+    })
+
+    // Clean up
+    this.timers.delete(label)
+
+    return duration
+  }
+
+  /**
+   * Measure execution time of a function
+   */
+  async measure<T>(label: string, fn: () => Promise<T>, meta?: any): Promise<T> {
+    this.startTimer(label, meta)
+    try {
+      const result = await fn()
+      this.endTimer(label, { success: true })
+      return result
+    } catch (error) {
+      this.endTimer(label, { success: false, error: error.message })
+      throw error
+    }
+  }
+
+  /**
+   * Measure execution time of a synchronous function
+   */
+  measureSync<T>(label: string, fn: () => T, meta?: any): T {
+    this.startTimer(label, meta)
+    try {
+      const result = fn()
+      this.endTimer(label, { success: true })
+      return result
+    } catch (error) {
+      this.endTimer(label, { success: false, error: error.message })
+      throw error
+    }
+  }
+
+  /**
+   * Log memory usage
+   */
+  logMemoryUsage(label?: string): void {
+    const memUsage = process.memoryUsage()
+    const formatBytes = (bytes: number) => (bytes / 1024 / 1024).toFixed(2) + ' MB'
+
+    this.logger.info(`📊 Memory usage${label ? ` (${label})` : ''}`, {
+      type: 'memory_usage',
+      label,
+      memory: {
+        rss: formatBytes(memUsage.rss),
+        heapTotal: formatBytes(memUsage.heapTotal),
+        heapUsed: formatBytes(memUsage.heapUsed),
+        external: formatBytes(memUsage.external)
+      },
+      raw: memUsage
+    })
+  }
+
+  /**
+   * Log system performance metrics
+   */
+  logSystemMetrics(label?: string): void {
+    const cpuUsage = process.cpuUsage()
+    const uptime = process.uptime()
+
+    this.logger.info(`⚡ System metrics${label ? ` (${label})` : ''}`, {
+      type: 'system_metrics',
+      label,
+      cpu: {
+        user: cpuUsage.user,
+        system: cpuUsage.system
+      },
+      uptime: {
+        seconds: uptime,
+        formatted: this.formatUptime(uptime)
+      }
+    })
+  }
+
+  private getTimerLogLevel(duration: number): 'debug' | 'info' | 'warn' {
+    if (duration > 1000) return 'warn' // > 1 second
+    if (duration > 100) return 'info'  // > 100ms
+    return 'debug'
+  }
+
+  private getDurationEmoji(duration: number): string {
+    if (duration > 5000) return '🐌' // Very slow
+    if (duration > 1000) return '⏳' // Slow
+    if (duration > 100) return '⏱️'  // Medium
+    return '⚡' // Fast
+  }
+
+  private formatUptime(seconds: number): string {
+    const days = Math.floor(seconds / 86400)
+    const hours = Math.floor((seconds % 86400) / 3600)
+    const minutes = Math.floor((seconds % 3600) / 60)
+    const secs = Math.floor(seconds % 60)
+
+    if (days > 0) return `${days}d ${hours}h ${minutes}m ${secs}s`
+    if (hours > 0) return `${hours}h ${minutes}m ${secs}s`
+    if (minutes > 0) return `${minutes}m ${secs}s`
+    return `${secs}s`
+  }
+}
+
+/**
+ * Middleware for automatic request logging
+ */
+export function createRequestLoggingMiddleware(logger: Logger) {
+  const requestLogger = new RequestLogger(logger)
+
+  return {
+    onRequest: (request: any) => {
+      const method = request.method
+      const path = request.url || request.path
+      const userAgent = request.headers?.['user-agent']
+      const ip = request.headers?.['x-forwarded-for'] || request.ip
+
+      const requestId = requestLogger.startRequest(method, path, {
+        userAgent,
+        ip,
+        headers: request.headers
+      })
+
+      // Attach request ID to request for correlation
+      request.requestId = requestId
+      request.logger = requestLogger.childLogger(requestId)
+
+      return requestId
+    },
+
+    onResponse: (request: any, response: any) => {
+      if (request.requestId) {
+        const status = response.status || response.statusCode || 200
+        requestLogger.endRequest(request.requestId, status, {
+          responseHeaders: response.headers
+        })
+      }
+    },
+
+    onError: (request: any, error: Error) => {
+      if (request.requestId) {
+        requestLogger.errorRequest(request.requestId, error)
+      }
+    }
+  }
+}