@nest-omni/core 4.1.3-3 → 4.1.3-31

package/email-log/services/email-log-logger.service.js

@@ -0,0 +1,168 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailLogLogger = void 0;
+exports.createEmailLogger = createEmailLogger;
+const common_1 = require("@nestjs/common");
+const log_level_helper_1 = require("../utils/log-level.helper");
+/**
+ * Enhanced Logger service with email alert support
+ * This service wraps the standard NestJS Logger and adds email alert functionality
+ * for error and fatal level logs.
+ *
+ * @example
+ * ```typescript
+ * import { EmailLogLogger } from '@nest-omni/core';
+ *
+ * @Injectable()
+ * export class MyService {
+ *   private readonly logger = new EmailLogLogger(MyService.name);
+ *
+ *   handleError() {
+ *     this.logger.error('Something went wrong!', error.stack);
+ *     // This will both log to console and send an email alert
+ *   }
+ * }
+ * ```
+ */
+let EmailLogLogger = class EmailLogLogger extends common_1.Logger {
+    constructor(context, emailTransportService) {
+        super(context);
+        this.emailTransportService = emailTransportService;
+        this.minLevel = 50; // Default to error level
+    }
+    /**
+     * Initialize with email transport from DI
+     */
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // This will be called if the service is injected with dependencies
+            if (this.emailTransportService) {
+                this.emailTransport = this.emailTransportService;
+            }
+        });
+    }
+    /**
+     * Set email transport manually (alternative to DI)
+     */
+    setEmailTransport(transport, options) {
+        this.emailTransport = transport;
+        this.emailOptions = options;
+        this.minLevel = (0, log_level_helper_1.getLevelValue)(options.level);
+    }
+    /**
+     * Log message
+     */
+    log(message, context) {
+        super.log(message, context);
+        this.sendEmailIfNeeded('log', message, context);
+    }
+    /**
+     * Log error message
+     */
+    error(message, stack, context) {
+        super.error(message, stack, context);
+        this.sendEmailIfNeeded('error', message, context, stack);
+    }
+    /**
+     * Log warn message
+     */
+    warn(message, context) {
+        super.warn(message, context);
+        this.sendEmailIfNeeded('warn', message, context);
+    }
+    /**
+     * Log debug message
+     */
+    debug(message, context) {
+        super.debug(message, context);
+        // Don't send email for debug level
+    }
+    /**
+     * Log verbose message
+     */
+    verbose(message, context) {
+        super.verbose(message, context);
+        // Don't send email for verbose level
+    }
+    /**
+     * Log fatal error message
+     */
+    fatal(message, stack, context) {
+        super.error(message, stack, context);
+        this.sendEmailIfNeeded('fatal', message, context, stack);
+    }
+    /**
+     * Send email alert if needed based on log level
+     */
+    sendEmailIfNeeded(level, message, context, stack) {
+        if (!this.emailTransport || !this.shouldSendEmail(level)) {
+            return;
+        }
+        try {
+            this.emailTransport.write({
+                level,
+                message: typeof message === 'string' ? message : String(message),
+                context,
+                stack,
+                timestamp: Date.now(),
+            });
+        }
+        catch (err) {
+            // Don't let email errors break the application
+            console.error('Failed to send log email:', err);
+        }
+    }
+    /**
+     * Check if email should be sent for the given log level
+     */
+    shouldSendEmail(level) {
+        if (!this.emailTransport || !this.emailOptions) {
+            return false;
+        }
+        return (0, log_level_helper_1.getLevelValue)(level) >= this.minLevel;
+    }
+};
+exports.EmailLogLogger = EmailLogLogger;
+exports.EmailLogLogger = EmailLogLogger = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [String, Function])
+], EmailLogLogger);
+/**
+ * Factory function to create an EmailLogLogger with email transport
+ * Use this in your services to get a logger with email alert support
+ *
+ * @example
+ * ```typescript
+ * import { createEmailLogger } from '@nest-omni/core';
+ *
+ * @Injectable()
+ * export class MyService {
+ *   private readonly logger = createEmailLogger(MyService.name);
+ * }
+ * ```
+ */
+function createEmailLogger(context, emailTransport, options) {
+    const logger = new EmailLogLogger(context, emailTransport);
+    if (emailTransport && options) {
+        logger.setEmailTransport(emailTransport, options);
+    }
+    return logger;
+}

package/email-log/services/email-log-rate-limiter.service.d.ts

@@ -0,0 +1,42 @@
+import { OnModuleDestroy } from '@nestjs/common';
+/**
+ * Token bucket rate limiter for email logs
+ * Prevents email spam during error storms
+ *
+ * Similar pattern to CacheModule's LRUCacheProvider
+ */
+export declare class EmailLogRateLimiterService implements OnModuleDestroy {
+    private readonly maxEmails;
+    private readonly windowMs;
+    private readonly burstSize;
+    private readonly logger;
+    private tokenBucket;
+    private refillTimer;
+    constructor(maxEmails: number, windowMs: number, burstSize: number);
+    /**
+     * Check if email should be sent based on rate limit
+     * @param key - Rate limit key (e.g., 'error:global' or 'error:appname')
+     * @returns true if allowed, false if rate limited
+     */
+    canSend(key: string): boolean;
+    /**
+     * Get current state for monitoring/debugging
+     */
+    getState(key: string): {
+        tokens: number;
+        lastRefill: number;
+    } | undefined;
+    /**
+     * Reset rate limit for a key (admin function)
+     */
+    reset(key: string): void;
+    /**
+     * Start periodic token refill
+     * Refills all buckets every second to prevent token starvation
+     */
+    private startRefillTimer;
+    /**
+     * Cleanup on module destroy
+     */
+    onModuleDestroy(): void;
+}

package/email-log/services/email-log-rate-limiter.service.js

@@ -0,0 +1,110 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var EmailLogRateLimiterService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailLogRateLimiterService = void 0;
+const common_1 = require("@nestjs/common");
+/**
+ * Token bucket rate limiter for email logs
+ * Prevents email spam during error storms
+ *
+ * Similar pattern to CacheModule's LRUCacheProvider
+ */
+let EmailLogRateLimiterService = EmailLogRateLimiterService_1 = class EmailLogRateLimiterService {
+    constructor(maxEmails, windowMs, burstSize) {
+        this.maxEmails = maxEmails;
+        this.windowMs = windowMs;
+        this.burstSize = burstSize;
+        this.logger = new common_1.Logger(EmailLogRateLimiterService_1.name);
+        this.tokenBucket = new Map();
+        this.refillTimer = null;
+        // Start periodic refill timer (every second)
+        this.startRefillTimer();
+    }
+    /**
+     * Check if email should be sent based on rate limit
+     * @param key - Rate limit key (e.g., 'error:global' or 'error:appname')
+     * @returns true if allowed, false if rate limited
+     */
+    canSend(key) {
+        const now = Date.now();
+        let state = this.tokenBucket.get(key);
+        if (!state) {
+            // First request - initialize with burst capacity
+            state = {
+                tokens: this.burstSize,
+                lastRefill: now,
+            };
+            this.tokenBucket.set(key, state);
+        }
+        // Refill tokens based on time elapsed
+        const elapsed = now - state.lastRefill;
+        const tokensToAdd = (elapsed / this.windowMs) * this.maxEmails;
+        state.tokens = Math.min(this.maxEmails, state.tokens + tokensToAdd);
+        state.lastRefill = now;
+        // Check if we have tokens available
+        if (state.tokens >= 1) {
+            state.tokens -= 1;
+            this.tokenBucket.set(key, state);
+            this.logger.debug(`Rate limit check passed for key: ${key}, remaining tokens: ${state.tokens.toFixed(2)}`);
+            return true;
+        }
+        this.logger.warn(`Rate limit exceeded for key: ${key}, tokens: ${state.tokens.toFixed(2)}`);
+        return false;
+    }
+    /**
+     * Get current state for monitoring/debugging
+     */
+    getState(key) {
+        const state = this.tokenBucket.get(key);
+        return state ? Object.assign({}, state) : undefined;
+    }
+    /**
+     * Reset rate limit for a key (admin function)
+     */
+    reset(key) {
+        this.tokenBucket.delete(key);
+        this.logger.debug(`Rate limit reset for key: ${key}`);
+    }
+    /**
+     * Start periodic token refill
+     * Refills all buckets every second to prevent token starvation
+     */
+    startRefillTimer() {
+        this.refillTimer = setInterval(() => {
+            const now = Date.now();
+            for (const [key, state] of this.tokenBucket.entries()) {
+                const elapsed = now - state.lastRefill;
+                if (elapsed > 0) {
+                    const tokensToAdd = (elapsed / this.windowMs) * this.maxEmails;
+                    state.tokens = Math.min(this.maxEmails, state.tokens + tokensToAdd);
+                    state.lastRefill = now;
+                    this.tokenBucket.set(key, state);
+                }
+            }
+        }, 1000); // Refill every second
+    }
+    /**
+     * Cleanup on module destroy
+     */
+    onModuleDestroy() {
+        if (this.refillTimer) {
+            clearInterval(this.refillTimer);
+            this.refillTimer = null;
+        }
+        this.tokenBucket.clear();
+    }
+};
+exports.EmailLogRateLimiterService = EmailLogRateLimiterService;
+exports.EmailLogRateLimiterService = EmailLogRateLimiterService = EmailLogRateLimiterService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Number, Number, Number])
+], EmailLogRateLimiterService);

package/email-log/services/email-log-transport.service.d.ts

@@ -0,0 +1,80 @@
+import { LogDescriptor } from 'pino';
+import { Writable } from 'stream';
+import { EmailLogRateLimiterService } from './email-log-rate-limiter.service';
+import { EmailLogFormatterService } from './email-log-formatter.service';
+import { EmailLogOptions } from '../interfaces';
+import type { IEmailLogTransport } from '../interfaces';
+/**
+ * Pino email transport service
+ * Implements Writable stream interface for Pino compatibility
+ *
+ * Follows the pattern of RedisLock and Cache decorators:
+ * - Global service holder pattern
+ * - Graceful error handling
+ * - Configurable via environment variables
+ */
+export declare class EmailLogTransportService extends Writable implements IEmailLogTransport, NodeJS.WritableStream {
+    private readonly options;
+    private readonly rateLimiter;
+    private readonly formatter;
+    private readonly logger;
+    private readonly appName;
+    private emailProvider;
+    private isClosing;
+    constructor(options: EmailLogOptions, rateLimiter: EmailLogRateLimiterService, formatter: EmailLogFormatterService);
+    /**
+     * Write method - implements Writable stream interface
+     * Called by Pino for each log entry
+     */
+    _write(data: LogDescriptor, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    /**
+     * Writev method - handles batch writes
+     */
+    _writev(chunks: {
+        chunk: LogDescriptor;
+        encoding: BufferEncoding;
+    }[], callback: (error?: Error | null) => void): void;
+    /**
+     * Final method - cleanup before stream closes
+     */
+    _final(callback: (error?: Error | null) => void): void;
+    /**
+     * Process a single log entry
+     */
+    private processLog;
+    /**
+     * Check if log should trigger email based on configuration
+     */
+    private shouldSendLog;
+    /**
+     * Get rate limit key for this log entry
+     * Uses 'email-log:appName:level' by default
+     */
+    private getRateLimitKey;
+    /**
+     * Get level label from numeric level
+     */
+    private getLevelLabel;
+    /**
+     * Get level value from level name
+     */
+    private getLevelValueFromName;
+    /**
+     * Format and send email
+     */
+    private sendEmail;
+    /**
+     * Check if transport is enabled for given log level
+     * Part of IEmailLogTransport interface
+     */
+    shouldSend(level: string): boolean;
+    /**
+     * Flush any pending writes
+     * Part of IEmailLogTransport interface
+     */
+    flush(): Promise<void>;
+    /**
+     * Cleanup on module destroy
+     */
+    onModuleDestroy(): Promise<void>;
+}

package/email-log/services/email-log-transport.service.js

@@ -0,0 +1,271 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var EmailLogTransportService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailLogTransportService = void 0;
+const common_1 = require("@nestjs/common");
+const pino_1 = require("pino");
+const stream_1 = require("stream");
+const email_log_rate_limiter_service_1 = require("./email-log-rate-limiter.service");
+const email_log_formatter_service_1 = require("./email-log-formatter.service");
+const email_provider_1 = require("../providers/email-provider");
+const email_log_constants_1 = require("../email-log.constants");
+const interfaces_1 = require("../interfaces");
+/**
+ * Pino email transport service
+ * Implements Writable stream interface for Pino compatibility
+ *
+ * Follows the pattern of RedisLock and Cache decorators:
+ * - Global service holder pattern
+ * - Graceful error handling
+ * - Configurable via environment variables
+ */
+let EmailLogTransportService = EmailLogTransportService_1 = class EmailLogTransportService extends stream_1.Writable {
+    constructor(options, rateLimiter, formatter) {
+        super({ objectMode: true }); // Enable object mode for Pino logs
+        this.options = options;
+        this.rateLimiter = rateLimiter;
+        this.formatter = formatter;
+        this.logger = new common_1.Logger(EmailLogTransportService_1.name);
+        this.isClosing = false;
+        this.appName = process.env.NAME || process.env.APP_NAME || 'omni-app';
+        this.emailProvider = new email_provider_1.EmailLogProvider({
+            smtpHost: options.smtpHost,
+            smtpPort: options.smtpPort || 587,
+            smtpUsername: options.smtpUsername,
+            smtpPassword: options.smtpPassword,
+            smtpSecure: options.smtpSecure || false,
+            smtpIgnoreTLSError: options.smtpIgnoreTLSError || false,
+        });
+        this.logger.log(`Email log transport initialized for app: ${this.appName}, level: ${this.options.level}`);
+    }
+    /**
+     * Write method - implements Writable stream interface
+     * Called by Pino for each log entry
+     */
+    _write(data, _encoding, callback) {
+        if (this.isClosing) {
+            callback();
+            return;
+        }
+        this.processLog(data)
+            .then(() => callback())
+            .catch((error) => {
+            this.logger.error(`Error processing log entry: ${error.message}`, error.stack);
+            callback(); // Don't fail the stream, just log the error
+        });
+    }
+    /**
+     * Writev method - handles batch writes
+     */
+    _writev(chunks, callback) {
+        if (this.isClosing) {
+            callback();
+            return;
+        }
+        Promise.all(chunks.map(({ chunk }) => this.processLog(chunk)))
+            .then(() => callback())
+            .catch((error) => {
+            this.logger.error(`Error processing log batch: ${error.message}`, error.stack);
+            callback();
+        });
+    }
+    /**
+     * Final method - cleanup before stream closes
+     */
+    _final(callback) {
+        this.isClosing = true;
+        this.emailProvider
+            .close()
+            .then(() => callback())
+            .catch((error) => {
+            this.logger.error(`Error closing email provider: ${error.message}`);
+            callback();
+        });
+    }
+    /**
+     * Process a single log entry
+     */
+    processLog(log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Check if transport is enabled for this log level
+                if (!this.shouldSendLog(log)) {
+                    return;
+                }
+                // Check rate limiting
+                const rateLimitKey = this.getRateLimitKey(log);
+                if (!this.rateLimiter.canSend(rateLimitKey)) {
+                    this.logger.debug(`Rate limited email for log: ${log.msg}`);
+                    return;
+                }
+                // Format and send email
+                yield this.sendEmail(log);
+            }
+            catch (error) {
+                this.logger.error(`Failed to send log email: ${error.message}`, error.stack);
+                // Don't throw - we don't want to break logging
+            }
+        });
+    }
+    /**
+     * Check if log should trigger email based on configuration
+     */
+    shouldSendLog(log) {
+        var _a;
+        const { level } = log;
+        const levelValue = typeof level === 'string'
+            ? ((_a = pino_1.levels[level]) !== null && _a !== void 0 ? _a : 0)
+            : level;
+        const thresholdValue = this.getLevelValueFromName(this.options.level);
+        // Check log level threshold
+        if (levelValue < thresholdValue) {
+            return false;
+        }
+        // Check app filters
+        if (this.options.includeApps && this.options.includeApps.length > 0) {
+            if (!this.options.includeApps.includes(this.appName)) {
+                return false;
+            }
+        }
+        if (this.options.excludeApps && this.options.excludeApps.includes(this.appName)) {
+            return false;
+        }
+        // Check error type filters
+        if (log.err) {
+            const errorType = log.err.type || log.err.name;
+            if (this.options.includeErrors &&
+                this.options.includeErrors.length > 0) {
+                if (!this.options.includeErrors.includes(errorType)) {
+                    return false;
+                }
+            }
+            if (this.options.excludeErrors &&
+                this.options.excludeErrors.includes(errorType)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Get rate limit key for this log entry
+     * Uses 'email-log:appName:level' by default
+     */
+    getRateLimitKey(log) {
+        const levelLabel = typeof log.level === 'string' ? log.level : this.getLevelLabel(log.level);
+        return `email-log:${this.appName}:${levelLabel}`;
+    }
+    /**
+     * Get level label from numeric level
+     */
+    getLevelLabel(level) {
+        const labels = {
+            10: 'trace',
+            20: 'debug',
+            30: 'info',
+            40: 'warn',
+            50: 'error',
+            60: 'fatal',
+        };
+        return labels[level] || 'unknown';
+    }
+    /**
+     * Get level value from level name
+     */
+    getLevelValueFromName(levelName) {
+        var _a;
+        const nameToValue = {
+            trace: 10,
+            debug: 20,
+            info: 30,
+            warn: 40,
+            error: 50,
+            fatal: 60,
+        };
+        return (_a = nameToValue[levelName]) !== null && _a !== void 0 ? _a : 50;
+    }
+    /**
+     * Format and send email
+     */
+    sendEmail(log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subjectPrefix = this.options.subjectPrefix || '[Log Alert]';
+            const emailContent = this.options.useHtmlFormat
+                ? this.formatter.formatHtml(log, this.appName, subjectPrefix)
+                : this.formatter.formatText(log, this.appName, subjectPrefix);
+            yield this.emailProvider.sendLogEmail({
+                to: this.options.to,
+                cc: this.options.cc,
+                from: this.options.from,
+                subject: emailContent.subject,
+                html: 'html' in emailContent ? emailContent.html : undefined,
+                text: 'text' in emailContent ? emailContent.text : undefined,
+            });
+            this.logger.debug(`Log email sent for ${this.appName}: ${log.msg}`);
+        });
+    }
+    /**
+     * Check if transport is enabled for given log level
+     * Part of IEmailLogTransport interface
+     */
+    shouldSend(level) {
+        const levelValue = this.getLevelValueFromName(level);
+        const thresholdValue = this.getLevelValueFromName(this.options.level);
+        return levelValue >= thresholdValue;
+    }
+    /**
+     * Flush any pending writes
+     * Part of IEmailLogTransport interface
+     */
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.end((error) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve();
+                });
+            });
+        });
+    }
+    /**
+     * Cleanup on module destroy
+     */
+    onModuleDestroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.isClosing = true;
+            yield this.emailProvider.close();
+        });
+    }
+};
+exports.EmailLogTransportService = EmailLogTransportService;
+exports.EmailLogTransportService = EmailLogTransportService = EmailLogTransportService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(email_log_constants_1.EMAIL_LOG_OPTIONS)),
+    __param(1, (0, common_1.Inject)(email_log_constants_1.EMAIL_LOG_RATE_LIMITER)),
+    __param(2, (0, common_1.Inject)(email_log_constants_1.EMAIL_LOG_FORMATTER)),
+    __metadata("design:paramtypes", [interfaces_1.EmailLogOptions,
+        email_log_rate_limiter_service_1.EmailLogRateLimiterService,
+        email_log_formatter_service_1.EmailLogFormatterService])
+], EmailLogTransportService);

package/email-log/services/index.d.ts

@@ -0,0 +1,5 @@
+export * from './email-log-transport.service';
+export * from './email-log-formatter.service';
+export * from './email-log-rate-limiter.service';
+export * from './email-log-alert.service';
+export * from './email-log-logger.service';