emailengine-app 2.68.1 → 2.70.0

package/workers/documents.js

@@ -14,28 +14,8 @@ const GB_COLLECT_DELAY = 6 * 3600 * 1000; // 6h
 const GB_FAILURE_DELAY = 3 * 1000;
 const GB_EMPTY_DELAY = 10 * 1000;
 
-const Bugsnag = require('@bugsnag/js');
-if (readEnvValue('BUGSNAG_API_KEY')) {
-    Bugsnag.start({
-        apiKey: readEnvValue('BUGSNAG_API_KEY'),
-        appVersion: packageData.version,
-        logger: {
-            debug(...args) {
-                logger.debug({ msg: args.shift(), worker: 'documents', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            info(...args) {
-                logger.debug({ msg: args.shift(), worker: 'documents', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            warn(...args) {
-                logger.warn({ msg: args.shift(), worker: 'documents', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            error(...args) {
-                logger.error({ msg: args.shift(), worker: 'documents', source: 'bugsnag', args: args.length ? args : undefined });
-            }
-        }
-    });
-    logger.notifyError = Bugsnag.notify.bind(Bugsnag);
-}
+const { initSentry } = require('../lib/sentry');
+initSentry('documents');
 
 const { redis, queueConf } = require('../lib/db');
 const { Worker } = require('bullmq');

package/workers/export.js

@@ -17,33 +17,13 @@ const {
     DEFAULT_EXPORT_MAX_MESSAGES,
     DEFAULT_EXPORT_MAX_SIZE
 } = require('../lib/consts');
-const { getDuration, readEnvValue, threadStats, reloadHttpProxyAgent } = require('../lib/tools');
+const { getDuration, readEnvValue, threadStats, maybeReloadHttpProxyAgent } = require('../lib/tools');
 const { webhooks: Webhooks } = require('../lib/webhooks');
 const settings = require('../lib/settings');
-const { Export } = require('../lib/export');
-
-const Bugsnag = require('@bugsnag/js');
-if (readEnvValue('BUGSNAG_API_KEY')) {
-    Bugsnag.start({
-        apiKey: readEnvValue('BUGSNAG_API_KEY'),
-        appVersion: packageData.version,
-        logger: {
-            debug(...args) {
-                logger.debug({ msg: args.shift(), worker: 'export', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            info(...args) {
-                logger.debug({ msg: args.shift(), worker: 'export', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            warn(...args) {
-                logger.warn({ msg: args.shift(), worker: 'export', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            error(...args) {
-                logger.error({ msg: args.shift(), worker: 'export', source: 'bugsnag', args: args.length ? args : undefined });
-            }
-        }
-    });
-    logger.notifyError = Bugsnag.notify.bind(Bugsnag);
-}
+const { Export, isTransientError, isSkippableError, isFolderMissingError } = require('../lib/export');
+
+const { initSentry } = require('../lib/sentry');
+initSentry('export');
 
 const { redis, queueConf } = require('../lib/db');
 const { Worker } = require('bullmq');
@@ -74,23 +54,6 @@ const IMAP_MESSAGE_RETRY_BASE_DELAY = 2000;
 const ACCOUNT_CHECK_INTERVAL = 60 * 1000;
 const LOCK_EXTENSION_INTERVAL = 5 * 60 * 1000;
 
-function isTransientError(err) {
-    if (['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN', 'ECONNREFUSED', 'EPIPE', 'EHOSTUNREACH'].includes(err.code)) {
-        return true;
-    }
-    if (err.statusCode >= 500 && err.statusCode < 600) {
-        return true;
-    }
-    if (err.code === 'Timeout' || err.message?.includes('timeout')) {
-        return true;
-    }
-    return false;
-}
-
-function isSkippableError(err) {
-    return err.code === 'MessageNotFound' || err.statusCode === 404 || err.message?.includes('Failed to generate message ID');
-}
-
 let callQueue = new Map();
 let mids = 0;
 
@@ -155,6 +118,28 @@ async function notify(account, event, data) {
     await Webhooks.pushToQueue(event, await Webhooks.formatPayload(event, payload));
 }
 
+// Returns a throttled callback that extends both the BullMQ job lock and the export's Redis key
+// expiry on the LOCK_EXTENSION_INTERVAL cadence. Long-running indexing/exporting loops call it
+// freely; the lock/expiry are refreshed at most once per interval. Without this the lock could lapse
+// (stalling and reprocessing the job) and the export keys could expire mid-run.
+function createLeaseExtender(job, account, exportId) {
+    let lastExtension = Date.now();
+    return async function maybeExtendLease() {
+        if (Date.now() - lastExtension <= LOCK_EXTENSION_INTERVAL) {
+            return;
+        }
+        await Promise.all([
+            job.extendLock(job.token, 10 * 60 * 1000).catch(err => {
+                logger.warn({ msg: 'Failed to extend job lock', account, exportId, err });
+            }),
+            Export.extendExpiry(account, exportId).catch(err => {
+                logger.warn({ msg: 'Failed to extend export expiry', account, exportId, err });
+            })
+        ]);
+        lastExtension = Date.now();
+    };
+}
+
 async function indexMessages(job, exportData) {
     const { account, exportId } = job.data;
     const folders = JSON.parse(exportData.folders || '[]');
@@ -195,15 +180,10 @@ async function indexMessages(job, exportData) {
 
     let totalIndexed = 0;
     let truncated = false;
-    let lastLockExtension = Date.now();
+    const maybeExtendLease = createLeaseExtender(job, account, exportId);
 
     for (let i = 0; i < foldersToProcess.length; i++) {
-        if (Date.now() - lastLockExtension > LOCK_EXTENSION_INTERVAL) {
-            await job.extendLock(job.token, 10 * 60 * 1000).catch(err => {
-                logger.warn({ msg: 'Failed to extend job lock during indexing', account, exportId, err });
-            });
-            lastLockExtension = Date.now();
-        }
+        await maybeExtendLease();
 
         if (await Export.isCancelled(account, exportId)) {
             const err = new Error('Export cancelled by user');
@@ -221,8 +201,6 @@ async function indexMessages(job, exportData) {
                 const queued = await indexFolder(accountObject, account, exportId, folderPath, startDate, endDate, indexingStartTime, remaining);
                 totalIndexed += queued;
 
-                await Export.update(account, exportId, { foldersScanned: i + 1 });
-
                 logger.trace({
                     msg: 'Folder indexed',
                     account,
@@ -266,6 +244,9 @@ async function indexMessages(job, exportData) {
             });
         }
 
+        // Count the folder as scanned whether or not it succeeded so progress reaches foldersTotal.
+        await Export.update(account, exportId, { foldersScanned: i + 1 });
+
         if (maxMessages && totalIndexed >= maxMessages) {
             truncated = true;
             logger.warn({
@@ -323,7 +304,18 @@ async function indexFolder(accountObject, account, exportId, folderPath, startDa
             cursor
         };
 
-        const result = await accountObject.listMessages(listOptions);
+        let result;
+        try {
+            result = await accountObject.listMessages(listOptions);
+        } catch (err) {
+            // Other errors (e.g. a deleted account) propagate
+            if (isFolderMissingError(err)) {
+                // The folder disappeared mid-export - treat it as empty instead of failing the export
+                logger.warn({ msg: 'Export folder was not found, skipping', account, exportId, folder: folderPath, err });
+                return queued;
+            }
+            throw err;
+        }
 
         for (const msg of result.messages || []) {
             if (maxMessages && queued >= maxMessages) {
@@ -357,7 +349,9 @@ async function exportMessages(job, exportData) {
     const { filePath } = exportData;
     const includeAttachments = exportData.includeAttachments === '1';
     const textType = exportData.textType || '*';
-    const maxBytes = Number(exportData.maxBytes) || 5 * 1024 * 1024;
+    const rawMaxBytes = Number(exportData.maxBytes);
+    // Preserve an explicit 0 ("unlimited" per the API contract); only fall back when unset/invalid.
+    const maxBytes = Number.isFinite(rawMaxBytes) ? rawMaxBytes : 5 * 1024 * 1024;
     const maxMessageSize = (await settings.get('exportMaxMessageSize')) || DEFAULT_EXPORT_MAX_MESSAGE_SIZE;
     const maxExportSize = Number(await settings.get('exportMaxSize')) || DEFAULT_EXPORT_MAX_SIZE;
     const isEncrypted = exportData.isEncrypted === '1';
@@ -419,14 +413,15 @@ async function exportMessages(job, exportData) {
         });
     }
 
-    let lastScore = Number(exportData.lastProcessedScore) || 0;
     let processed = 0;
     let totalBytesWritten = 0;
     let processingError = null;
     let sizeLimitReached = false;
 
     let lastAccountCheck = Date.now();
-    let lastLockExtension = Date.now();
+    // Refreshes the job lock and export key expiry on a fixed cadence; called from the main loop and
+    // from inside the rate-limit backoff so a batch stuck retrying does not let the lock lapse.
+    const maybeExtendLease = createLeaseExtender(job, account, exportId);
 
     const accountData = await accountObject.loadAccountData(account);
     const isApiAccount = await accountObject.isApiClient(accountData);
@@ -490,12 +485,7 @@ async function exportMessages(job, exportData) {
                 break;
             }
 
-            if (Date.now() - lastLockExtension > LOCK_EXTENSION_INTERVAL) {
-                await job.extendLock(job.token, 10 * 60 * 1000).catch(err => {
-                    logger.warn({ msg: 'Failed to extend job lock', account, exportId, err });
-                });
-                lastLockExtension = Date.now();
-            }
+            await maybeExtendLease();
 
             if (await Export.isCancelled(account, exportId)) {
                 const err = new Error('Export cancelled by user');
@@ -513,7 +503,7 @@ async function exportMessages(job, exportData) {
                 lastAccountCheck = Date.now();
             }
 
-            const batch = await Export.getNextBatch(account, exportId, lastScore, BATCH_SIZE);
+            const batch = await Export.getNextBatch(account, exportId, BATCH_SIZE);
             if (batch.length === 0) {
                 break;
             }
@@ -522,14 +512,12 @@ async function exportMessages(job, exportData) {
             for (const entry of batch) {
                 if (includeAttachments && entry.size > maxMessageSize) {
                     await Export.incrementSkipped(account, exportId);
-                    lastScore = entry.score;
                 } else {
                     entriesToFetch.push(entry);
                 }
             }
 
             if (entriesToFetch.length === 0) {
-                await Export.updateLastProcessedScore(account, exportId, lastScore);
                 continue;
             }
 
@@ -573,7 +561,6 @@ async function exportMessages(job, exportData) {
                                         reason: err.message || err.code
                                     });
                                     await Export.incrementSkipped(account, exportId);
-                                    lastScore = entry.score;
                                 } else if (isRateLimited && rateLimitRetry < MAX_RATE_LIMIT_RETRIES) {
                                     rateLimitedEntries.push(entry);
                                 } else {
@@ -584,7 +571,6 @@ async function exportMessages(job, exportData) {
                                 }
                             } else if (result && result.data) {
                                 await processMessage(result.data, entry);
-                                lastScore = entry.score;
                                 if (maxExportSize && totalBytesWritten >= maxExportSize) {
                                     sizeLimitReached = true;
                                     break;
@@ -599,7 +585,6 @@ async function exportMessages(job, exportData) {
                                     reason: 'Message not found in batch results'
                                 });
                                 await Export.incrementSkipped(account, exportId);
-                                lastScore = entry.score;
                             }
                         }
 
@@ -620,6 +605,7 @@ async function exportMessages(job, exportData) {
                                 delayMs: Math.round(delay)
                             });
                             await new Promise(resolve => setTimeout(resolve, delay));
+                            await maybeExtendLease();
                             fetchBatch = rateLimitedEntries;
                         } else {
                             break;
@@ -672,7 +658,6 @@ async function exportMessages(job, exportData) {
                         await processMessage(message, entry);
                         if (maxExportSize && totalBytesWritten >= maxExportSize) {
                             sizeLimitReached = true;
-                            lastScore = entry.score;
                             break;
                         }
                     } else if (fetchError && isSkippableError(fetchError)) {
@@ -688,12 +673,9 @@ async function exportMessages(job, exportData) {
                     } else if (fetchError) {
                         throw fetchError;
                     }
-
-                    lastScore = entry.score;
                 }
             }
 
-            await Export.updateLastProcessedScore(account, exportId, lastScore);
             logger.trace({ msg: 'Export batch processed', account, exportId, messagesExported: processed });
         }
     } catch (err) {
@@ -764,19 +746,26 @@ const exportWorker = new Worker(
 
             await Export.complete(account, exportId);
 
-            const finalData = await redis.hgetall(`${REDIS_PREFIX}exp:${account}:${exportId}`);
+            // The export is complete and persisted. A failure while reading final stats or delivering
+            // the completion webhook must NOT fall through to the job catch below, which would delete
+            // the finished file and mark the export as failed.
+            try {
+                const finalData = await redis.hgetall(`${REDIS_PREFIX}exp:${account}:${exportId}`);
 
-            await notify(account, EXPORT_COMPLETED_NOTIFY, {
-                exportId,
-                folders: JSON.parse(exportData.folders || '[]'),
-                startDate: new Date(Number(exportData.startDate)).toISOString(),
-                endDate: new Date(Number(exportData.endDate)).toISOString(),
-                messagesExported: Number(finalData.messagesExported) || 0,
-                messagesSkipped: Number(finalData.messagesSkipped) || 0,
-                bytesWritten: Number(finalData.bytesWritten) || 0,
-                duration: Date.now() - startTime,
-                expiresAt: new Date(Number(finalData.expiresAt)).toISOString()
-            });
+                await notify(account, EXPORT_COMPLETED_NOTIFY, {
+                    exportId,
+                    folders: JSON.parse(exportData.folders || '[]'),
+                    startDate: new Date(Number(exportData.startDate)).toISOString(),
+                    endDate: new Date(Number(exportData.endDate)).toISOString(),
+                    messagesExported: Number(finalData.messagesExported) || 0,
+                    messagesSkipped: Number(finalData.messagesSkipped) || 0,
+                    bytesWritten: Number(finalData.bytesWritten) || 0,
+                    duration: Date.now() - startTime,
+                    expiresAt: new Date(Number(finalData.expiresAt)).toISOString()
+                });
+            } catch (notifyErr) {
+                logger.error({ msg: 'Failed to deliver export completion notification', account, exportId, err: notifyErr });
+            }
 
             logger.info({ msg: 'Export job completed', account, exportId, duration: Date.now() - startTime });
         } catch (err) {
@@ -795,14 +784,19 @@ const exportWorker = new Worker(
             }
 
             if (err.code !== 'AccountDeleted' && err.code !== 'AccountNotFound' && err.code !== 'ExportCancelled') {
-                await notify(account, EXPORT_FAILED_NOTIFY, {
-                    exportId,
-                    error: err.message,
-                    errorCode: err.code,
-                    phase: exportData.phase || 'unknown',
-                    messagesExported: Number(exportData.messagesExported) || 0,
-                    messagesQueued: Number(exportData.messagesQueued) || 0
-                });
+                try {
+                    await notify(account, EXPORT_FAILED_NOTIFY, {
+                        exportId,
+                        error: err.message,
+                        errorCode: err.code,
+                        phase: exportData.phase || 'unknown',
+                        messagesExported: Number(exportData.messagesExported) || 0,
+                        messagesQueued: Number(exportData.messagesQueued) || 0
+                    });
+                } catch (notifyErr) {
+                    // Never let a failed notification replace the original error below.
+                    logger.error({ msg: 'Failed to deliver export failure notification', account, exportId, err: notifyErr });
+                }
             }
 
             throw err;
@@ -876,7 +870,7 @@ function onCommand(command) {
             try {
                 const activeExports = await redis.smembers(`${REDIS_PREFIX}exp:active`);
                 for (const entry of activeExports) {
-                    const separatorIndex = entry.indexOf(':exp_');
+                    const separatorIndex = entry.lastIndexOf(':exp_');
                     if (separatorIndex === -1) continue;
                     const entryAccount = entry.substring(0, separatorIndex);
                     const entryExportId = entry.substring(separatorIndex + 1);
@@ -893,6 +887,22 @@ function onCommand(command) {
         5 * 60 * 1000
     ).unref();
 
+    // Periodically remove export files whose Redis state has already expired. Without this, files of
+    // expired exports would only be reclaimed on the next worker restart.
+    setInterval(
+        async () => {
+            try {
+                const cleaned = await Export.cleanup();
+                if (cleaned > 0) {
+                    logger.info({ msg: 'Cleaned up orphaned export files', count: cleaned });
+                }
+            } catch (err) {
+                logger.error({ msg: 'Failed to clean up export files', err });
+            }
+        },
+        60 * 60 * 1000
+    ).unref();
+
     parentPort.postMessage({ cmd: 'ready' });
 })();
 
@@ -919,19 +929,8 @@ parentPort.on('message', message => {
     }
 
     if (message && message.cmd === 'settings') {
-        let d = message.data || {};
-        if ('httpProxyEnabled' in d || 'httpProxyUrl' in d) {
-            reloadHttpProxyAgent().catch(err => logger.error({ msg: 'Failed to reload HTTP proxy agent', err }));
-        }
+        maybeReloadHttpProxyAgent(message.data);
     }
 });
 
 logger.info({ msg: 'Started export worker thread', version: packageData.version });
-
-module.exports = {
-    isTransientError,
-    isSkippableError,
-    IMAP_MESSAGE_MAX_RETRIES,
-    IMAP_MESSAGE_RETRY_BASE_DELAY,
-    ACCOUNT_CHECK_INTERVAL
-};

package/workers/imap-proxy.js

@@ -5,32 +5,12 @@ const { parentPort } = require('worker_threads');
 const packageData = require('../package.json');
 const logger = require('../lib/logger');
 
-const { readEnvValue, threadStats } = require('../lib/tools');
+const { threadStats } = require('../lib/tools');
 
 const { run } = require('../lib/imapproxy/imap-server');
 
-const Bugsnag = require('@bugsnag/js');
-if (readEnvValue('BUGSNAG_API_KEY')) {
-    Bugsnag.start({
-        apiKey: readEnvValue('BUGSNAG_API_KEY'),
-        appVersion: packageData.version,
-        logger: {
-            debug(...args) {
-                logger.debug({ msg: args.shift(), worker: 'imapProxy', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            info(...args) {
-                logger.debug({ msg: args.shift(), worker: 'imapProxy', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            warn(...args) {
-                logger.warn({ msg: args.shift(), worker: 'imapProxy', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            error(...args) {
-                logger.error({ msg: args.shift(), worker: 'imapProxy', source: 'bugsnag', args: args.length ? args : undefined });
-            }
-        }
-    });
-    logger.notifyError = Bugsnag.notify.bind(Bugsnag);
-}
+const { initSentry } = require('../lib/sentry');
+initSentry('imapProxy');
 
 async function onCommand(command) {
     switch (command.cmd) {

package/workers/imap.js

@@ -7,30 +7,10 @@ const logger = require('../lib/logger');
 
 const { REDIS_PREFIX } = require('../lib/consts');
 
-const { getDuration, getBoolean, emitChangeEvent, readEnvValue, hasEnvValue, threadStats, reloadHttpProxyAgent } = require('../lib/tools');
-
-const Bugsnag = require('@bugsnag/js');
-if (readEnvValue('BUGSNAG_API_KEY')) {
-    Bugsnag.start({
-        apiKey: readEnvValue('BUGSNAG_API_KEY'),
-        appVersion: packageData.version,
-        logger: {
-            debug(...args) {
-                logger.debug({ msg: args.shift(), worker: 'imap', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            info(...args) {
-                logger.debug({ msg: args.shift(), worker: 'imap', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            warn(...args) {
-                logger.warn({ msg: args.shift(), worker: 'imap', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            error(...args) {
-                logger.error({ msg: args.shift(), worker: 'imap', source: 'bugsnag', args: args.length ? args : undefined });
-            }
-        }
-    });
-    logger.notifyError = Bugsnag.notify.bind(Bugsnag);
-}
+const { getDuration, getBoolean, emitChangeEvent, readEnvValue, hasEnvValue, threadStats, maybeReloadHttpProxyAgent } = require('../lib/tools');
+
+const { initSentry } = require('../lib/sentry');
+initSentry('imap');
 
 const { IMAPClient } = require('../lib/email-client/imap-client');
 const { GmailClient } = require('../lib/email-client/gmail-client');
@@ -39,7 +19,7 @@ const { BaseClient } = require('../lib/email-client/base-client');
 const { Account } = require('../lib/account');
 const { oauth2Apps, isApiBasedApp } = require('../lib/oauth2-apps');
 const { redis, notifyQueue, submitQueue, documentsQueue, getFlowProducer } = require('../lib/db');
-const { MessagePortWritable } = require('../lib/message-port-stream');
+const { MessagePortWritable, pipeToMessagePort } = require('../lib/message-port-stream');
 const { getESClient } = require('../lib/document-store');
 const settings = require('../lib/settings');
 const msgpack = require('msgpack5')();
@@ -728,8 +708,6 @@ class ConnectionHandler {
         if (!accountData.connection) {
             throw NO_ACTIVE_HANDLER_RESP_ERR;
         }
-        let stream = new MessagePortWritable(message.port);
-
         let source = await accountData.connection.getRawMessage(message.message);
         if (!source) {
             let err = new Error('Requested file not found');
@@ -737,11 +715,22 @@ class ConnectionHandler {
             throw err;
         }
 
+        // Build the cross-thread writable only after we know there is content to send.
+        // Constructing it earlier leaks the transferred MessagePort (and its message
+        // listener) whenever the lookup above throws (e.g. a 404).
+        let stream = new MessagePortWritable(message.port);
+
         setImmediate(() => {
             if (Buffer.isBuffer(source)) {
-                stream.end(source);
+                // The consumer may have aborted and destroyed the writable (via a cancel
+                // message) before this runs; ending a destroyed stream would emit an
+                // unhandled 'error' and take down the worker. The streaming branch is
+                // safe because pipeline() tears down a destroyed destination cleanly.
+                if (!stream.destroyed) {
+                    stream.end(source);
+                }
             } else {
-                source.pipe(stream);
+                pipeToMessagePort(source, stream, accountData.connection.logger);
             }
         });
 
@@ -764,8 +753,6 @@ class ConnectionHandler {
             throw NO_ACTIVE_HANDLER_RESP_ERR;
         }
 
-        let stream = new MessagePortWritable(message.port);
-
         let source = await accountData.connection.getAttachment(message.attachment);
         if (!source) {
             let err = new Error('Requested file not found');
@@ -773,11 +760,22 @@ class ConnectionHandler {
             throw err;
         }
 
+        // Build the cross-thread writable only after we know there is content to send.
+        // Constructing it earlier leaks the transferred MessagePort (and its message
+        // listener) whenever the lookup above throws (e.g. a 404).
+        let stream = new MessagePortWritable(message.port);
+
         setImmediate(() => {
             if (Buffer.isBuffer(source.data)) {
-                stream.end(source.data);
+                // The consumer may have aborted and destroyed the writable (via a cancel
+                // message) before this runs; ending a destroyed stream would emit an
+                // unhandled 'error' and take down the worker. The streaming branch is
+                // safe because pipeline() tears down a destroyed destination cleanly.
+                if (!stream.destroyed) {
+                    stream.end(source.data);
+                }
             } else {
-                source.pipe(stream);
+                pipeToMessagePort(source, stream, accountData.connection.logger);
             }
         });
 
@@ -812,9 +810,7 @@ class ConnectionHandler {
 
         switch (message.cmd) {
             case 'settings':
-                if (message.data && ('httpProxyEnabled' in message.data || 'httpProxyUrl' in message.data)) {
-                    reloadHttpProxyAgent().catch(err => logger.error({ msg: 'Failed to reload HTTP proxy agent', err }));
-                }
+                maybeReloadHttpProxyAgent(message.data);
 
                 if (message.data && message.data.logs) {
                     for (let [account, accountObject] of this.accounts) {

package/workers/smtp.js

@@ -9,28 +9,8 @@ const logger = require('../lib/logger');
 const { getDuration, emitChangeEvent, readEnvValue, threadStats, loadTlsConfig, getByteSize } = require('../lib/tools');
 const { matchIp } = require('../lib/utils/network');
 
-const Bugsnag = require('@bugsnag/js');
-if (readEnvValue('BUGSNAG_API_KEY')) {
-    Bugsnag.start({
-        apiKey: readEnvValue('BUGSNAG_API_KEY'),
-        appVersion: packageData.version,
-        logger: {
-            debug(...args) {
-                logger.debug({ msg: args.shift(), worker: 'smtp', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            info(...args) {
-                logger.debug({ msg: args.shift(), worker: 'smtp', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            warn(...args) {
-                logger.warn({ msg: args.shift(), worker: 'smtp', source: 'bugsnag', args: args.length ? args : undefined });
-            },
-            error(...args) {
-                logger.error({ msg: args.shift(), worker: 'smtp', source: 'bugsnag', args: args.length ? args : undefined });
-            }
-        }
-    });
-    logger.notifyError = Bugsnag.notify.bind(Bugsnag);
-}
+const { initSentry } = require('../lib/sentry');
+initSentry('smtp');
 
 const { SMTPServer } = require('smtp-server');
 const util = require('util');