emailengine-app 2.68.1 → 2.70.0

package/lib/sentry.js

@@ -0,0 +1,139 @@
+'use strict';
+
+const packageData = require('../package.json');
+const logger = require('./logger');
+const { readEnvValue } = require('./tools');
+const { COMMUNITY_SENTRY_DSN } = require('./consts');
+
+const SENTRY_SETTINGS_CHECK_INTERVAL = 60 * 1000;
+
+let Sentry;
+let workerName;
+let activeDsn = false;
+
+function startSentry(dsn) {
+    // require lazily, the SDK loads several hundred modules in every worker thread,
+    // so only pay that cost when error tracking is actually enabled
+    if (!Sentry) {
+        Sentry = require('@sentry/node');
+    }
+
+    Sentry.init({
+        dsn,
+        release: packageData.version,
+        // Error capture only: skip the OpenTelemetry setup and the default
+        // integrations that patch http/fetch/console on hot paths. Sentry's own
+        // uncaughtException/unhandledRejection integrations are left out on
+        // purpose - they do not run in worker threads and do not guarantee a
+        // process exit, so lib/logger.js owns reporting and exiting instead.
+        skipOpenTelemetrySetup: true,
+        defaultIntegrations: false,
+        integrations: [
+            Sentry.eventFiltersIntegration(),
+            Sentry.functionToStringIntegration(),
+            Sentry.linkedErrorsIntegration(),
+            Sentry.contextLinesIntegration(),
+            Sentry.nodeContextIntegration(),
+            Sentry.modulesIntegration()
+        ],
+        initialScope: {
+            tags: { worker: workerName }
+        }
+    });
+
+    logger.notifyError = (err, opts) => {
+        let captureContext = {};
+        if (opts?.user) {
+            captureContext.user = { id: `${opts.user}` };
+        }
+        if (opts?.meta && Object.keys(opts.meta).length) {
+            captureContext.contexts = { ee: opts.meta };
+        }
+        Sentry.captureException(err, captureContext);
+    };
+
+    // the global exception handlers in lib/logger.js wait for this before exiting
+    logger.flushNotifications = () => Sentry.flush(2000);
+}
+
+// Tag all events with the installation identity, so reports from different
+// EmailEngine instances sharing the same DSN can be told apart. Read once per
+// SDK start - a license swapped at runtime is reflected after the next restart.
+async function applyIdentityTags() {
+    const settings = require('./settings');
+    let { serviceId, tract } = await settings.getMulti('serviceId', 'tract');
+    let tags = {};
+    if (serviceId) {
+        tags.instance = serviceId;
+    }
+    if (tract?.key) {
+        tags.license = tract.key;
+    }
+    Sentry.getGlobalScope().setTags(tags);
+}
+
+async function applySentryState(dsn) {
+    dsn = dsn || false;
+    if (dsn === activeDsn) {
+        return;
+    }
+
+    if (activeDsn) {
+        delete logger.notifyError;
+        delete logger.flushNotifications;
+        await Sentry.close(2000);
+        logger.info({ msg: 'Disabled Sentry error reporting', worker: workerName });
+    }
+
+    if (dsn) {
+        startSentry(dsn);
+        logger.info({ msg: 'Enabled Sentry error reporting', worker: workerName });
+
+        // identity lookup failure must not break error reporting, events just lack the tags
+        applyIdentityTags().catch(err => {
+            logger.error({ msg: 'Failed to apply Sentry identity tags', worker: workerName, err });
+        });
+    }
+
+    activeDsn = dsn;
+}
+
+async function checkSentrySettings() {
+    const settings = require('./settings');
+    let { sentryEnabled, sentryDsn } = await settings.getMulti('sentryEnabled', 'sentryDsn');
+    await applySentryState(sentryEnabled ? sentryDsn || COMMUNITY_SENTRY_DSN : false);
+}
+
+// Initialize Sentry error tracking. If the SENTRY_DSN environment variable is set,
+// it pins the configuration and runtime settings are ignored. Otherwise the
+// `sentryEnabled` and `sentryDsn` settings are applied at runtime and re-checked
+// periodically, so error reporting can be toggled from the admin UI without a
+// restart. While disabled, logger.notifyError stays undefined and the global
+// exception handlers in lib/logger.js exit without waiting for a delivery flush.
+function initSentry(worker) {
+    workerName = worker;
+
+    let envDsn = readEnvValue('SENTRY_DSN');
+    if (envDsn) {
+        applySentryState(envDsn).catch(err => {
+            logger.error({ msg: 'Failed to initialize Sentry', worker: workerName, err });
+        });
+        return;
+    }
+
+    // Settings changes are detected by polling instead of the {cmd: 'settings'}
+    // broadcast because that broadcast does not reach all the threads that
+    // initialize Sentry (smtp, imap-proxy, documents, and the main thread).
+    let checkSettings = async () => {
+        try {
+            await checkSentrySettings();
+        } catch (err) {
+            logger.error({ msg: 'Failed to apply Sentry settings', worker: workerName, err });
+        }
+        setTimeout(checkSettings, SENTRY_SETTINGS_CHECK_INTERVAL).unref();
+    };
+
+    setImmediate(checkSettings);
+}
+
+module.exports = { initSentry };

package/lib/settings.js

@@ -13,9 +13,12 @@ config.service = config.service || {};
 const ENCRYPTED_KEYS = [
     'gmailClientSecret',
     'outlookClientSecret',
+    'mailRuClientSecret',
     'cookiePassword',
     'smtpServerPassword',
+    'imapProxyServerPassword',
     'serviceSecret',
+    'serviceKey',
     'gmailServiceKey',
     'gmailServiceExternalAccount',
     'documentStorePassword',
@@ -100,6 +103,9 @@ module.exports = {
     formatSettingValue(key, value) {
         switch (key) {
             case 'serviceUrl': {
+                if (!value) {
+                    return value;
+                }
                 let urlObj = new URL(value);
                 return urlObj.origin;
             }
@@ -155,9 +161,9 @@ module.exports = {
             }
         }
 
-        if (key in ['generateEmailSummary', 'openAiGenerateEmbeddings'] && value) {
-            // make sure `notifyText` is enabled
-            return await redis.hset(`${REDIS_PREFIX}settings`, 'notifyText', 'true');
+        if (['generateEmailSummary', 'openAiGenerateEmbeddings'].includes(key) && formattedValue) {
+            // AI processing needs access to message text content, so make sure `notifyText` is enabled as well
+            await module.exports.set('notifyText', true);
         }
 
         if (/^openAi/.test(key) || key === 'generateEmailSummary') {

package/lib/stream-encrypt.js

@@ -162,7 +162,7 @@ class DecryptStream extends Transform {
             decrypted = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
         } catch (err) {
             if (err.message.includes('auth')) {
-                throw new Error('Decryption failed: invalid secret or corrupted data');
+                throw new Error('Decryption failed: invalid secret or corrupted data', { cause: err });
             }
             throw err;
         }

package/lib/templates.js

@@ -53,7 +53,7 @@ class TemplateHandler {
                 let templateMeta = msgpack.decode(entry);
                 response.templates.push(templateMeta);
             } catch (err) {
-                logger.error({ msg: 'Failed to process template', entry: entry.toString('base64') });
+                logger.error({ msg: 'Failed to process template', entry: entry && entry.toString('base64'), err });
                 continue;
             }
         }

package/lib/tokens.js

@@ -325,16 +325,18 @@ module.exports = {
         let lastEntry = false;
         for (let i = 0; i < detailList.length; i++) {
             let entry = detailList[i];
+            // Each token occupies two consecutive multi results (data + access info)
+            let tokenHash = list[Math.floor(i / 2)];
             if (i % 2 === 0) {
                 lastEntry = false;
                 if (entry[1]) {
                     try {
                         let tokenData = msgpack.decode(entry[1]);
                         tokenData.created = new Date(tokenData.created);
-                        lastEntry = Object.assign({ id: list[response.tokens.length] }, tokenData);
+                        lastEntry = Object.assign({ id: tokenHash }, tokenData);
                         response.tokens.push(lastEntry);
                     } catch (err) {
-                        logger.error({ msg: 'Failed to process token data', hash: list[response.tokens.length], err });
+                        logger.error({ msg: 'Failed to process token data', hash: tokenHash, err });
                     }
                 }
             } else if (lastEntry && entry[1]) {
@@ -343,7 +345,7 @@ module.exports = {
                     accessData.time = accessData.time ? new Date(accessData.time) : null;
                     lastEntry.access = accessData;
                 } catch (err) {
-                    logger.error({ msg: 'Failed to process token data', hash: list[i], err });
+                    logger.error({ msg: 'Failed to process token data', hash: tokenHash, err });
                 }
             }
         }

package/lib/tools.js

@@ -1,7 +1,5 @@
 /* eslint no-bitwise: 0 */
 
-// NB! This file is processed by gettext parser and can not use newer syntax like ?.
-
 'use strict';
 
 const msgpack = require('msgpack5')();
@@ -145,6 +143,14 @@ async function reloadHttpProxyAgent() {
     }
 }
 
+// Reload the shared HTTP proxy agent, but only when proxy-related settings actually changed.
+// Centralizes the 'settings' message handling shared by the main thread and every worker.
+function maybeReloadHttpProxyAgent(data) {
+    if (data && ('httpProxyEnabled' in data || 'httpProxyUrl' in data)) {
+        reloadHttpProxyAgent().catch(err => logger.error({ msg: 'Failed to reload HTTP proxy agent', err }));
+    }
+}
+
 async function _doReloadHttpProxyAgent() {
     let enabled, proxyUrl;
     try {
@@ -1387,6 +1393,9 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV3QUiYsp13nD9suD1/ZkEXnuMoSg
         let redisSoftware;
         let redisCluster = false;
 
+        // Consolidated list of Redis health issues, rendered as dashboard warning banners
+        let redisWarnings = [];
+
         try {
             let redisInfo = await module.exports.getRedisStats(redis);
 
@@ -1434,6 +1443,61 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV3QUiYsp13nD9suD1/ZkEXnuMoSg
                 softwareDetails = `Amazon MemoryDB`;
                 redisSoftware = 'memorydb';
             }
+
+            // Incompatible backend: Amazon ElastiCache
+            if (redisSoftware === 'elasticache') {
+                redisWarnings.push({
+                    key: 'elasticache',
+                    color: 'danger',
+                    title: 'Redis compatibility warning',
+                    details: [
+                        'EmailEngine is incompatible with Amazon ElastiCache as the database backend.',
+                        'Please switch to a standard Redis instance. Using ElastiCache with EmailEngine can result in data loss and some features may not work correctly.'
+                    ]
+                });
+            }
+
+            // Incompatible backend: Redis Cluster
+            if (redisCluster) {
+                redisWarnings.push({
+                    key: 'cluster',
+                    color: 'danger',
+                    title: 'Redis compatibility warning',
+                    details: ['EmailEngine is incompatible with a Redis Cluster setup.', 'Please switch to a standard Redis primary instance.']
+                });
+            }
+
+            // EmailEngine uses Redis as a database, not a cache. Any eviction silently drops sync state,
+            // which makes already-synced messages look new and triggers duplicate webhooks.
+            let maxmemoryPolicy = typeof redisInfo.maxmemory_policy === 'string' ? redisInfo.maxmemory_policy : null;
+            let maxmemory = Number(redisInfo.maxmemory) || 0;
+            let evictedKeys = Number(redisInfo.evicted_keys) || 0;
+
+            if (evictedKeys > 0) {
+                // Definitive: Redis has already evicted keys
+                redisWarnings.push({
+                    key: 'evicted-keys',
+                    color: 'danger',
+                    title: 'Redis eviction detected',
+                    details: [
+                        `Redis has evicted ${evictedKeys.toLocaleString('en-US')} key${evictedKeys === 1 ? '' : 's'} after reaching its memory limit.`,
+                        'EmailEngine uses Redis as its primary database, not a cache. Evicted keys cause already-synced messages to be reprocessed - generating duplicate webhooks - and can lead to data loss.',
+                        'Set the Redis "maxmemory-policy" to "noeviction" and provision enough memory so Redis never reaches its limit.'
+                    ]
+                });
+            } else if (maxmemoryPolicy && maxmemoryPolicy !== 'noeviction') {
+                // Latent risk: an eviction policy is configured but nothing has been evicted yet
+                redisWarnings.push({
+                    key: 'maxmemory-policy',
+                    color: maxmemory > 0 ? 'danger' : 'warning',
+                    title: 'Unsafe Redis eviction policy',
+                    details: [
+                        `The Redis "maxmemory-policy" is set to "${maxmemoryPolicy}", but EmailEngine requires "noeviction".`,
+                        'With any other policy, Redis can delete EmailEngine sync state under memory pressure, causing already-synced messages to be reprocessed - generating duplicate webhooks - and possible data loss.',
+                        'Set "maxmemory-policy noeviction" and make sure Redis has enough memory for your workload.'
+                    ]
+                });
+            }
         } catch (err) {
             logger.error({ msg: 'Failed to get stats', err });
             redisVersion = err.message;
@@ -1451,9 +1515,9 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV3QUiYsp13nD9suD1/ZkEXnuMoSg
                     .hget(`${REDIS_PREFIX}bull:${queue}:meta`, 'paused')
                     .exec();
                 if (resActive[0] || resDelayed[0] || resWaiting[0] || resPaused[0] || resMeta[0]) {
-                    // counting failed
+                    // counting failed, skip this queue but keep the rest of the stats response
                     logger.error({ msg: 'Failed to count queue length', queue, active: resActive, delayed: resDelayed, waiting: resWaiting });
-                    return false;
+                    continue;
                 }
                 queues[queue] = {
                     active: Number(resActive[1]) || 0,
@@ -1477,6 +1541,7 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV3QUiYsp13nD9suD1/ZkEXnuMoSg
                 redis: `${redisVersion}${softwareDetails ? ` (${softwareDetails})` : ''}`,
                 redisSoftware,
                 redisCluster,
+                redisWarnings,
                 imapflow: ImapFlow.version || 'please upgrade',
                 bullmq: bullmqPackage.version,
                 arch: process.arch,
@@ -1963,6 +2028,7 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEV3QUiYsp13nD9suD1/ZkEXnuMoSg
 
     httpAgent,
     reloadHttpProxyAgent,
+    maybeReloadHttpProxyAgent,
     createSocksAgent,
 
     get fetchAgent() {