ghost 6.63.0 → 6.65.0

package/core/server/services/comments/comments-service.js

@@ -13,9 +13,7 @@ const messages = {
   alreadyDisliked: 'This comment was disliked already',
   replyToReply: 'Can not reply to a reply',
   commentsNotEnabled: 'Comments are not enabled for this site.',
-  postIdRequired: 'A post ID is required to read comments.',
   cannotCommentOnPost: 'You do not have permission to comment on this post.',
-  cannotReadComment: 'You do not have permission to read comments on this post',
   cannotEditComment: 'You do not have permission to edit comments',
   cannotPinReply: 'Replies cannot be pinned',
   cannotPinDeletedComment: 'Deleted comments cannot be pinned',
@@ -41,7 +39,8 @@ const COMMENT_STATUSES_IN_REPLY_TO = [COMMENT_STATUS_PUBLISHED, COMMENT_STATUS_H
 // new `comment.get(...)` call has one obvious place to register its column.
 const REPLY_PARENT_REQUIRED_COLUMNS = ['parent_id', 'post_id'];
 const IN_REPLY_TO_REQUIRED_COLUMNS = ['parent_id'];
-const OWNERSHIP_REQUIRED_COLUMNS = ['member_id', 'post_id'];
+const OWNERSHIP_REQUIRED_COLUMNS = ['member_id'];
+const VOTE_REQUIRED_COLUMNS = ['post_id'];
 const REPORT_REQUIRED_COLUMNS = ['post_id', 'member_id', 'html', 'created_at'];
 
 function getColumnList(columns) {
@@ -169,14 +168,11 @@ class CommentsService {
   }
 
   /** @private */
-  checkPostAccess(postModel, memberModel, { action = 'comment' } = {}) {
-    const access = this.contentGating.checkPostAccess(
-      postModel.toJSON(),
-      memberModel ? memberModel.toJSON() : null,
-    );
+  checkPostAccess(postModel, memberModel) {
+    const access = this.contentGating.checkPostAccess(postModel.toJSON(), memberModel.toJSON());
     if (access === this.contentGating.BLOCK_ACCESS) {
       throw new errors.NoPermissionError({
-        message: tpl(action === 'read' ? messages.cannotReadComment : messages.cannotCommentOnPost),
+        message: tpl(messages.cannotCommentOnPost),
       });
     }
   }
@@ -194,32 +190,6 @@ class CommentsService {
     });
   }
 
-  async #checkPostAccessForRead(postId, options) {
-    if (options.isAdmin) {
-      return;
-    }
-
-    if (!postId) {
-      throw new errors.ValidationError({ message: tpl(messages.postIdRequired) });
-    }
-
-    const postModel = await this.models.Post.findOne(
-      { id: postId },
-      { require: true, transacting: options.transacting, withRelated: ['tiers'] },
-    );
-
-    let memberModel = null;
-    const memberId = options.context?.member?.id;
-    if (memberId) {
-      memberModel = await this.models.Member.findOne(
-        { id: memberId },
-        { require: true, transacting: options.transacting, withRelated: ['products'] },
-      );
-    }
-
-    this.checkPostAccess(postModel, memberModel, { action: 'read' });
-  }
-
   /**
    * Primary comment lookup: a single keyed fetch with the allowed statuses
    * applied in the query (`WHERE id = ? AND status IN (...)`), optionally locked
@@ -385,9 +355,27 @@ class CommentsService {
     this.checkCommentAccess(memberModel);
 
     return await this.#withTransaction(options, async (transactionOptions) => {
-      await this.#getPublishedCommentForAction(commentId, transactionOptions, [], {
-        forUpdate: true,
-      });
+      const comment = await this.#getPublishedCommentForAction(
+        commentId,
+        transactionOptions,
+        VOTE_REQUIRED_COLUMNS,
+        {
+          forUpdate: true,
+        },
+      );
+
+      const postModel = await this.models.Post.findOne(
+        {
+          id: comment.get('post_id'),
+        },
+        {
+          require: true,
+          ...transactionOptions,
+          withRelated: ['tiers'],
+        },
+      );
+
+      this.checkPostAccess(postModel, memberModel);
 
       const votes = await this.#getMemberCommentVotes(
         {
@@ -551,7 +539,6 @@ class CommentsService {
    */
   async getComments(options) {
     this.checkEnabled();
-    await this.#checkPostAccessForRead(options.post_id, options);
     const page = await this.models.Comment.findPage(
       withPinnedSelect({ ...options, parentId: null, pinnedFirst: true }),
     );
@@ -691,17 +678,6 @@ class CommentsService {
    */
   async getReplies(id, options, { includeHidden = false } = {}) {
     this.checkEnabled();
-
-    const parentComment = await this.#fetchCommentByID(id, options, {
-      requiredColumns: ['post_id'],
-    });
-
-    if (!parentComment) {
-      throw new errors.NotFoundError({ message: tpl(messages.commentNotFound) });
-    }
-
-    await this.#checkPostAccessForRead(parentComment.get('post_id'), options);
-
     const page = await this.models.Comment.findPage(
       withPinnedSelect({ ...options, parentId: id }, { includeHidden }),
     );
@@ -783,9 +759,7 @@ class CommentsService {
   async getCommentByID(id, options = {}) {
     this.checkEnabled();
 
-    const model = await this.#getReadableCommentByID(id, options, ['post_id']);
-    await this.#checkPostAccessForRead(model.get('post_id'), options);
-    return model;
+    return await this.#getReadableCommentByID(id, options);
   }
 
   /**
@@ -953,9 +927,6 @@ class CommentsService {
       });
     }
 
-    // Mutation responses include replies, so they require the same post access as reads.
-    await this.#checkPostAccessForRead(existingComment.get('post_id'), options);
-
     const model = await this.models.Comment.edit(
       {
         status: COMMENT_STATUS_DELETED,
@@ -991,8 +962,6 @@ class CommentsService {
       });
     }
 
-    await this.#checkPostAccessForRead(existingComment.get('post_id'), options);
-
     if (!comment) {
       return existingComment;
     }

package/core/server/services/comments/comments-stats-service.js

@@ -37,7 +37,7 @@ module.exports = class CommentsStatsService {
       .groupBy('post_id');
 
     /** @type Object<string, number> */
-    let counts = {};
+    const counts = {};
 
     for (const row of results) {
       counts[row.post_id] = row.count;

package/core/server/services/content-import/import/media.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostMediaInliner = exports.MediaInliningFailure = void 0;
 exports.isBlockedMediaUrl = isBlockedMediaUrl;
-const cheerio = require('cheerio');
+const cheerio = require('cheerio/slim');
 class MediaInliningFailure extends Error {
     failures;
     constructor(failures) {

package/core/server/services/content-import/import/staged-file.js

@@ -5,25 +5,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createImportFileStager = createImportFileStager;
 const node_crypto_1 = __importDefault(require("node:crypto"));
-const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-function createImportFileStager() {
+// Stages uploads at the root of the imports storage adapter. The job reads the staged
+// file from its path, so the adapter is the local store storage:imports defaults to.
+function createImportFileStager(getStorage) {
     return {
         async stage({ filePath, fileName }) {
-            const stagedPath = node_path_1.default.join(node_os_1.default.tmpdir(), `content-csv-import-${node_crypto_1.default.randomUUID()}`);
+            const storage = getStorage();
+            const name = `content-csv-import-${node_crypto_1.default.randomUUID()}`;
             try {
-                await fs_extra_1.default.copyFile(filePath, stagedPath, fs_extra_1.default.constants.COPYFILE_EXCL);
-                await fs_extra_1.default.chmod(stagedPath, 0o600);
+                const url = await storage.save({ name, path: filePath }, storage.storagePath);
+                return { path: node_path_1.default.join(storage.storagePath, storage.urlToPath(url)), name: fileName };
             }
             catch (error) {
-                await fs_extra_1.default.remove(stagedPath).catch(() => { });
+                await storage.delete(name).catch(() => { });
                 throw error;
             }
-            return { path: stagedPath, name: fileName };
         },
         async remove(file) {
-            await fs_extra_1.default.remove(file.path);
+            await getStorage().delete(node_path_1.default.basename(file.path));
         },
     };
 }

package/core/server/services/content-import/index.js

@@ -78,7 +78,7 @@ function makeImporter() {
         }),
         email,
         dispatchJob: (job) => (0, jobs_service_1.getInstance)().dispatch(job),
-        fileStager: (0, staged_file_1.createImportFileStager)(),
+        fileStager: (0, staged_file_1.createImportFileStager)(() => require('../adapter-manager').default.getAdapter('storage:imports')),
         report,
         store: new store_1.ImportRunStore(),
         urlForPost: (post) => (0, post_link_1.urlForImportedPost)(post, {

package/core/server/services/custom-redirects/validation.js

@@ -16,7 +16,7 @@ const messages = {
  * @param {import('@tryghost/adapter-base-redirects').RedirectConfig[]} redirects
  */
 const validate = (redirects) => {
-  if (!_.isArray(redirects)) {
+  if (!Array.isArray(redirects)) {
     throw new errors.ValidationError({
       message: tpl(messages.redirectsWrongFormat),
       help: tpl(messages.redirectsHelp),

package/core/server/services/email-analytics/email-analytics-service-wrapper.js

@@ -4,12 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmailAnalyticsServiceWrapper = void 0;
-const errors_1 = __importDefault(require("@tryghost/errors"));
 const logging_1 = __importDefault(require("@tryghost/logging"));
 const email_analytics_service_1 = require("./email-analytics-service");
 const fetch_mailgun_events_1 = require("./fetch-mailgun-events");
 class EmailAnalyticsServiceWrapper {
     #logName;
+    #jobType;
+    #completionEvent;
     #config;
     #metrics;
     #service;
@@ -19,25 +20,10 @@ class EmailAnalyticsServiceWrapper {
     get #logPrefix() {
         return `[EmailAnalytics:${this.#logName}]`;
     }
-    get #backgroundJobName() {
-        switch (this.#logName) {
-            case 'newsletters':
-                return 'email-analytics-fetch-latest';
-            case 'automations':
-                return 'email-analytics-automation-fetch-latest';
-            case 'gifts':
-                return 'email-analytics-gift-fetch-latest';
-            default:
-                return `email-analytics-${this.#logName}-fetch-latest`;
-        }
-    }
-    constructor({ logName }) {
+    constructor({ logName, jobType, config, queries, mailgunTags, jobNames, cursorSeed, createEventProcessor, metrics, settingsCache, }) {
         this.#logName = logName;
-    }
-    init({ config, domainEvents, event, queries, mailgunTags, jobNames, cursorSeed, createEventProcessor, metrics, settingsCache, }) {
-        if (this.#service) {
-            return;
-        }
+        this.#jobType = jobType;
+        this.#completionEvent = `${jobType.replaceAll('-', '_')}.completed`;
         this.#config = config;
         this.#metrics = metrics;
         this.#fetchOpenedEvents = Boolean(cursorSeed.eventColumns.opened);
@@ -51,32 +37,12 @@ class EmailAnalyticsServiceWrapper {
         // Log the processing mode on initialization
         const batchProcessingEnabled = this.#config.get('emailAnalytics:batchProcessing');
         logging_1.default.info(`${this.#logPrefix} Initialized with ${batchProcessingEnabled ? 'BATCHED' : 'SEQUENTIAL'} processing mode`);
-        // We currently cannot trigger a non-offloaded job from the job manager
-        // So the email analytics jobs simply emits an event.
-        domainEvents.subscribe(event, async () => {
-            await this.startFetch();
-        });
     }
     get service() {
-        const result = this.#service;
-        if (!result) {
-            throw new errors_1.default.InternalServerError({
-                message: 'EmailAnalyticsServiceWrapper is not initialized with service',
-            });
-        }
-        return result;
-    }
-    #getConfig() {
-        const result = this.#config;
-        if (!result) {
-            throw new errors_1.default.InternalServerError({
-                message: 'EmailAnalyticsServiceWrapper is not initialized with config',
-            });
-        }
-        return result;
+        return this.#service;
     }
-    _logJobCompletion(jobType, fetchResult, totalDurationMs) {
-        const config = this.#getConfig();
+    _logJobCompletion(jobType, fetchResult, totalDurationMs, lagSeconds = null) {
+        const config = this.#config;
         const { eventCount, apiPollingTimeMs, processingTimeMs, aggregationTimeMs, emailAggregationTimeMs, memberAggregationTimeMs, result, } = fetchResult;
         if (eventCount === 0) {
             return;
@@ -87,8 +53,9 @@ class EmailAnalyticsServiceWrapper {
         const aggregationPercent = totalDurationMs > 0 ? Math.round((aggregationTimeMs / totalDurationMs) * 100) : 0;
         const batchMode = config.get('emailAnalytics:batchProcessing') ? 'BATCHED' : 'SEQUENTIAL';
         const logMessage = [
-            `[Background Job] ${this.#backgroundJobName} processed ${jobType} | ${this.#logPrefix}`,
+            `[Background Job] ${this.#jobType} processed ${jobType} | ${this.#logPrefix}`,
             `${eventCount} events in ${(totalDurationMs / 1000).toFixed(1)}s (${throughput.toFixed(2)} events/s)`,
+            ...(lagSeconds === null ? [] : [`Lag: ${(lagSeconds / 60).toFixed(1)}m`]),
             `Mode: ${batchMode}`,
             `Timings: API ${(apiPollingTimeMs / 1000).toFixed(1)}s (${apiPercent}%) / Processing ${(processingTimeMs / 1000).toFixed(1)}s (${processingPercent}%) / Aggregation ${(aggregationTimeMs / 1000).toFixed(1)}s (${aggregationPercent}%) [Email ${(emailAggregationTimeMs / 1000).toFixed(1)}s / Member ${(memberAggregationTimeMs / 1000).toFixed(1)}s]`,
             `Events: opened=${result.opened} delivered=${result.delivered} failed=${result.permanentFailed + result.temporaryFailed} unprocessable=${result.unprocessable}`,
@@ -96,10 +63,11 @@ class EmailAnalyticsServiceWrapper {
         logging_1.default.info({
             system: {
                 event: 'job.completed',
-                job_type: this.#backgroundJobName,
+                job_type: this.#jobType,
                 task: jobType,
                 event_count: eventCount,
                 duration_ms: totalDurationMs,
+                ...(lagSeconds === null ? {} : { lag_seconds: lagSeconds }),
             },
         }, logMessage);
         // We're only concerned with open throughput as this is displayed to users and is most sensitive to being up to date
@@ -110,13 +78,7 @@ class EmailAnalyticsServiceWrapper {
                 const metricName = this.#logName === 'newsletters'
                     ? 'email-analytics-open-throughput'
                     : `email-${this.#logName}-analytics-open-throughput`;
-                const metrics = this.#metrics;
-                if (!metrics) {
-                    throw new errors_1.default.InternalServerError({
-                        message: 'EmailAnalyticsServiceWrapper is not initialized with metrics',
-                    });
-                }
-                metrics.metric(metricName, {
+                this.#metrics.metric(metricName, {
                     value: throughput,
                     events: eventCount,
                     duration: totalDurationMs,
@@ -124,46 +86,30 @@ class EmailAnalyticsServiceWrapper {
             }
         }
     }
-    async fetchLatestOpenedEvents({ maxEvents = Infinity, } = {}) {
-        const config = this.#getConfig();
-        const beginTimestamp = await this.service.getLastOpenedEventTimestamp();
-        const lagMinutes = (Date.now() - beginTimestamp.getTime()) / 60000;
-        const lagThreshold = config.get('emailAnalytics:openedJobLagWarningMinutes');
-        // NOTE: We only update the begin timestamp when we process events, so there's cases where we can have a false positive
-        //  - Ghost or Mailgun outages
-        //  - Lack of actual email activity
-        if (lagThreshold && lagMinutes > lagThreshold) {
-            logging_1.default.warn(`${this.#logPrefix} Opened events processing is ${lagMinutes.toFixed(1)} minutes behind (threshold: ${lagThreshold})`);
-        }
+    async #fetchAndLog(jobType, fetch, lagPipeline) {
         const fetchStartedAt = Date.now();
-        const fetchResult = await this.service.fetchLatestOpenedEvents({ maxEvents });
+        const fetchResult = await fetch();
         const totalDuration = Date.now() - fetchStartedAt;
-        this._logJobCompletion('latest-opened', fetchResult, totalDuration);
+        // Lag is read after the fetch so a clean run counts as caught up
+        const lagSeconds = lagPipeline ? this.service.getStatus()[lagPipeline].lagSeconds : null;
+        this._logJobCompletion(jobType, fetchResult, totalDuration, lagSeconds);
         return fetchResult.eventCount;
     }
+    async fetchLatestOpenedEvents({ maxEvents = Infinity, } = {}) {
+        return this.#fetchAndLog('latest-opened', () => this.service.fetchLatestOpenedEvents({ maxEvents }), 'latestOpened');
+    }
     async fetchLatestNonOpenedEvents({ maxEvents = Infinity, } = {}) {
-        const fetchStartedAt = Date.now();
-        const fetchResult = await this.service.fetchLatestNonOpenedEvents({ maxEvents });
-        const totalDuration = Date.now() - fetchStartedAt;
-        this._logJobCompletion('latest', fetchResult, totalDuration);
-        return fetchResult.eventCount;
+        return this.#fetchAndLog('latest', () => this.service.fetchLatestNonOpenedEvents({ maxEvents }), 'latest');
     }
     async fetchMissing({ maxEvents = Infinity } = {}) {
-        const fetchStartedAt = Date.now();
-        const fetchResult = await this.service.fetchMissing({ maxEvents });
-        const totalDuration = Date.now() - fetchStartedAt;
-        this._logJobCompletion('missing', fetchResult, totalDuration);
-        return fetchResult.eventCount;
+        // The missing-events sweep trails the delivery pipeline by design, so it has no lag of its own
+        return this.#fetchAndLog('missing', () => this.service.fetchMissing({ maxEvents }));
     }
     async fetchScheduled({ maxEvents }) {
         if (maxEvents < 300) {
             return 0;
         }
-        const fetchStartedAt = Date.now();
-        const fetchResult = await this.service.fetchScheduled({ maxEvents });
-        const totalDuration = Date.now() - fetchStartedAt;
-        this._logJobCompletion('scheduled', fetchResult, totalDuration);
-        return fetchResult.eventCount;
+        return this.#fetchAndLog('scheduled', () => this.service.fetchScheduled({ maxEvents }));
     }
     async startFetch() {
         const startedAt = Date.now();
@@ -173,12 +119,12 @@ class EmailAnalyticsServiceWrapper {
                 await this.service.restoreScheduled();
             }
             catch (e) {
-                logging_1.default.error(e, `[Background Job] ${this.#backgroundJobName} failed while restoring scheduled events after ${Date.now() - startedAt}ms`);
+                logging_1.default.error(e, `[Background Job] ${this.#jobType} failed while restoring scheduled events after ${Date.now() - startedAt}ms`);
                 throw e;
             }
         }
         if (this.#fetching) {
-            logging_1.default.info(`[Background Job] ${this.#backgroundJobName} skipped because a fetch is already running`);
+            logging_1.default.info(`[Background Job] ${this.#jobType} skipped because a fetch is already running`);
             return;
         }
         this.#fetching = true;
@@ -208,11 +154,19 @@ class EmailAnalyticsServiceWrapper {
                 this._restartFetch('scheduled backfill');
                 return;
             }
-            logging_1.default.info(`[Background Job] ${this.#backgroundJobName} completed in ${Date.now() - startedAt}ms with ${c1 + c2 + c3 + c4} events | ${this.#logPrefix}`);
+            // The message is unchanged so existing log queries keep matching; the
+            // structured fields are additive.
+            logging_1.default.info({
+                system: {
+                    event: this.#completionEvent,
+                    event_count: c1 + c2 + c3 + c4,
+                    duration_ms: Date.now() - startedAt,
+                },
+            }, `[Background Job] ${this.#jobType} completed in ${Date.now() - startedAt}ms with ${c1 + c2 + c3 + c4} events | ${this.#logPrefix}`);
             this.#fetching = false;
         }
         catch (e) {
-            logging_1.default.error(e, `[Background Job] ${this.#backgroundJobName} failed after ${Date.now() - startedAt}ms`);
+            logging_1.default.error(e, `[Background Job] ${this.#jobType} failed after ${Date.now() - startedAt}ms`);
             // Log again only the error, otherwise we lose the stack trace
             logging_1.default.error(e);
         }
@@ -220,7 +174,7 @@ class EmailAnalyticsServiceWrapper {
     }
     _restartFetch(reason) {
         this.#fetching = false;
-        logging_1.default.info(`[Background Job] ${this.#backgroundJobName} continuing due to ${reason}`);
+        logging_1.default.info(`[Background Job] ${this.#jobType} continuing due to ${reason}`);
         this.startFetch();
     }
 }

package/core/server/services/email-analytics/email-analytics-service.js

@@ -65,11 +65,18 @@ class EmailAnalyticsService {
         this.queries.setJobMetadata(this.#jobNames.scheduled, null);
     }
     getStatus() {
+        const now = Date.now();
+        const withLag = (data) => Object.assign(data, {
+            fetchedThrough: data.fetchedThrough ?? null,
+            lagSeconds: data.fetchedThrough
+                ? Math.max(0, Math.floor((now - data.fetchedThrough.getTime()) / 1000))
+                : null,
+        });
         return {
-            latest: this.#fetchLatestNonOpenedData,
-            missing: this.#fetchMissingData,
+            latest: withLag(this.#fetchLatestNonOpenedData),
+            missing: withLag(this.#fetchMissingData),
             scheduled: this.#fetchScheduledData,
-            latestOpened: this.#fetchLatestOpenedData,
+            latestOpened: withLag(this.#fetchLatestOpenedData),
         };
     }
     /**
@@ -363,6 +370,7 @@ class EmailAnalyticsService {
                 });
             }
         };
+        let fetchedThrough;
         try {
             const fetchResult = await this.#fetchEvents({
                 batchHandler: processBatch,
@@ -371,6 +379,11 @@ class EmailAnalyticsService {
                 maxEvents,
                 events: eventTypes,
             });
+            // A void result means fetching was skipped (for example, Mailgun is not configured).
+            // Empty successful windows still establish progress through their requested end.
+            if (fetchResult) {
+                fetchedThrough = fetchResult.safeCursor ?? end;
+            }
             if (fetchResult?.safeCursor &&
                 (!fetchData.lastEventTimestamp || fetchResult.safeCursor < fetchData.lastEventTimestamp)) {
                 fetchData.lastEventTimestamp = fetchResult.safeCursor;
@@ -425,6 +438,9 @@ class EmailAnalyticsService {
         if (error) {
             throw error;
         }
+        if (fetchedThrough) {
+            fetchData.fetchedThrough = fetchedThrough;
+        }
         return {
             eventCount,
             apiPollingTimeMs,

package/core/server/services/email-analytics/index.js

@@ -3,7 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = exports.gifts = exports.automations = exports.newsletters = void 0;
+exports.init = void 0;
+exports.getNewsletters = getNewsletters;
+exports.getAutomations = getAutomations;
+exports.getGifts = getGifts;
+const strict_1 = __importDefault(require("node:assert/strict"));
 const email_analytics_service_wrapper_1 = require("./email-analytics-service-wrapper");
 // @ts-expect-error This module lacks type definitions.
 const newsletter_email_analytics_batch_processor_1 = require("./newsletter-email-analytics-batch-processor");
@@ -21,16 +25,25 @@ const automation_email_analytics_batch_processor_1 = require("./automation-email
 const gift_email_analytics_batch_processor_1 = require("./gift-email-analytics-batch-processor");
 const start_gift_email_analytics_job_event_1 = require("./events/start-gift-email-analytics-job-event");
 const constants_2 = require("../gifts/constants");
-exports.newsletters = new email_analytics_service_wrapper_1.EmailAnalyticsServiceWrapper({
-    logName: 'newsletters',
-});
-exports.automations = new email_analytics_service_wrapper_1.EmailAnalyticsServiceWrapper({
-    logName: 'automations',
-});
-exports.gifts = new email_analytics_service_wrapper_1.EmailAnalyticsServiceWrapper({
-    logName: 'gifts',
-});
+let newsletters;
+let automations;
+let gifts;
+function getNewsletters() {
+    (0, strict_1.default)(newsletters, 'Newsletter email analytics should be initialized');
+    return newsletters;
+}
+function getAutomations() {
+    (0, strict_1.default)(automations, 'Automation email analytics should be initialized');
+    return automations;
+}
+function getGifts() {
+    (0, strict_1.default)(gifts, 'Gift email analytics should be initialized');
+    return gifts;
+}
 const init = ({ automationsApi, config, db, domainEvents, emailSuppressionList, giftDeliveryService, membersRepository, models: { Email, EmailRecipientFailure, EmailSpamComplaintEvent }, metrics, prometheusClient, settingsCache, }) => {
+    if (newsletters) {
+        return;
+    }
     const queries = new queries_1.Queries(db.knex);
     const newsletterEmailEventProcessor = new email_event_processor_1.default({
         domainEvents,
@@ -50,17 +63,22 @@ const init = ({ automationsApi, config, db, domainEvents, emailSuppressionList,
         prometheusClient,
     });
     const newsletterMailgunTags = ['bulk-email'];
-    if (config.get('bulkEmail:mailgun:tag')) {
-        newsletterMailgunTags.push(config.get('bulkEmail:mailgun:tag'));
+    const automationMailgunTags = [constants_1.AUTOMATION_EMAIL_TAG];
+    const giftMailgunTags = [constants_2.GIFT_DELIVERY_EMAIL_TAG];
+    const mailgunTagFromConfig = config.get('bulkEmail:mailgun:tag');
+    if (mailgunTagFromConfig) {
+        newsletterMailgunTags.push(mailgunTagFromConfig);
+        automationMailgunTags.push(mailgunTagFromConfig);
+        giftMailgunTags.push(mailgunTagFromConfig);
     }
     prometheusClient?.registerCounter({
         name: newsletter_email_analytics_batch_processor_1.AGGREGATE_MEMBER_STATS_METRIC_NAME,
         help: 'Count of member stats aggregations',
     });
-    exports.newsletters.init({
+    newsletters = new email_analytics_service_wrapper_1.EmailAnalyticsServiceWrapper({
+        logName: 'newsletters',
+        jobType: 'email-analytics-fetch-latest',
         config,
-        domainEvents,
-        event: start_email_analytics_job_event_1.StartEmailAnalyticsJobEvent,
         queries,
         mailgunTags: newsletterMailgunTags,
         jobNames: {
@@ -86,12 +104,12 @@ const init = ({ automationsApi, config, db, domainEvents, emailSuppressionList,
             queries,
         }),
     });
-    exports.automations.init({
+    automations = new email_analytics_service_wrapper_1.EmailAnalyticsServiceWrapper({
+        logName: 'automations',
+        jobType: 'email-analytics-automation-fetch-latest',
         config,
-        domainEvents,
-        event: start_automation_email_analytics_job_event_1.StartAutomationEmailAnalyticsJobEvent,
         queries,
-        mailgunTags: [constants_1.AUTOMATION_EMAIL_TAG],
+        mailgunTags: automationMailgunTags,
         jobNames: {
             latestNonOpened: 'email-analytics-automation-latest-others',
             missing: 'email-analytics-automation-missing',
@@ -111,12 +129,12 @@ const init = ({ automationsApi, config, db, domainEvents, emailSuppressionList,
             automationsApi,
         }),
     });
-    exports.gifts.init({
+    gifts = new email_analytics_service_wrapper_1.EmailAnalyticsServiceWrapper({
+        logName: 'gifts',
+        jobType: 'email-analytics-gift-fetch-latest',
         config,
-        domainEvents,
-        event: start_gift_email_analytics_job_event_1.StartGiftEmailAnalyticsJobEvent,
         queries,
-        mailgunTags: [constants_2.GIFT_DELIVERY_EMAIL_TAG],
+        mailgunTags: giftMailgunTags,
         jobNames: {
             latestNonOpened: 'email-analytics-gifts-latest-others',
             missing: 'email-analytics-gifts-missing',
@@ -134,5 +152,8 @@ const init = ({ automationsApi, config, db, domainEvents, emailSuppressionList,
         settingsCache,
         createEventProcessor: () => new gift_email_analytics_batch_processor_1.GiftEmailAnalyticsBatchProcessor({ giftDeliveryService }),
     });
+    domainEvents.subscribe(start_email_analytics_job_event_1.StartEmailAnalyticsJobEvent, () => newsletters.startFetch());
+    domainEvents.subscribe(start_automation_email_analytics_job_event_1.StartAutomationEmailAnalyticsJobEvent, () => automations.startFetch());
+    domainEvents.subscribe(start_gift_email_analytics_job_event_1.StartGiftEmailAnalyticsJobEvent, () => gifts.startFetch());
 };
 exports.init = init;