@morojs/moro 1.5.4 → 1.5.6

package/src/core/http/http-server.ts

@@ -26,6 +26,11 @@ export class MoroHttpServer {
   // Request handler pooling to avoid function creation overhead
   private middlewareExecutionCache = new Map<string, Function>();
 
+  // Response caching for ultra-fast common responses
+  private responseCache = new Map<string, Buffer>();
+  private responseCacheHits = 0;
+  private responseCacheMisses = 0;
+
   // String interning for common values (massive memory savings)
   private static readonly INTERNED_METHODS = new Map([
     ['GET', 'GET'],
@@ -492,6 +497,20 @@ export class MoroHttpServer {
     httpRes.json = async (data: any) => {
       if (httpRes.headersSent) return;
 
+      // PERFORMANCE OPTIMIZATION: Check response cache for common patterns
+      const cacheKey = this.getResponseCacheKey(data);
+      if (cacheKey) {
+        const cachedBuffer = this.responseCache.get(cacheKey);
+        if (cachedBuffer) {
+          this.responseCacheHits++;
+          httpRes.setHeader('Content-Type', 'application/json; charset=utf-8');
+          httpRes.setHeader('Content-Length', cachedBuffer.length);
+          httpRes.end(cachedBuffer);
+          return;
+        }
+        this.responseCacheMisses++;
+      }
+
       // Ultra-fast JSON serialization with zero-copy buffers
       let jsonString: string;
 
@@ -578,6 +597,12 @@ export class MoroHttpServer {
       });
 
       httpRes.end(finalBuffer);
+
+      // PERFORMANCE OPTIMIZATION: Cache small, common responses
+      if (cacheKey && finalBuffer.length < 1024 && this.responseCache.size < 100) {
+        this.responseCache.set(cacheKey, Buffer.from(finalBuffer));
+      }
+
       // Return buffer to pool after response (zero-copy achievement!)
       process.nextTick(() => MoroHttpServer.returnBuffer(buffer));
     };
@@ -953,6 +978,47 @@ export class MoroHttpServer {
   getServer(): Server {
     return this.server;
   }
+
+  // PERFORMANCE OPTIMIZATION: Generate cache key for common response patterns
+  private getResponseCacheKey(data: any): string | null {
+    // Only cache simple, common responses
+    if (!data || typeof data !== 'object') {
+      // Simple primitives or strings - generate key
+      const key = JSON.stringify(data);
+      return key.length < 100 ? key : null;
+    }
+
+    // Common API response patterns
+    if ('hello' in data && Object.keys(data).length <= 2) {
+      // Hello world type responses
+      return `hello:${JSON.stringify(data)}`;
+    }
+
+    if ('status' in data && Object.keys(data).length <= 3) {
+      // Status responses like {status: "ok", version: "1.0.0"}
+      return `status:${JSON.stringify(data)}`;
+    }
+
+    if ('success' in data && 'message' in data && Object.keys(data).length <= 3) {
+      // Simple success/error responses
+      return `msg:${data.success}:${data.message}`;
+    }
+
+    // Don't cache complex objects
+    return null;
+  }
+
+  // Performance statistics
+  getPerformanceStats() {
+    return {
+      responseCacheHits: this.responseCacheHits,
+      responseCacheMisses: this.responseCacheMisses,
+      responseCacheSize: this.responseCache.size,
+      paramObjectPoolSize: this.paramObjectPool.length,
+      bufferPoolSize: this.bufferPool.length,
+      middlewareExecutionCacheSize: this.middlewareExecutionCache.size,
+    };
+  }
 }
 
 // Built-in middleware

package/src/core/http/router.ts

@@ -12,6 +12,14 @@ export class Router {
   private routes: RouteDefinition[] = [];
   private logger = createFrameworkLogger('Router');
 
+  // Performance optimizations - O(1) static route lookup
+  private staticRoutes = new Map<string, RouteDefinition>(); // "GET:/api/users" -> route
+  private dynamicRoutes: RouteDefinition[] = []; // Routes with parameters
+
+  // Object pooling for parameters to reduce GC pressure
+  private paramObjectPool: Record<string, string>[] = [];
+  private readonly maxPoolSize = 50;
+
   get(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
     this.addRoute('GET', path, handlers);
   }
@@ -37,14 +45,37 @@ export class Router {
     const handler = handlers.pop() as HttpHandler;
     const middleware = handlers as Middleware[];
 
-    this.routes.push({
+    const route: RouteDefinition = {
       method,
       path,
       pattern,
       paramNames,
       handler,
       middleware,
-    });
+    };
+
+    // Add to routes array (maintain compatibility)
+    this.routes.push(route);
+
+    // Performance optimization: separate static and dynamic routes
+    const isStatic = !path.includes(':') && !path.includes('*');
+    if (isStatic && middleware.length === 0) {
+      // Static route with no middleware - use O(1) lookup
+      const routeKey = `${method}:${path}`;
+      this.staticRoutes.set(routeKey, route);
+      this.logger.debug(`Added static route: ${routeKey}`, 'FastRoute');
+    } else {
+      // Dynamic route or has middleware - needs regex matching
+      this.dynamicRoutes.push(route);
+      this.logger.debug(`Added dynamic route: ${method} ${path}`, 'DynamicRoute');
+    }
+
+    // Initialize object pool on first route
+    if (this.paramObjectPool.length === 0) {
+      for (let i = 0; i < this.maxPoolSize; i++) {
+        this.paramObjectPool.push({});
+      }
+    }
   }
 
   private pathToRegex(path: string): { pattern: RegExp; paramNames: string[] } {
@@ -77,10 +108,30 @@ export class Router {
       'Processing'
     );
 
-    const route = this.routes.find(r => r.method === req.method && r.pattern.test(path));
+    // PERFORMANCE OPTIMIZATION: Fast path - O(1) static route lookup first
+    const routeKey = `${req.method}:${path}`;
+    const staticRoute = this.staticRoutes.get(routeKey);
+
+    if (staticRoute) {
+      this.logger.debug(`Fast route match: ${routeKey}`, 'FastRoute');
+
+      // Static route with no middleware - execute handler directly
+      req.params = {}; // No params for static routes
+      const result = await staticRoute.handler(req, res);
+
+      // If handler returns data and response hasn't been sent, send it
+      if (result !== undefined && result !== null && !res.headersSent) {
+        res.json(result);
+      }
+
+      return true;
+    }
+
+    // Fallback: Dynamic route matching (with middleware support)
+    const route = this.dynamicRoutes.find(r => r.method === req.method && r.pattern.test(path));
 
     this.logger.debug(
-      `Found route: ${!!route}${route ? ` ${route.method} ${route.path}` : ' none'}`,
+      `Found dynamic route: ${!!route}${route ? ` ${route.method} ${route.path}` : ' none'}`,
       'RouteMatch'
     );
 
@@ -88,54 +139,92 @@ export class Router {
       return false; // Route not found
     }
 
-    // Extract path parameters
+    // Extract path parameters using object pooling
     const matches = path.match(route.pattern);
     if (matches) {
-      req.params = {};
+      req.params = this.acquireParamObject();
       route.paramNames.forEach((name, index) => {
         req.params[name] = matches[index + 1];
       });
     }
 
-    // Execute middleware
-    for (const mw of route.middleware) {
-      await new Promise<void>((resolve, reject) => {
-        let nextCalled = false;
-
-        const next = () => {
-          if (nextCalled) return;
-          nextCalled = true;
-          resolve();
-        };
-
-        try {
-          const result = mw(req, res, next);
-
-          if (result instanceof Promise) {
-            result
-              .then(() => {
-                if (!nextCalled) next();
-              })
-              .catch(reject);
+    try {
+      // Execute middleware
+      for (const mw of route.middleware) {
+        await new Promise<void>((resolve, reject) => {
+          let nextCalled = false;
+
+          const next = () => {
+            if (nextCalled) return;
+            nextCalled = true;
+            resolve();
+          };
+
+          try {
+            const result = mw(req, res, next);
+
+            if (result instanceof Promise) {
+              result
+                .then(() => {
+                  if (!nextCalled) next();
+                })
+                .catch(reject);
+            }
+          } catch (error) {
+            reject(error);
           }
-        } catch (error) {
-          reject(error);
-        }
-      });
-    }
+        });
 
-    // Execute handler
-    const result = await route.handler(req, res);
+        if (res.headersSent) break; // Early exit if response sent
+      }
 
-    // If handler returns data and response hasn't been sent, send it
-    if (result !== undefined && result !== null && !res.headersSent) {
-      res.json(result);
-    }
+      // Execute handler
+      const result = await route.handler(req, res);
 
-    return true;
+      // If handler returns data and response hasn't been sent, send it
+      if (result !== undefined && result !== null && !res.headersSent) {
+        res.json(result);
+      }
+
+      return true;
+    } finally {
+      // Release parameter object back to pool
+      if (req.params && matches) {
+        this.releaseParamObject(req.params);
+      }
+    }
   }
 
   getRoutes(): RouteDefinition[] {
     return [...this.routes];
   }
+
+  // Object pooling methods for performance optimization
+  private acquireParamObject(): Record<string, string> {
+    const obj = this.paramObjectPool.pop();
+    if (obj) {
+      // Clear the object
+      for (const key in obj) {
+        delete obj[key];
+      }
+      return obj;
+    }
+    return {};
+  }
+
+  private releaseParamObject(obj: Record<string, string>): void {
+    if (this.paramObjectPool.length < this.maxPoolSize) {
+      this.paramObjectPool.push(obj);
+    }
+  }
+
+  // Performance statistics for monitoring
+  getPerformanceStats() {
+    return {
+      totalRoutes: this.routes.length,
+      staticRoutes: this.staticRoutes.size,
+      dynamicRoutes: this.dynamicRoutes.length,
+      paramObjectPoolSize: this.paramObjectPool.length,
+    };
+  }
 }

package/src/core/logger/index.ts

@@ -5,6 +5,7 @@ export {
   createFrameworkLogger,
   configureGlobalLogger,
   applyLoggingConfiguration,
+  destroyGlobalLogger,
 } from './logger';
 export * from './filters';
 

package/src/core/logger/logger.ts

@@ -60,6 +60,7 @@ export class MoroLogger implements Logger {
   // Buffer overflow protection
   private bufferOverflowThreshold: number;
   private emergencyFlushInProgress = false;
+  private isDestroyed = false;
 
   // High-performance output methods
 
@@ -226,7 +227,9 @@ export class MoroLogger implements Logger {
   }
 
   child(context: string, metadata?: Record<string, any>): Logger {
-    const childLogger = new MoroLogger(this.options);
+    // Create child logger with current parent level (not original options level)
+    const childOptions = { ...this.options, level: this.level };
+    const childLogger = new MoroLogger(childOptions);
     childLogger.contextPrefix = this.contextPrefix ? `${this.contextPrefix}:${context}` : context;
     childLogger.contextMetadata = { ...this.contextMetadata, ...metadata };
     childLogger.outputs = this.outputs;
@@ -242,6 +245,10 @@ export class MoroLogger implements Logger {
     this.level = level;
   }
 
+  getLevel(): LogLevel {
+    return this.level;
+  }
+
   addOutput(output: LogOutput): void {
     this.outputs.set(output.name, output);
   }
@@ -344,24 +351,13 @@ export class MoroLogger implements Logger {
 
     // Absolute minimal path for simple logs - pure speed
     if (!metadata && !context && !this.contextPrefix && !this.contextMetadata) {
-      const logStr = level.toUpperCase() + ' ' + message + '\n';
-      if (level === 'error' || level === 'fatal') {
-        process.stderr.write(logStr);
-      } else {
-        process.stdout.write(logStr);
-      }
+      this.writeSimpleLog(level, message);
       return;
     }
 
     // Minimal path for logs with context but no metadata
     if (!metadata && !this.contextMetadata) {
-      const contextStr = context ? '[' + context + '] ' : '';
-      const logStr = level.toUpperCase() + ' ' + contextStr + message + '\n';
-      if (level === 'error' || level === 'fatal') {
-        process.stderr.write(logStr);
-      } else {
-        process.stdout.write(logStr);
-      }
+      this.writeSimpleLog(level, message, context);
       return;
     }
 
@@ -427,33 +423,78 @@ export class MoroLogger implements Logger {
     context?: string,
     metadata?: Record<string, any>
   ): void {
-    // Build string directly - no array, no try-catch, no metrics
-    let logStr = this.getFastCachedTimestamp() + ' ' + level.toUpperCase().padEnd(5);
+    // Use object pooling for LogEntry (Pino's technique)
+    const entry = MoroLogger.getPooledEntry();
+    const now = Date.now();
 
-    if (context) {
-      logStr += '[' + context + '] ';
-    } else if (this.contextPrefix) {
-      logStr += '[' + this.contextPrefix + '] ';
-    }
+    entry.timestamp = new Date(now);
+    entry.level = level;
+    entry.message = message;
+    entry.context = this.contextPrefix
+      ? context
+        ? `${this.contextPrefix}:${context}`
+        : this.contextPrefix
+      : context;
+    entry.metadata = this.createMetadata(metadata);
+    entry.performance = this.options.enablePerformance ? this.getPerformanceData(now) : undefined;
 
-    logStr += message;
+    // Write to outputs with batched processing
+    this.writeToOutputs(entry, level);
 
-    if (metadata && Object.keys(metadata).length > 0) {
-      logStr += ' ' + this.safeStringify(metadata);
-    }
+    // Return entry to pool
+    MoroLogger.returnPooledEntry(entry);
+  }
 
-    if (this.contextMetadata && Object.keys(this.contextMetadata).length > 0) {
-      logStr += ' ' + this.safeStringify(this.contextMetadata);
-    }
+  // Simple log writer with colors for minimal overhead cases
+  private writeSimpleLog(level: LogLevel, message: string, context?: string): void {
+    const colors = this.options.enableColors !== false;
+    const levelReset = colors ? MoroLogger.RESET : '';
 
-    logStr += '\n';
+    MoroLogger.resetStringBuilder();
 
-    // Direct write - no error handling, no buffering
-    if (level === 'error' || level === 'fatal') {
-      process.stderr.write(logStr);
+    // Timestamp with caching optimization
+    if (this.options.enableTimestamp !== false) {
+      const timestamp = this.getFastCachedTimestamp();
+      if (colors) {
+        MoroLogger.appendToBuilder(MoroLogger.COLORS.timestamp);
+        MoroLogger.appendToBuilder(timestamp);
+        MoroLogger.appendToBuilder(levelReset);
+      } else {
+        MoroLogger.appendToBuilder(timestamp);
+      }
+      MoroLogger.appendToBuilder(' ');
+    }
+
+    // Level with pre-allocated strings
+    const levelStr = MoroLogger.LEVEL_STRINGS[level];
+    if (colors) {
+      MoroLogger.appendToBuilder(MoroLogger.COLORS[level]);
+      MoroLogger.appendToBuilder(MoroLogger.BOLD);
+      MoroLogger.appendToBuilder(levelStr);
+      MoroLogger.appendToBuilder(levelReset);
     } else {
-      process.stdout.write(logStr);
+      MoroLogger.appendToBuilder(levelStr);
+    }
+
+    // Context
+    if (context && this.options.enableContext !== false) {
+      MoroLogger.appendToBuilder(' ');
+      if (colors) {
+        MoroLogger.appendToBuilder(MoroLogger.COLORS.context);
+        MoroLogger.appendToBuilder(`[${context}]`);
+        MoroLogger.appendToBuilder(levelReset);
+      } else {
+        MoroLogger.appendToBuilder(`[${context}]`);
+      }
     }
+
+    // Message
+    MoroLogger.appendToBuilder(' ');
+    MoroLogger.appendToBuilder(message);
+
+    // Output main log line with high-performance method
+    const finalMessage = MoroLogger.buildString();
+    this.output(`${finalMessage}\n`, level);
   }
 
   private updateMetrics(entry: LogEntry): void {
@@ -691,8 +732,8 @@ export class MoroLogger implements Logger {
   }
 
   private scheduleFlush(): void {
-    if (this.flushTimeout) {
-      return; // Already scheduled
+    if (this.flushTimeout || this.isDestroyed) {
+      return; // Already scheduled or destroyed
     }
 
     this.flushTimeout = setTimeout(() => {
@@ -700,7 +741,7 @@ export class MoroLogger implements Logger {
     }, this.flushInterval);
   }
 
-  private flushBuffer(): void {
+  public flushBuffer(): void {
     if (this.outputBuffer.length === 0) {
       return;
     }
@@ -882,6 +923,30 @@ export class MoroLogger implements Logger {
       // Ignore flush errors
     }
   }
+
+  // Destroy logger and clean up all resources (for testing)
+  public destroy(): void {
+    // Mark as destroyed to prevent new timeouts
+    this.isDestroyed = true;
+
+    // Clear any remaining timeouts
+    if (this.flushTimeout) {
+      clearTimeout(this.flushTimeout);
+      this.flushTimeout = null;
+    }
+
+    // Flush any remaining buffer
+    this.flushBuffer();
+
+    // Clear outputs and filters
+    this.outputs.clear();
+    this.filters.clear();
+
+    // Clear history
+    this.history.length = 0;
+    this.historyIndex = 0;
+    this.historySize = 0;
+  }
 }
 
 // Global logger instance
@@ -908,6 +973,14 @@ export function configureGlobalLogger(options: Partial<LoggerOptions>): void {
   // For now, focusing on level which is the most critical
 }
 
+/**
+ * Destroy the global logger and clean up resources (for testing)
+ * @internal
+ */
+export function destroyGlobalLogger(): void {
+  logger.destroy();
+}
+
 /**
  * Apply logging configuration from the config system and/or createApp options
  */