create-fluxstack 1.0.13 → 1.0.14

package/core/utils/errors/middleware.ts

@@ -0,0 +1,114 @@
+import { Elysia } from 'elysia'
+import { EnhancedErrorHandler, type ErrorHandlerContext, type ErrorHandlerOptions, type ErrorMetricsCollector } from './handlers'
+import type { Logger } from '../logger/index'
+
+export interface ErrorMiddlewareOptions extends ErrorHandlerOptions {
+  logger?: Logger
+  isDevelopment?: boolean
+  enableRequestContext?: boolean
+  metricsCollector?: ErrorMetricsCollector
+}
+
+export const errorMiddleware = (options: ErrorMiddlewareOptions = {}) => {
+  const handler = new EnhancedErrorHandler(options)
+  
+  return new Elysia({ name: 'error-handler' })
+    .onError(async ({ error, request, path, set }) => {
+      // Extract request context
+      const context: ErrorHandlerContext = {
+        logger: options.logger || console as any, // Fallback to console if no logger provided
+        isDevelopment: options.isDevelopment ?? process.env.NODE_ENV === 'development',
+        request,
+        path,
+        method: request.method,
+        correlationId: request.headers.get('x-correlation-id') || undefined,
+        userId: request.headers.get('x-user-id') || undefined,
+        userAgent: request.headers.get('user-agent') || undefined,
+        ip: request.headers.get('x-forwarded-for') || 
+            request.headers.get('x-real-ip') || 
+            'unknown',
+        metricsCollector: options.metricsCollector
+      }
+
+      try {
+        // Convert Elysia error to standard Error if needed
+        const standardError = error instanceof Error ? error : new Error(String(error))
+        const errorResponse = await handler.handle(standardError, context)
+        
+        // Set response status code
+        set.status = errorResponse.error.statusCode
+        
+        // Set correlation ID header if available
+        if (errorResponse.error.correlationId) {
+          set.headers['x-correlation-id'] = errorResponse.error.correlationId
+        }
+        
+        return errorResponse
+      } catch (handlerError) {
+        // Fallback error handling if the error handler itself fails
+        const fallbackLogger = options.logger || console as any
+        fallbackLogger.error('Error handler failed', {
+          originalError: error instanceof Error ? error.message : String(error),
+          handlerError: handlerError instanceof Error ? handlerError.message : handlerError
+        })
+        
+        set.status = 500
+        return {
+          error: {
+            message: 'Internal server error',
+            code: 'INTERNAL_ERROR',
+            statusCode: 500,
+            timestamp: new Date().toISOString()
+          }
+        }
+      }
+    })
+}
+
+// Correlation ID middleware to add correlation IDs to requests
+export const correlationIdMiddleware = () => {
+  return new Elysia({ name: 'correlation-id' })
+    .onRequest(({ request, set }) => {
+      // Check if correlation ID already exists in headers
+      let correlationId = request.headers.get('x-correlation-id')
+      
+      // Generate new correlation ID if not present
+      if (!correlationId) {
+        correlationId = crypto.randomUUID()
+      }
+      
+      // Add correlation ID to response headers
+      set.headers['x-correlation-id'] = correlationId
+      
+      // Store correlation ID in request context for later use
+      // Note: This would typically be stored in a request-scoped context
+      // For now, we'll rely on the error handler to extract it from headers
+    })
+}
+
+// Request context middleware to extract and store request information
+export const requestContextMiddleware = () => {
+  return new Elysia({ name: 'request-context' })
+    .onRequest(({ request, set }) => {
+      // Extract useful request information and store in headers for error handling
+      const userAgent = request.headers.get('user-agent')
+      const ip = request.headers.get('x-forwarded-for') || 
+                 request.headers.get('x-real-ip') || 
+                 'unknown'
+      
+      // Store in custom headers for error handler access
+      // In a real implementation, this would use request-scoped storage
+      if (userAgent) {
+        set.headers['x-internal-user-agent'] = userAgent
+      }
+      set.headers['x-internal-ip'] = ip
+    })
+}
+
+// Combined error handling middleware with all features
+export const fullErrorHandlingMiddleware = (options: ErrorMiddlewareOptions = {}) => {
+  return new Elysia({ name: 'full-error-handling' })
+    .use(correlationIdMiddleware())
+    .use(requestContextMiddleware())
+    .use(errorMiddleware(options))
+}

package/core/utils/logger/formatters.ts

@@ -0,0 +1,222 @@
+/**
+ * FluxStack Logger Formatters
+ * Different formatting strategies for log output
+ */
+
+import type { LogEntry, LogLevel } from './transports'
+
+export interface LogFormatter {
+  format(entry: LogEntry): string
+}
+
+/**
+ * Pretty formatter for development with colors and readable layout
+ */
+export class PrettyFormatter implements LogFormatter {
+  private colors: boolean
+  private timestamp: boolean
+
+  private colorMap = {
+    debug: '\x1b[36m', // cyan
+    info: '\x1b[32m',  // green
+    warn: '\x1b[33m',  // yellow
+    error: '\x1b[31m', // red
+    reset: '\x1b[0m',
+    gray: '\x1b[90m'
+  }
+
+  constructor(options: { colors?: boolean; timestamp?: boolean } = {}) {
+    this.colors = options.colors !== false
+    this.timestamp = options.timestamp !== false
+  }
+
+  format(entry: LogEntry): string {
+    const { timestamp, level, message, meta, context } = entry
+    
+    let formatted = ''
+    
+    // Add timestamp
+    if (this.timestamp) {
+      const color = this.colors ? this.colorMap.gray : ''
+      const reset = this.colors ? this.colorMap.reset : ''
+      formatted += `${color}[${timestamp}]${reset} `
+    }
+    
+    // Add level with color and icon
+    const levelColor = this.colors ? this.colorMap[level] : ''
+    const reset = this.colors ? this.colorMap.reset : ''
+    const levelIcon = this.getLevelIcon(level)
+    const levelStr = level.toUpperCase().padEnd(5)
+    formatted += `${levelColor}${levelIcon} ${levelStr}${reset} `
+    
+    // Add context if available
+    if (context && Object.keys(context).length > 0) {
+      const contextStr = Object.entries(context)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(' ')
+      const contextColor = this.colors ? this.colorMap.gray : ''
+      formatted += `${contextColor}[${contextStr}]${reset} `
+    }
+    
+    // Add message
+    formatted += message
+    
+    // Add meta if available
+    if (meta && typeof meta === 'object') {
+      const metaColor = this.colors ? this.colorMap.gray : ''
+      const metaStr = this.formatMeta(meta)
+      formatted += ` ${metaColor}${metaStr}${reset}`
+    } else if (meta !== undefined) {
+      formatted += ` ${meta}`
+    }
+    
+    return formatted
+  }
+
+  private getLevelIcon(level: LogLevel): string {
+    switch (level) {
+      case 'debug': return '🔍'
+      case 'info': return 'ℹ️ '
+      case 'warn': return '⚠️ '
+      case 'error': return '❌'
+      default: return '  '
+    }
+  }
+
+  private formatMeta(meta: any): string {
+    if (typeof meta === 'object' && meta !== null) {
+      // Pretty print objects with indentation
+      return JSON.stringify(meta, null, 2)
+        .split('\n')
+        .map((line, index) => index === 0 ? line : `    ${line}`)
+        .join('\n')
+    }
+    return String(meta)
+  }
+}
+
+/**
+ * JSON formatter for production with structured output
+ */
+export class JSONFormatter implements LogFormatter {
+  private pretty: boolean
+
+  constructor(options: { pretty?: boolean } = {}) {
+    this.pretty = options.pretty || false
+  }
+
+  format(entry: LogEntry): string {
+    const jsonEntry = {
+      '@timestamp': entry.timestamp,
+      level: entry.level,
+      message: entry.message,
+      ...(entry.context && { context: entry.context }),
+      ...(entry.meta && { meta: entry.meta })
+    }
+    
+    return this.pretty 
+      ? JSON.stringify(jsonEntry, null, 2)
+      : JSON.stringify(jsonEntry)
+  }
+}
+
+/**
+ * Simple formatter for basic text output
+ */
+export class SimpleFormatter implements LogFormatter {
+  private timestamp: boolean
+
+  constructor(options: { timestamp?: boolean } = {}) {
+    this.timestamp = options.timestamp !== false
+  }
+
+  format(entry: LogEntry): string {
+    const { timestamp, level, message, meta, context } = entry
+    
+    let formatted = ''
+    
+    // Add timestamp
+    if (this.timestamp) {
+      formatted += `[${timestamp}] `
+    }
+    
+    // Add level
+    formatted += `${level.toUpperCase().padEnd(5)} `
+    
+    // Add context if available
+    if (context && Object.keys(context).length > 0) {
+      const contextStr = Object.entries(context)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(' ')
+      formatted += `[${contextStr}] `
+    }
+    
+    // Add message
+    formatted += message
+    
+    // Add meta if available
+    if (meta && typeof meta === 'object') {
+      formatted += ` ${JSON.stringify(meta)}`
+    } else if (meta !== undefined) {
+      formatted += ` ${meta}`
+    }
+    
+    return formatted
+  }
+}
+
+/**
+ * Syslog formatter for system logging
+ */
+export class SyslogFormatter implements LogFormatter {
+  private facility: number
+  private hostname: string
+
+  constructor(options: { facility?: number; hostname?: string } = {}) {
+    this.facility = options.facility || 16 // local0
+    this.hostname = options.hostname || require('os').hostname()
+  }
+
+  format(entry: LogEntry): string {
+    const { timestamp, level, message, meta, context } = entry
+    
+    // Calculate priority (facility * 8 + severity)
+    const severity = this.getLevelSeverity(level)
+    const priority = this.facility * 8 + severity
+    
+    // Format timestamp in RFC3339
+    const syslogTime = new Date(timestamp).toISOString()
+    
+    // Build syslog message
+    let syslogMessage = `<${priority}>${syslogTime} ${this.hostname} fluxstack: `
+    
+    // Add context if available
+    if (context && Object.keys(context).length > 0) {
+      const contextStr = Object.entries(context)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(' ')
+      syslogMessage += `[${contextStr}] `
+    }
+    
+    syslogMessage += message
+    
+    // Add meta if available
+    if (meta && typeof meta === 'object') {
+      syslogMessage += ` ${JSON.stringify(meta)}`
+    } else if (meta !== undefined) {
+      syslogMessage += ` ${meta}`
+    }
+    
+    return syslogMessage
+  }
+
+  private getLevelSeverity(level: LogLevel): number {
+    switch (level) {
+      case 'debug': return 7 // debug
+      case 'info': return 6  // info
+      case 'warn': return 4  // warning
+      case 'error': return 3 // error
+      default: return 6
+    }
+  }
+}

package/core/utils/logger/index.ts

@@ -1,11 +1,15 @@
 /**
  * FluxStack Logger
- * Environment-aware logging system
+ * Enhanced logging system with multiple transports and formatters
  */
 
-// Environment info is handled via process.env directly
+import { ConsoleTransport, FileTransport, JSONTransport } from './transports'
+import { PrettyFormatter, JSONFormatter, SimpleFormatter } from './formatters'
+import type { LogTransport, LogEntry, LogLevel } from './transports'
+import type { LogFormatter } from './formatters'
 
-type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+export type { LogLevel, LogTransport, LogEntry } from './transports'
+export type { LogFormatter } from './formatters'
 
 export interface Logger {
   debug(message: string, meta?: any): void
@@ -22,6 +26,19 @@ export interface Logger {
   
   // Request logging
   request(method: string, path: string, status?: number, duration?: number): void
+  
+  // Transport management
+  addTransport(transport: LogTransport): void
+  removeTransport(name: string): void
+  
+  // Cleanup
+  close(): Promise<void>
+}
+
+export interface LoggerConfig {
+  level?: LogLevel
+  transports?: LogTransport[]
+  defaultMeta?: any
 }
 
 class FluxStackLogger implements Logger {
@@ -29,20 +46,59 @@ class FluxStackLogger implements Logger {
   private logLevel: LogLevel
   private context: any = {}
   private timers: Map<string, number> = new Map()
+  private transports: Map<string, LogTransport> = new Map()
+  private defaultMeta: any = {}
 
-  private constructor(context?: any) {
-    // Default to 'info' level, can be overridden by config
-    this.logLevel = (process.env.LOG_LEVEL as LogLevel) || 'info'
-    this.context = context || {}
+  constructor(config?: LoggerConfig) {
+    this.logLevel = config?.level || (process.env.LOG_LEVEL as LogLevel) || 'info'
+    this.context = {}
+    this.defaultMeta = config?.defaultMeta || {}
+    
+    // Setup default transports if none provided
+    if (config?.transports) {
+      config.transports.forEach(transport => {
+        this.transports.set(transport.name, transport)
+      })
+    } else {
+      this.setupDefaultTransports()
+    }
   }
 
-  static getInstance(): FluxStackLogger {
+  static getInstance(config?: LoggerConfig): FluxStackLogger {
     if (FluxStackLogger.instance === null) {
-      FluxStackLogger.instance = new FluxStackLogger()
+      FluxStackLogger.instance = new FluxStackLogger(config)
     }
     return FluxStackLogger.instance
   }
 
+  private setupDefaultTransports(): void {
+    const isDevelopment = process.env.NODE_ENV !== 'production'
+    
+    if (isDevelopment) {
+      // Development: Pretty console output
+      this.transports.set('console', new ConsoleTransport({
+        level: this.logLevel,
+        colors: true,
+        timestamp: true
+      }))
+    } else {
+      // Production: JSON output for structured logging
+      this.transports.set('json', new JSONTransport({
+        level: this.logLevel,
+        pretty: false
+      }))
+      
+      // Also add file transport for production
+      this.transports.set('file', new FileTransport({
+        level: this.logLevel,
+        filename: 'logs/fluxstack.log',
+        maxSize: 10 * 1024 * 1024, // 10MB
+        maxFiles: 5,
+        compress: true
+      }))
+    }
+  }
+
   private shouldLog(level: LogLevel): boolean {
     const levels: Record<LogLevel, number> = {
       debug: 0,
@@ -54,58 +110,63 @@ class FluxStackLogger implements Logger {
     return levels[level] >= levels[this.logLevel]
   }
 
-  private formatMessage(level: LogLevel, message: string, meta?: any): string {
-    const timestamp = new Date().toISOString()
-    const levelStr = level.toUpperCase().padEnd(5)
-    
-    let formatted = `[${timestamp}] ${levelStr}`
-    
-    // Add context if available
-    if (Object.keys(this.context).length > 0) {
-      const contextStr = Object.entries(this.context)
-        .map(([key, value]) => `${key}=${value}`)
-        .join(' ')
-      formatted += ` [${contextStr}]`
-    }
-    
-    formatted += ` ${message}`
-    
-    if (meta && typeof meta === 'object') {
-      formatted += ` ${JSON.stringify(meta)}`
-    } else if (meta !== undefined) {
-      formatted += ` ${meta}`
+  private async writeToTransports(level: LogLevel, message: string, meta?: any): Promise<void> {
+    if (!this.shouldLog(level)) return
+
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      meta: { ...this.defaultMeta, ...meta },
+      context: Object.keys(this.context).length > 0 ? this.context : undefined
     }
-    
-    return formatted
+
+    // Write to all transports
+    const writePromises = Array.from(this.transports.values()).map(async transport => {
+      try {
+        await transport.write(entry)
+      } catch (error) {
+        // Fallback to console if transport fails
+        console.error(`Transport ${transport.name} failed:`, error)
+      }
+    })
+
+    await Promise.all(writePromises)
   }
 
   debug(message: string, meta?: any): void {
-    if (this.shouldLog('debug')) {
-      console.debug(this.formatMessage('debug', message, meta))
-    }
+    this.writeToTransports('debug', message, meta).catch(err => {
+      console.error('Logger error:', err)
+    })
   }
 
   info(message: string, meta?: any): void {
-    if (this.shouldLog('info')) {
-      console.info(this.formatMessage('info', message, meta))
-    }
+    this.writeToTransports('info', message, meta).catch(err => {
+      console.error('Logger error:', err)
+    })
   }
 
   warn(message: string, meta?: any): void {
-    if (this.shouldLog('warn')) {
-      console.warn(this.formatMessage('warn', message, meta))
-    }
+    this.writeToTransports('warn', message, meta).catch(err => {
+      console.error('Logger error:', err)
+    })
   }
 
   error(message: string, meta?: any): void {
-    if (this.shouldLog('error')) {
-      console.error(this.formatMessage('error', message, meta))
-    }
+    this.writeToTransports('error', message, meta).catch(err => {
+      console.error('Logger error:', err)
+    })
   }
 
   // Contextual logging
   child(context: any): FluxStackLogger {
-    return new FluxStackLogger({ ...this.context, ...context })
+    const childLogger = new FluxStackLogger({
+      level: this.logLevel,
+      transports: Array.from(this.transports.values()),
+      defaultMeta: this.defaultMeta
+    })
+    childLogger.context = { ...this.context, ...context }
+    return childLogger
   }
 
   // Performance logging
@@ -124,22 +185,72 @@ class FluxStackLogger implements Logger {
 
   // HTTP request logging
   request(method: string, path: string, status?: number, duration?: number): void {
+    const meta: any = { method, path }
+    if (status) meta.status = status
+    if (duration) meta.duration = duration
+    
     const statusStr = status ? ` ${status}` : ''
     const durationStr = duration ? ` (${duration}ms)` : ''
-    this.info(`${method} ${path}${statusStr}${durationStr}`)
+    this.info(`${method} ${path}${statusStr}${durationStr}`, meta)
+  }
+
+  // Transport management
+  addTransport(transport: LogTransport): void {
+    this.transports.set(transport.name, transport)
+  }
+
+  removeTransport(name: string): void {
+    const transport = this.transports.get(name)
+    if (transport && transport.close) {
+      const closeResult = transport.close()
+      if (closeResult instanceof Promise) {
+        closeResult.catch(console.error)
+      }
+    }
+    this.transports.delete(name)
+  }
+
+  // Cleanup
+  async close(): Promise<void> {
+    const closePromises = Array.from(this.transports.values())
+      .filter(transport => transport.close)
+      .map(transport => transport.close!())
+    
+    await Promise.all(closePromises)
+    this.transports.clear()
   }
 
   // Plugin logging
   plugin(pluginName: string, message: string, meta?: any): void {
-    this.debug(`[${pluginName}] ${message}`, meta)
+    this.debug(`[${pluginName}] ${message}`, { plugin: pluginName, ...meta })
   }
 
   // Framework logging
   framework(message: string, meta?: any): void {
-    this.info(`[FluxStack] ${message}`, meta)
+    this.info(`[FluxStack] ${message}`, { component: 'framework', ...meta })
   }
 }
 
+// Export transport and formatter classes
+export { ConsoleTransport, FileTransport, JSONTransport } from './transports'
+export { PrettyFormatter, JSONFormatter, SimpleFormatter } from './formatters'
+
+// Export performance utilities
+export { 
+  RequestLogger, 
+  PerformanceLogger, 
+  createRequestLoggingMiddleware 
+} from './performance'
+export type { RequestContext, PerformanceTimer } from './performance'
+
+// Export middleware utilities
+export {
+  createElysiaLoggerMiddleware,
+  createDatabaseLoggerMiddleware,
+  createPluginLoggerMiddleware,
+  createBuildLoggerMiddleware
+} from './middleware'
+
 // Export singleton instance
 export const logger = FluxStackLogger.getInstance()
 
@@ -157,5 +268,13 @@ export const log = {
     logger.framework(message, meta),
   child: (context: any) => logger.child(context),
   time: (label: string) => logger.time(label),
-  timeEnd: (label: string) => logger.timeEnd(label)
+  timeEnd: (label: string) => logger.timeEnd(label),
+  addTransport: (transport: LogTransport) => logger.addTransport(transport),
+  removeTransport: (name: string) => logger.removeTransport(name),
+  close: () => logger.close()
+}
+
+// Factory function for creating configured loggers
+export function createLogger(config: LoggerConfig): Logger {
+  return new FluxStackLogger(config)
 }