@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/delivery/smtpserver/utils/adaptive-logging.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Adaptive SMTP Logging System
+ * Automatically switches between logging modes based on server load (active connections)
+ * to maintain performance during high-concurrency scenarios
+ */
+import * as plugins from '../../../../plugins.js';
+import { SecurityLogLevel, SecurityEventType } from '../constants.js';
+import type { ISmtpSession } from '../interfaces.js';
+import type { LogLevel, ISmtpLogOptions } from './logging.js';
+/**
+ * Log modes based on server load
+ */
+export declare enum LogMode {
+    VERBOSE = "VERBOSE",// < 20 connections: Full detailed logging
+    REDUCED = "REDUCED",// 20-40 connections: Limited command/response logging, full error logging
+    MINIMAL = "MINIMAL"
+}
+/**
+ * Configuration for adaptive logging thresholds
+ */
+export interface IAdaptiveLogConfig {
+    verboseThreshold: number;
+    reducedThreshold: number;
+    aggregationInterval: number;
+    maxAggregatedEntries: number;
+}
+/**
+ * Connection metadata for aggregation tracking
+ */
+interface IConnectionTracker {
+    activeConnections: number;
+    peakConnections: number;
+    totalConnections: number;
+    connectionsPerSecond: number;
+    lastConnectionTime: number;
+}
+/**
+ * Adaptive SMTP Logger that scales logging based on server load
+ */
+export declare class AdaptiveSmtpLogger {
+    private static instance;
+    private currentMode;
+    private config;
+    private aggregatedEntries;
+    private aggregationTimer;
+    private connectionTracker;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(config?: Partial<IAdaptiveLogConfig>): AdaptiveSmtpLogger;
+    /**
+     * Update active connection count and adjust log mode if needed
+     */
+    updateConnectionCount(activeConnections: number): void;
+    /**
+     * Track new connection for rate calculation
+     */
+    trackConnection(): void;
+    /**
+     * Get current logging mode
+     */
+    getCurrentMode(): LogMode;
+    /**
+     * Get connection statistics
+     */
+    getConnectionStats(): IConnectionTracker;
+    /**
+     * Log a message with adaptive behavior
+     */
+    log(level: LogLevel, message: string, options?: ISmtpLogOptions): void;
+    /**
+     * Log command with adaptive behavior
+     */
+    logCommand(command: string, socket: plugins.net.Socket | plugins.tls.TLSSocket, session?: ISmtpSession): void;
+    /**
+     * Log response with adaptive behavior
+     */
+    logResponse(response: string, socket: plugins.net.Socket | plugins.tls.TLSSocket): void;
+    /**
+     * Log connection event with adaptive behavior
+     */
+    logConnection(socket: plugins.net.Socket | plugins.tls.TLSSocket, eventType: 'connect' | 'close' | 'error', session?: ISmtpSession, error?: Error): void;
+    /**
+     * Log security event (always logged regardless of mode)
+     */
+    logSecurityEvent(level: SecurityLogLevel, type: SecurityEventType, message: string, details: Record<string, any>, ipAddress?: string, domain?: string, success?: boolean): void;
+    /**
+     * Determine appropriate log mode based on connection count
+     */
+    private determineLogMode;
+    /**
+     * Switch to a new log mode
+     */
+    private switchLogMode;
+    /**
+     * Add entry to aggregation buffer
+     */
+    private aggregateEntry;
+    /**
+     * Start the aggregation timer
+     */
+    private startAggregationTimer;
+    /**
+     * Flush aggregated entries to logs
+     */
+    private flushAggregatedEntries;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}
+/**
+ * Default instance for easy access
+ */
+export declare const adaptiveLogger: AdaptiveSmtpLogger;
+export {};

package/dist_ts/ts/mail/delivery/smtpserver/utils/adaptive-logging.js

@@ -0,0 +1,411 @@
+/**
+ * Adaptive SMTP Logging System
+ * Automatically switches between logging modes based on server load (active connections)
+ * to maintain performance during high-concurrency scenarios
+ */
+import * as plugins from '../../../../plugins.js';
+import { logger } from '../../../../logger.js';
+import { SecurityLogLevel, SecurityEventType } from '../constants.js';
+/**
+ * Log modes based on server load
+ */
+export var LogMode;
+(function (LogMode) {
+    LogMode["VERBOSE"] = "VERBOSE";
+    LogMode["REDUCED"] = "REDUCED";
+    LogMode["MINIMAL"] = "MINIMAL"; // 40+ connections: Aggregated logging only, critical errors only
+})(LogMode || (LogMode = {}));
+/**
+ * Adaptive SMTP Logger that scales logging based on server load
+ */
+export class AdaptiveSmtpLogger {
+    constructor(config) {
+        this.currentMode = LogMode.VERBOSE;
+        this.aggregatedEntries = new Map();
+        this.aggregationTimer = null;
+        this.connectionTracker = {
+            activeConnections: 0,
+            peakConnections: 0,
+            totalConnections: 0,
+            connectionsPerSecond: 0,
+            lastConnectionTime: Date.now()
+        };
+        this.config = {
+            verboseThreshold: 20,
+            reducedThreshold: 40,
+            aggregationInterval: 30000, // 30 seconds
+            maxAggregatedEntries: 100,
+            ...config
+        };
+        this.startAggregationTimer();
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance(config) {
+        if (!AdaptiveSmtpLogger.instance) {
+            AdaptiveSmtpLogger.instance = new AdaptiveSmtpLogger(config);
+        }
+        return AdaptiveSmtpLogger.instance;
+    }
+    /**
+     * Update active connection count and adjust log mode if needed
+     */
+    updateConnectionCount(activeConnections) {
+        this.connectionTracker.activeConnections = activeConnections;
+        this.connectionTracker.peakConnections = Math.max(this.connectionTracker.peakConnections, activeConnections);
+        const newMode = this.determineLogMode(activeConnections);
+        if (newMode !== this.currentMode) {
+            this.switchLogMode(newMode);
+        }
+    }
+    /**
+     * Track new connection for rate calculation
+     */
+    trackConnection() {
+        this.connectionTracker.totalConnections++;
+        const now = Date.now();
+        const timeDiff = (now - this.connectionTracker.lastConnectionTime) / 1000;
+        if (timeDiff > 0) {
+            this.connectionTracker.connectionsPerSecond = 1 / timeDiff;
+        }
+        this.connectionTracker.lastConnectionTime = now;
+    }
+    /**
+     * Get current logging mode
+     */
+    getCurrentMode() {
+        return this.currentMode;
+    }
+    /**
+     * Get connection statistics
+     */
+    getConnectionStats() {
+        return { ...this.connectionTracker };
+    }
+    /**
+     * Log a message with adaptive behavior
+     */
+    log(level, message, options = {}) {
+        // Always log structured data
+        const errorInfo = options.error ? {
+            errorMessage: options.error.message,
+            errorStack: options.error.stack,
+            errorName: options.error.name
+        } : {};
+        const logData = {
+            component: 'smtp-server',
+            logMode: this.currentMode,
+            activeConnections: this.connectionTracker.activeConnections,
+            ...options,
+            ...errorInfo
+        };
+        if (logData.error) {
+            delete logData.error;
+        }
+        logger.log(level, message, logData);
+        // Adaptive console logging based on mode
+        switch (this.currentMode) {
+            case LogMode.VERBOSE:
+                // Full console logging
+                if (level === 'error' || level === 'warn') {
+                    console[level](`[SMTP] ${message}`, logData);
+                }
+                break;
+            case LogMode.REDUCED:
+                // Only errors and warnings to console
+                if (level === 'error' || level === 'warn') {
+                    console[level](`[SMTP] ${message}`, logData);
+                }
+                break;
+            case LogMode.MINIMAL:
+                // Only critical errors to console
+                if (level === 'error' && (message.includes('critical') || message.includes('security') || message.includes('crash'))) {
+                    console[level](`[SMTP] ${message}`, logData);
+                }
+                break;
+        }
+    }
+    /**
+     * Log command with adaptive behavior
+     */
+    logCommand(command, socket, session) {
+        const clientInfo = {
+            remoteAddress: socket.remoteAddress,
+            remotePort: socket.remotePort,
+            secure: socket instanceof plugins.tls.TLSSocket,
+            sessionId: session?.id,
+            sessionState: session?.state
+        };
+        switch (this.currentMode) {
+            case LogMode.VERBOSE:
+                this.log('info', `Command received: ${command}`, {
+                    ...clientInfo,
+                    command: command.split(' ')[0]?.toUpperCase()
+                });
+                console.log(`← ${command}`);
+                break;
+            case LogMode.REDUCED:
+                // Aggregate commands instead of logging each one
+                this.aggregateEntry('command', 'info', `Command: ${command.split(' ')[0]?.toUpperCase()}`, clientInfo);
+                // Only show error commands
+                if (command.toUpperCase().startsWith('QUIT') || command.includes('error')) {
+                    console.log(`← ${command}`);
+                }
+                break;
+            case LogMode.MINIMAL:
+                // Only aggregate, no console output unless it's an error command
+                this.aggregateEntry('command', 'info', `Command: ${command.split(' ')[0]?.toUpperCase()}`, clientInfo);
+                break;
+        }
+    }
+    /**
+     * Log response with adaptive behavior
+     */
+    logResponse(response, socket) {
+        const clientInfo = {
+            remoteAddress: socket.remoteAddress,
+            remotePort: socket.remotePort,
+            secure: socket instanceof plugins.tls.TLSSocket
+        };
+        const responseCode = response.substring(0, 3);
+        const isError = responseCode.startsWith('4') || responseCode.startsWith('5');
+        switch (this.currentMode) {
+            case LogMode.VERBOSE:
+                if (responseCode.startsWith('2') || responseCode.startsWith('3')) {
+                    this.log('debug', `Response sent: ${response}`, clientInfo);
+                }
+                else if (responseCode.startsWith('4')) {
+                    this.log('warn', `Temporary error response: ${response}`, clientInfo);
+                }
+                else if (responseCode.startsWith('5')) {
+                    this.log('error', `Permanent error response: ${response}`, clientInfo);
+                }
+                console.log(`→ ${response}`);
+                break;
+            case LogMode.REDUCED:
+                // Log errors normally, aggregate success responses
+                if (isError) {
+                    if (responseCode.startsWith('4')) {
+                        this.log('warn', `Temporary error response: ${response}`, clientInfo);
+                    }
+                    else {
+                        this.log('error', `Permanent error response: ${response}`, clientInfo);
+                    }
+                    console.log(`→ ${response}`);
+                }
+                else {
+                    this.aggregateEntry('response', 'debug', `Response: ${responseCode}xx`, clientInfo);
+                }
+                break;
+            case LogMode.MINIMAL:
+                // Only log critical errors
+                if (responseCode.startsWith('5')) {
+                    this.log('error', `Permanent error response: ${response}`, clientInfo);
+                    console.log(`→ ${response}`);
+                }
+                else {
+                    this.aggregateEntry('response', 'debug', `Response: ${responseCode}xx`, clientInfo);
+                }
+                break;
+        }
+    }
+    /**
+     * Log connection event with adaptive behavior
+     */
+    logConnection(socket, eventType, session, error) {
+        const clientInfo = {
+            remoteAddress: socket.remoteAddress,
+            remotePort: socket.remotePort,
+            secure: socket instanceof plugins.tls.TLSSocket,
+            sessionId: session?.id,
+            sessionState: session?.state
+        };
+        if (eventType === 'connect') {
+            this.trackConnection();
+        }
+        switch (this.currentMode) {
+            case LogMode.VERBOSE:
+                // Full connection logging
+                switch (eventType) {
+                    case 'connect':
+                        this.log('info', `New ${clientInfo.secure ? 'secure ' : ''}connection from ${clientInfo.remoteAddress}:${clientInfo.remotePort}`, clientInfo);
+                        break;
+                    case 'close':
+                        this.log('info', `Connection closed from ${clientInfo.remoteAddress}:${clientInfo.remotePort}`, clientInfo);
+                        break;
+                    case 'error':
+                        this.log('error', `Connection error from ${clientInfo.remoteAddress}:${clientInfo.remotePort}`, {
+                            ...clientInfo,
+                            error
+                        });
+                        break;
+                }
+                break;
+            case LogMode.REDUCED:
+                // Aggregate normal connections, log errors
+                if (eventType === 'error') {
+                    this.log('error', `Connection error from ${clientInfo.remoteAddress}:${clientInfo.remotePort}`, {
+                        ...clientInfo,
+                        error
+                    });
+                }
+                else {
+                    this.aggregateEntry('connection', 'info', `Connection ${eventType}`, clientInfo);
+                }
+                break;
+            case LogMode.MINIMAL:
+                // Only aggregate, except for critical errors
+                if (eventType === 'error' && error && (error.message.includes('security') || error.message.includes('critical'))) {
+                    this.log('error', `Critical connection error from ${clientInfo.remoteAddress}:${clientInfo.remotePort}`, {
+                        ...clientInfo,
+                        error
+                    });
+                }
+                else {
+                    this.aggregateEntry('connection', 'info', `Connection ${eventType}`, clientInfo);
+                }
+                break;
+        }
+    }
+    /**
+     * Log security event (always logged regardless of mode)
+     */
+    logSecurityEvent(level, type, message, details, ipAddress, domain, success) {
+        const logLevel = level === SecurityLogLevel.DEBUG ? 'debug' :
+            level === SecurityLogLevel.INFO ? 'info' :
+                level === SecurityLogLevel.WARN ? 'warn' : 'error';
+        // Security events are always logged in full detail
+        this.log(logLevel, message, {
+            component: 'smtp-security',
+            eventType: type,
+            success,
+            ipAddress,
+            domain,
+            ...details
+        });
+    }
+    /**
+     * Determine appropriate log mode based on connection count
+     */
+    determineLogMode(activeConnections) {
+        if (activeConnections >= this.config.reducedThreshold) {
+            return LogMode.MINIMAL;
+        }
+        else if (activeConnections >= this.config.verboseThreshold) {
+            return LogMode.REDUCED;
+        }
+        else {
+            return LogMode.VERBOSE;
+        }
+    }
+    /**
+     * Switch to a new log mode
+     */
+    switchLogMode(newMode) {
+        const oldMode = this.currentMode;
+        this.currentMode = newMode;
+        // Log the mode switch
+        console.log(`[SMTP] Adaptive logging switched from ${oldMode} to ${newMode} (${this.connectionTracker.activeConnections} active connections)`);
+        this.log('info', `Adaptive logging mode changed to ${newMode}`, {
+            oldMode,
+            newMode,
+            activeConnections: this.connectionTracker.activeConnections,
+            peakConnections: this.connectionTracker.peakConnections,
+            totalConnections: this.connectionTracker.totalConnections
+        });
+        // If switching to more verbose mode, flush aggregated entries
+        if ((oldMode === LogMode.MINIMAL && newMode !== LogMode.MINIMAL) ||
+            (oldMode === LogMode.REDUCED && newMode === LogMode.VERBOSE)) {
+            this.flushAggregatedEntries();
+        }
+    }
+    /**
+     * Add entry to aggregation buffer
+     */
+    aggregateEntry(type, level, message, options) {
+        const key = `${type}:${message}`;
+        const now = Date.now();
+        if (this.aggregatedEntries.has(key)) {
+            const entry = this.aggregatedEntries.get(key);
+            entry.count++;
+            entry.lastSeen = now;
+        }
+        else {
+            this.aggregatedEntries.set(key, {
+                type,
+                count: 1,
+                firstSeen: now,
+                lastSeen: now,
+                sample: { message, level, options }
+            });
+        }
+        // Force flush if we have too many entries
+        if (this.aggregatedEntries.size >= this.config.maxAggregatedEntries) {
+            this.flushAggregatedEntries();
+        }
+    }
+    /**
+     * Start the aggregation timer
+     */
+    startAggregationTimer() {
+        if (this.aggregationTimer) {
+            clearInterval(this.aggregationTimer);
+        }
+        this.aggregationTimer = setInterval(() => {
+            this.flushAggregatedEntries();
+        }, this.config.aggregationInterval);
+        // Unref the timer so it doesn't keep the process alive
+        if (this.aggregationTimer && typeof this.aggregationTimer.unref === 'function') {
+            this.aggregationTimer.unref();
+        }
+    }
+    /**
+     * Flush aggregated entries to logs
+     */
+    flushAggregatedEntries() {
+        if (this.aggregatedEntries.size === 0) {
+            return;
+        }
+        const summary = {};
+        let totalAggregated = 0;
+        for (const [key, entry] of this.aggregatedEntries.entries()) {
+            summary[entry.type] = (summary[entry.type] || 0) + entry.count;
+            totalAggregated += entry.count;
+            // Log a sample of high-frequency entries
+            if (entry.count >= 10) {
+                this.log(entry.sample.level, `${entry.sample.message} (aggregated: ${entry.count} occurrences)`, {
+                    ...entry.sample.options,
+                    aggregated: true,
+                    occurrences: entry.count,
+                    timeSpan: entry.lastSeen - entry.firstSeen
+                });
+            }
+        }
+        // Log aggregation summary
+        console.log(`[SMTP] Aggregated ${totalAggregated} log entries: ${JSON.stringify(summary)}`);
+        this.log('info', 'Aggregated log summary', {
+            totalEntries: totalAggregated,
+            breakdown: summary,
+            logMode: this.currentMode,
+            activeConnections: this.connectionTracker.activeConnections
+        });
+        // Clear aggregated entries
+        this.aggregatedEntries.clear();
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        if (this.aggregationTimer) {
+            clearInterval(this.aggregationTimer);
+            this.aggregationTimer = null;
+        }
+        this.flushAggregatedEntries();
+    }
+}
+/**
+ * Default instance for easy access
+ */
+export const adaptiveLogger = AdaptiveSmtpLogger.getInstance();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adaptive-logging.js","sourceRoot":"","sources":["../../../../../../ts/mail/delivery/smtpserver/utils/adaptive-logging.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts/mail/delivery/smtpserver/utils/helpers.d.ts

@@ -0,0 +1,78 @@
+/**
+ * SMTP Helper Functions
+ * Provides utility functions for SMTP server implementation
+ */
+import * as plugins from '../../../../plugins.js';
+import type { ISmtpServerOptions } from '../interfaces.js';
+/**
+ * Formats a multi-line SMTP response according to RFC 5321
+ * @param code - Response code
+ * @param lines - Response lines
+ * @returns Formatted SMTP response
+ */
+export declare function formatMultilineResponse(code: number, lines: string[]): string;
+/**
+ * Generates a unique session ID
+ * @returns Unique session ID
+ */
+export declare function generateSessionId(): string;
+/**
+ * Safely parses an integer from string with a default value
+ * @param value - String value to parse
+ * @param defaultValue - Default value if parsing fails
+ * @returns Parsed integer or default value
+ */
+export declare function safeParseInt(value: string | undefined, defaultValue: number): number;
+/**
+ * Safely gets the socket details
+ * @param socket - Socket to get details from
+ * @returns Socket details object
+ */
+export declare function getSocketDetails(socket: plugins.net.Socket | plugins.tls.TLSSocket): {
+    remoteAddress: string;
+    remotePort: number;
+    remoteFamily: string;
+    localAddress: string;
+    localPort: number;
+    encrypted: boolean;
+};
+/**
+ * Gets TLS details if socket is TLS
+ * @param socket - Socket to get TLS details from
+ * @returns TLS details or undefined if not TLS
+ */
+export declare function getTlsDetails(socket: plugins.net.Socket | plugins.tls.TLSSocket): {
+    protocol?: string;
+    cipher?: string;
+    authorized?: boolean;
+} | undefined;
+/**
+ * Merges default options with provided options
+ * @param options - User provided options
+ * @returns Merged options with defaults
+ */
+export declare function mergeWithDefaults(options: Partial<ISmtpServerOptions>): ISmtpServerOptions;
+/**
+ * Creates a text response formatter for the SMTP server
+ * @param socket - Socket to send responses to
+ * @returns Function to send formatted response
+ */
+export declare function createResponseFormatter(socket: plugins.net.Socket | plugins.tls.TLSSocket): (response: string) => void;
+/**
+ * Extracts SMTP command name from a command line
+ * @param commandLine - Full command line
+ * @returns Command name in uppercase
+ */
+export declare function extractCommandName(commandLine: string): string;
+/**
+ * Extracts SMTP command arguments from a command line
+ * @param commandLine - Full command line
+ * @returns Arguments string
+ */
+export declare function extractCommandArgs(commandLine: string): string;
+/**
+ * Sanitizes data for logging (hides sensitive info)
+ * @param data - Data to sanitize
+ * @returns Sanitized data
+ */
+export declare function sanitizeForLogging(data: any): any;