ghost 6.57.1 → 6.58.0

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

@@ -1,63 +1,14 @@
-const {EventProcessingResult} = require('./event-processing-result');
-const logging = require('@tryghost/logging');
-const errors = require('@tryghost/errors');
-/** @import {PrometheusClient} from '@tryghost/prometheus-metrics' */
-/** @import {BatchEventProcessor} from './batch-event-processor' */
-/** @import {Queries} from './lib/queries' */
-
-/**
- * @typedef {object} FetchData
- * @property {boolean} running
- * @property {string} jobName Name of the job that is running
- * @property {Date} [lastStarted] Date the last fetch started on
- * @property {Date} [lastBegin] The begin time used during the last fetch
- * @property {Date} [lastEventTimestamp]
- * @property {boolean} [canceled] Set to quit the job early
- */
-
-/**
- * @typedef {FetchData & {schedule?: {begin: Date, end: Date}}} FetchDataScheduled
- */
-
-/**
- * @typedef {'delivered' | 'opened' | 'failed' | 'unsubscribed' | 'complained'} EmailAnalyticsEvent
- */
-
-/**
- * Names of the jobs this service runs. Each pipeline needs its own set so their
- * cursors don't overwrite each other in the jobs table.
- *
- * @typedef {object} JobNames
- * @property {string} latestNonOpened
- * @property {string} missing
- * @property {string} latestOpened
- * @property {string} scheduled
- */
-
-/**
- * Recipient table and timestamp columns used to seed a job's cursor the first
- * time it runs, before there's any job data to resume from.
- *
- * @typedef {object} CursorSeed
- * @prop {string} tableName
- * @prop {Partial<Record<EmailAnalyticsEvent, string>>} eventColumns
- */
-
-/**
- * @typedef {object} EmailAnalyticsFetchResult
- * @property {number} eventCount - The number of events fetched
- * @property {number} apiPollingTimeMs - Time spent polling the API in milliseconds
- * @property {number} processingTimeMs - Time spent processing events in milliseconds
- * @property {number} aggregationTimeMs - Time spent aggregating stats in milliseconds
- * @property {number} emailAggregationTimeMs - Time spent aggregating email stats in milliseconds
- * @property {number} memberAggregationTimeMs - Time spent aggregating member stats in milliseconds
- * @property {EventProcessingResult} result - The processing result with event breakdown
- */
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailAnalyticsService = void 0;
+const event_processing_result_1 = require("./event-processing-result");
+const logging_1 = __importDefault(require("@tryghost/logging"));
+const errors_1 = __importDefault(require("@tryghost/errors"));
 const TRUST_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutes
 const FETCH_LATEST_END_MARGIN_MS = 1 * 60 * 1000; // Do not fetch events newer than 1 minute (yet). Reduces the chance of having missed events in fetchLatest.
-const AGGREGATE_MEMBER_STATS_METRIC_NAME = 'email_analytics_aggregate_member_stats_count';
-
 /**
  * Helper function to create an empty fetch result
  * @returns {EmailAnalyticsFetchResult}
@@ -70,55 +21,25 @@ function createEmptyResult() {
         aggregationTimeMs: 0,
         emailAggregationTimeMs: 0,
         memberAggregationTimeMs: 0,
-        result: new EventProcessingResult()
+        result: new event_processing_result_1.EventProcessingResult()
     };
 }
-
-module.exports = class EmailAnalyticsService {
-    /** @type {Queries} */ queries;
-    provider;
+class EmailAnalyticsService {
+    queries;
+    #fetchEvents;
     #createEventProcessor;
-
-    /** @type {JobNames} */ #jobNames;
-    /** @type {CursorSeed} */ #cursorSeed;
-
-    /**
-     * @type {FetchData}
-     */
+    #jobNames;
+    #cursorSeed;
     #fetchLatestNonOpenedData;
-
-    /**
-     * @type {FetchData}
-     */
     #fetchMissingData;
-
-    /**
-     * @type {FetchData}
-     */
     #fetchLatestOpenedData;
-
-    /**
-     * @type {FetchDataScheduled}
-     */
     #fetchScheduledData;
-
-    /**
-     * @param {object} dependencies
-     * @param {Queries} dependencies.queries
-     * @param {object} dependencies.provider
-     * @param {PrometheusClient} [dependencies.prometheusClient]
-     * @param {() => BatchEventProcessor} dependencies.createEventProcessor
-     * @param {JobNames} dependencies.jobNames
-     * @param {CursorSeed} dependencies.cursorSeed
-     */
-    constructor({queries, provider, prometheusClient, createEventProcessor, jobNames, cursorSeed}) {
+    constructor({ queries, fetchEvents, createEventProcessor, jobNames, cursorSeed }) {
         this.queries = queries;
-        this.provider = provider;
-        this.prometheusClient = prometheusClient;
+        this.#fetchEvents = fetchEvents;
         this.#createEventProcessor = createEventProcessor;
         this.#jobNames = jobNames;
         this.#cursorSeed = cursorSeed;
-
         this.#fetchLatestNonOpenedData = {
             running: false,
             jobName: jobNames.latestNonOpened
@@ -135,12 +56,7 @@ module.exports = class EmailAnalyticsService {
             running: false,
             jobName: jobNames.scheduled
         };
-
-        if (prometheusClient) {
-            prometheusClient.registerCounter({name: AGGREGATE_MEMBER_STATS_METRIC_NAME, help: 'Count of member stats aggregations'});
-        }
     }
-
     #clearScheduledData() {
         this.#fetchScheduledData = {
             running: false,
@@ -148,7 +64,6 @@ module.exports = class EmailAnalyticsService {
         };
         this.queries.setJobMetadata(this.#jobNames.scheduled, null);
     }
-
     getStatus() {
         return {
             latest: this.#fetchLatestNonOpenedData,
@@ -157,106 +72,77 @@ module.exports = class EmailAnalyticsService {
             latestOpened: this.#fetchLatestOpenedData
         };
     }
-
     /**
      * Returns the timestamp of the last non-opened event we processed. Defaults to now minus 30 minutes if we have no data yet.
      */
     async getLastNonOpenedEventTimestamp() {
         return this.#fetchLatestNonOpenedData?.lastEventTimestamp ?? (await this.queries.getLastEventTimestamp(this.#fetchLatestNonOpenedData.jobName, ['delivered', 'failed'], this.#cursorSeed)) ?? new Date(Date.now() - TRUST_THRESHOLD_MS);
     }
-
     /**
      * Returns the timestamp of the last opened event we processed. Defaults to now minus 30 minutes if we have no data yet.
      */
     async getLastOpenedEventTimestamp() {
         return this.#fetchLatestOpenedData?.lastEventTimestamp ?? (await this.queries.getLastEventTimestamp(this.#fetchLatestOpenedData.jobName, ['opened'], this.#cursorSeed)) ?? new Date(Date.now() - TRUST_THRESHOLD_MS);
     }
-
     /**
      * Returns the timestamp of the last missing event we processed. Defaults to now minus 2h if we have no data yet.
      */
     async getLastMissingEventTimestamp() {
         return this.#fetchMissingData?.lastEventTimestamp ?? (await this.queries.getLastJobRunTimestamp(this.#fetchMissingData.jobName)) ?? new Date(Date.now() - TRUST_THRESHOLD_MS * 4);
     }
-
     /**
      * Fetches the latest opened events.
-     * @param {Object} options - The options for fetching events.
-     * @param {number} [options.maxEvents=Infinity] - The maximum number of events to fetch.
-     * @returns {Promise<EmailAnalyticsFetchResult>} Fetch results with timing metrics
      */
-    async fetchLatestOpenedEvents({maxEvents = Infinity} = {}) {
+    async fetchLatestOpenedEvents({ maxEvents = Infinity } = {}) {
         const begin = await this.getLastOpenedEventTimestamp();
         const end = new Date(Date.now() - FETCH_LATEST_END_MARGIN_MS); // Always stop at x minutes ago to give Mailgun a bit more time to stabilize storage
-
         if (end <= begin) {
             // Skip for now
-            logging.info('[EmailAnalytics] Skipping fetchLatestOpenedEvents because end (' + end + ') is before begin (' + begin + ')');
+            logging_1.default.info('[EmailAnalytics] Skipping fetchLatestOpenedEvents because end (' + end + ') is before begin (' + begin + ')');
             return createEmptyResult();
         }
-
-        return await this.#fetchEvents(this.#fetchLatestOpenedData, {begin, end, maxEvents, eventTypes: ['opened']});
+        return await this.#fetchEventsForJob(this.#fetchLatestOpenedData, { begin, end, maxEvents, eventTypes: ['opened'] });
     }
-
     /**
      * Fetches the latest non-opened events.
-     * @param {Object} options - The options for fetching events.
-     * @param {number} [options.maxEvents=Infinity] - The maximum number of events to fetch.
-     * @returns {Promise<EmailAnalyticsFetchResult>} Fetch results with timing metrics
      */
-    async fetchLatestNonOpenedEvents({maxEvents = Infinity} = {}) {
+    async fetchLatestNonOpenedEvents({ maxEvents = Infinity } = {}) {
         const begin = await this.getLastNonOpenedEventTimestamp();
         const end = new Date(Date.now() - FETCH_LATEST_END_MARGIN_MS); // Always stop at x minutes ago to give Mailgun a bit more time to stabilize storage
-
         if (end <= begin) {
             // Skip for now
-            logging.info('[EmailAnalytics] Skipping fetchLatestNonOpenedEvents because end (' + end + ') is before begin (' + begin + ')');
+            logging_1.default.info('[EmailAnalytics] Skipping fetchLatestNonOpenedEvents because end (' + end + ') is before begin (' + begin + ')');
             return createEmptyResult();
         }
-
-        return await this.#fetchEvents(this.#fetchLatestNonOpenedData, {begin, end, maxEvents, eventTypes: ['delivered', 'failed', 'unsubscribed', 'complained']});
+        return await this.#fetchEventsForJob(this.#fetchLatestNonOpenedData, { begin, end, maxEvents, eventTypes: ['delivered', 'failed', 'unsubscribed', 'complained'] });
     }
-
     /**
      * Fetches events that are older than 30 minutes, because then the 'storage' of the Mailgun API is stable. And we are sure we don't miss any events.
-     * @param {object} options
-     * @param {number} [options.maxEvents] Not a strict maximum. We stop fetching after we reached the maximum AND received at least one event after begin (not equal) to prevent deadlocks.
-     * @returns {Promise<EmailAnalyticsFetchResult>} Fetch results with timing metrics
+     * @param [options.maxEvents] Not a strict maximum. We stop fetching after we reached the maximum AND received at least one event after begin (not equal) to prevent deadlocks.
      */
-    async fetchMissing({maxEvents = Infinity} = {}) {
+    async fetchMissing({ maxEvents = Infinity } = {}) {
         const begin = await this.getLastMissingEventTimestamp();
-
         // Always stop at the earlier of the time the fetchLatest started fetching on or 30 minutes ago
-        const end = new Date(
-            Math.min(
-                Date.now() - TRUST_THRESHOLD_MS,
-                this.#fetchLatestNonOpenedData?.lastBegin?.getTime() || Date.now() // Fallback to now if the previous job didn't run, for whatever reason, prevents catastrophic error
-            )
-        );
-
+        const end = new Date(Math.min(Date.now() - TRUST_THRESHOLD_MS, this.#fetchLatestNonOpenedData?.lastBegin?.getTime() || Date.now() // Fallback to now if the previous job didn't run, for whatever reason, prevents catastrophic error
+        ));
         if (end <= begin) {
             // Skip for now
-            logging.info('[EmailAnalytics] Skipping fetchMissing because end (' + end + ') is before begin (' + begin + ')');
+            logging_1.default.info('[EmailAnalytics] Skipping fetchMissing because end (' + end + ') is before begin (' + begin + ')');
             return createEmptyResult();
         }
-
-        return await this.#fetchEvents(this.#fetchMissingData, {begin, end, maxEvents});
+        return await this.#fetchEventsForJob(this.#fetchMissingData, { begin, end, maxEvents });
     }
-
     /**
      * Schedule a new fetch for email analytics events.
-     * @param {Object} options - The options for scheduling the fetch.
-     * @param {Date} options.begin - The start date for the scheduled fetch.
-     * @param {Date} options.end - The end date for the scheduled fetch.
      * @throws {errors.ValidationError} Throws an error if a fetch is already in progress.
      */
-    async schedule({begin, end}) {
+    async schedule({ begin, end }) {
         if (this.#fetchScheduledData && this.#fetchScheduledData.running) {
-            throw new errors.ValidationError({
+            throw new errors_1.default.ValidationError({
                 message: 'Already fetching scheduled events. Wait for it to finish before scheduling a new one.'
             });
         }
-        logging.info('[EmailAnalytics] Scheduling fetch from ' + begin.toISOString() + ' until ' + end.toISOString());
+        logging_1.default.info('[EmailAnalytics] Scheduling fetch from ' + begin.toISOString() + ' until ' + end.toISOString());
         this.#fetchScheduledData = {
             running: false,
             jobName: this.#jobNames.scheduled,
@@ -270,12 +156,10 @@ module.exports = class EmailAnalyticsService {
             end: end.toISOString()
         });
     }
-
     /**
      * Cancels the scheduled fetch of email analytics events.
      * If a fetch is currently running, it marks it for cancellation.
      * If no fetch is running, it clears the scheduled fetch data.
-     * @method cancelScheduled
      */
     cancelScheduled() {
         if (this.#fetchScheduledData) {
@@ -283,12 +167,12 @@ module.exports = class EmailAnalyticsService {
                 this.#fetchScheduledData.canceled = true;
                 // Clear metadata eagerly; fetchScheduled() will clear in-memory state next cycle
                 this.queries.setJobMetadata(this.#jobNames.scheduled, null);
-            } else {
+            }
+            else {
                 this.#clearScheduledData();
             }
         }
     }
-
     /**
      * Restores a previously persisted scheduled fetch from the database.
      * Must only be called once on startup (caller guards against repeated calls).
@@ -296,119 +180,91 @@ module.exports = class EmailAnalyticsService {
     async restoreScheduled() {
         try {
             const jobData = await this.queries.getJobData(this.#jobNames.scheduled);
-            if (!jobData || !jobData.metadata) {
+            if (!jobData) {
                 return;
             }
-
-            const metadata = JSON.parse(jobData.metadata);
+            const { metadata } = jobData;
             if (metadata.begin && metadata.end) {
                 const begin = new Date(metadata.begin);
                 const end = new Date(metadata.end);
-
                 this.#fetchScheduledData = {
                     running: false,
                     jobName: this.#jobNames.scheduled,
-                    schedule: {begin, end}
+                    schedule: { begin, end }
                 };
-
                 // Use finished_at as the resume cursor if available
                 if (jobData.finished_at) {
                     this.#fetchScheduledData.lastEventTimestamp = new Date(jobData.finished_at);
                 }
-
-                logging.info('[EmailAnalytics] Restored scheduled fetch: ' + begin.toISOString() + ' to ' + end.toISOString());
+                logging_1.default.info('[EmailAnalytics] Restored scheduled fetch: ' + begin.toISOString() + ' to ' + end.toISOString());
             }
-        } catch (e) {
-            logging.error('[EmailAnalytics] Failed to restore scheduled fetch', e);
+        }
+        catch (e) {
+            logging_1.default.error('[EmailAnalytics] Failed to restore scheduled fetch', e);
         }
     }
-
     /**
      * Continues fetching the scheduled events (does not start one). Resets the scheduled event when received 0 events.
-     * @method fetchScheduled
-     * @param {Object} [options] - The options for fetching scheduled events.
-     * @param {number} [options.maxEvents=Infinity] - The maximum number of events to fetch.
-     * @returns {Promise<EmailAnalyticsFetchResult>} Fetch results with timing metrics
      */
-    async fetchScheduled({maxEvents = Infinity} = {}) {
+    async fetchScheduled({ maxEvents = Infinity } = {}) {
         if (!this.#fetchScheduledData || !this.#fetchScheduledData.schedule) {
             // Nothing scheduled
             return createEmptyResult();
         }
-
         if (this.#fetchScheduledData.canceled) {
             this.#clearScheduledData();
             return createEmptyResult();
         }
-
         let begin = this.#fetchScheduledData.schedule.begin;
         const end = this.#fetchScheduledData.schedule.end;
-
         if (this.#fetchScheduledData.lastEventTimestamp && this.#fetchScheduledData.lastEventTimestamp > begin) {
             // Continue where we left of
             begin = this.#fetchScheduledData.lastEventTimestamp;
         }
-
         if (end <= begin) {
-            logging.info('[EmailAnalytics] Ending fetchScheduled because end is before begin');
+            logging_1.default.info('[EmailAnalytics] Ending fetchScheduled because end is before begin');
             this.#clearScheduledData();
             return createEmptyResult();
         }
-
-        const fetchResult = await this.#fetchEvents(this.#fetchScheduledData, {begin, end, maxEvents});
+        const fetchResult = await this.#fetchEventsForJob(this.#fetchScheduledData, { begin, end, maxEvents });
         if (fetchResult.eventCount === 0 || this.#fetchScheduledData.canceled) {
             this.#clearScheduledData();
         }
-
         this.queries.setJobTimestamp(this.#fetchScheduledData.jobName, 'finished', this.#fetchScheduledData.lastEventTimestamp);
         return fetchResult;
     }
     /**
      * Start fetching analytics and store the data of the progress inside fetchData
-     * @param {FetchData} fetchData - Object to store the progress of the fetch operation
-     * @param {object} options - Options for fetching events
-     * @param {Date} options.begin - Start date for fetching events
-     * @param {Date} options.end - End date for fetching events
-     * @param {number} [options.maxEvents=Infinity] - Maximum number of events to fetch. Not a strict maximum. We stop fetching after we reached the maximum AND received at least one event after begin (not equal) to prevent deadlocks.
-     * @param {EmailAnalyticsEvent[]} [options.eventTypes] - Array of event types to fetch. If not provided, Mailgun will return all event types.
-     * @returns {Promise<EmailAnalyticsFetchResult>} Fetch results with timing metrics
+     * @param [options.maxEvents=Infinity] - Maximum number of events to fetch. Not a strict maximum. We stop fetching after we reached the maximum AND received at least one event after begin (not equal) to prevent deadlocks.
+     * @param [options.eventTypes] - Array of event types to fetch. If not provided, Mailgun will return all event types.
      */
-    async #fetchEvents(fetchData, {begin, end, maxEvents = Infinity, eventTypes}) {
+    async #fetchEventsForJob(fetchData, { begin, end, maxEvents = Infinity, eventTypes }) {
         // Start where we left of, or the last stored event in the database, or start 30 minutes ago if we have nothing available
         // Store that we started fetching
         fetchData.running = true;
         fetchData.lastStarted = new Date();
         fetchData.lastBegin = begin;
         await this.queries.setJobTimestamp(fetchData.jobName, 'started', begin);
-
         // Timing metrics
         const fetchStartMs = Date.now();
         let processingTimeMs = 0;
         let aggregationTimeMs = 0;
         let emailAggregationTimeMs = 0;
         let memberAggregationTimeMs = 0;
-
         let eventCount = 0;
         const includeOpenedEvents = eventTypes?.includes('opened') ?? false;
-
         const eventProcessor = this.#createEventProcessor();
-
         // We keep the processing result here, so we also have a result in case of failures
-        let processingResult = new EventProcessingResult();
+        const processingResult = new event_processing_result_1.EventProcessingResult();
         // Track cumulative event counts separately since processingResult gets reset during intermediate aggregations
-        const cumulativeResult = new EventProcessingResult();
+        const cumulativeResult = new event_processing_result_1.EventProcessingResult();
         let error = null;
-
-        /**
-         * @param {boolean} isFinal
-         * @returns {Promise<void>}
-         */
         const aggregate = async (isFinal) => {
             if (!eventProcessor.aggregate) {
                 return;
             }
             const start = Date.now();
-            const timings = await eventProcessor.aggregate({includeOpenedEvents, processingResult, isFinal});
+            const timings = await eventProcessor.aggregate({ includeOpenedEvents, processingResult, isFinal });
             if (!timings) {
                 return;
             }
@@ -416,12 +272,6 @@ module.exports = class EmailAnalyticsService {
             emailAggregationTimeMs += timings.emailAggregationTimeMs;
             memberAggregationTimeMs += timings.memberAggregationTimeMs;
         };
-
-        /**
-         * Process a batch of events
-         * @param {Array<Object>} events - Array of event objects to process
-         * @returns {Promise<void>}
-         */
         const processBatch = async (events) => {
             // Even if the fetching is interrupted because of an error, we still store the last event timestamp
             const processingStart = Date.now();
@@ -438,13 +288,11 @@ module.exports = class EmailAnalyticsService {
             };
             const beforeEmailIds = new Set(processingResult.emailIds);
             const beforeMemberIds = new Set(processingResult.memberIds);
-
             await eventProcessor.processBatch(events, processingResult, fetchData);
             processingTimeMs += (Date.now() - processingStart);
             eventCount += events.length;
-
             // Calculate delta (only new counts from this batch) and accumulate for final reporting
-            const batchDelta = new EventProcessingResult({
+            const batchDelta = new event_processing_result_1.EventProcessingResult({
                 opened: processingResult.opened - beforeCounts.opened,
                 delivered: processingResult.delivered - beforeCounts.delivered,
                 temporaryFailed: processingResult.temporaryFailed - beforeCounts.temporaryFailed,
@@ -457,48 +305,46 @@ module.exports = class EmailAnalyticsService {
                 memberIds: processingResult.memberIds.filter(id => !beforeMemberIds.has(id))
             });
             cumulativeResult.merge(batchDelta);
-
             // Offer the event processor a chance to aggregate mid-fetch.
             try {
                 if (eventCount) {
                     await aggregate(false);
                 }
-            } catch (err) {
-                logging.error('[EmailAnalytics] Error while aggregating stats');
-                logging.error(err);
             }
-
+            catch (err) {
+                logging_1.default.error('[EmailAnalytics] Error while aggregating stats');
+                logging_1.default.error(err);
+            }
             if (fetchData.canceled) {
-                throw new errors.InternalServerError({
+                throw new errors_1.default.InternalServerError({
                     message: 'Fetching canceled'
                 });
             }
         };
-
         try {
-            await this.provider.fetchLatest(processBatch, {begin, end, maxEvents, events: eventTypes});
-        } catch (err) {
-            if (err.message !== 'Fetching canceled') {
-                logging.error('[EmailAnalytics] Error while fetching');
-                logging.error(err);
+            await this.#fetchEvents({ batchHandler: processBatch, begin, end, maxEvents, events: eventTypes });
+        }
+        catch (err) {
+            if (!(err instanceof Error) || err.message !== 'Fetching canceled') {
+                logging_1.default.error('[EmailAnalytics] Error while fetching');
+                logging_1.default.error(err);
                 error = err;
-            } else {
-                logging.error('[EmailAnalytics] Canceled fetching');
+            }
+            else {
+                logging_1.default.error('[EmailAnalytics] Canceled fetching');
             }
         }
-
         // Final aggregation.
         try {
             await aggregate(true);
-        } catch (err) {
-            logging.error('[EmailAnalytics] Error while aggregating stats');
-            logging.error(err);
-
+        }
+        catch (err) {
+            logging_1.default.error('[EmailAnalytics] Error while aggregating stats');
+            logging_1.default.error(err);
             if (!error) {
                 error = err;
             }
         }
-
         // When we've consumed all available events (eventCount < maxEvents), advance the cursor by 1 second
         // to avoid re-fetching the same batch on the next cycle. When we hit the maxEvents budget mid-second,
         // do NOT advance — the next pass needs to re-cover that second to pick up any remaining events.
@@ -509,21 +355,18 @@ module.exports = class EmailAnalyticsService {
                 // Consumed everything in the window — advance to avoid re-fetching same batch
                 fetchData.lastEventTimestamp = new Date(fetchData.lastEventTimestamp.getTime() + 1000);
             }
-        } else {
+        }
+        else {
             await this.queries.setJobStatus(fetchData.jobName, 'finished');
         }
-
         fetchData.running = false;
-
         const totalTimeMs = Date.now() - fetchStartMs;
         // Derived by subtraction because fetchLatest() invokes processBatch internally,
         // so directly timing fetchLatest() would double-count processing and aggregation time.
         const apiPollingTimeMs = totalTimeMs - processingTimeMs - aggregationTimeMs;
-
         if (error) {
             throw error;
         }
-
         return {
             eventCount,
             apiPollingTimeMs,
@@ -534,4 +377,5 @@ module.exports = class EmailAnalyticsService {
             result: cumulativeResult
         };
     }
-};
+}
+exports.EmailAnalyticsService = EmailAnalyticsService;

package/core/server/services/email-analytics/event-processing-result.js

@@ -32,16 +32,6 @@ class EventProcessingResult {
         this.emailIds = [];
         this.memberIds = [];
     }
-    get totalEvents() {
-        return this.delivered
-            + this.opened
-            + this.temporaryFailed
-            + this.permanentFailed
-            + this.unsubscribed
-            + this.complained
-            + this.unhandled
-            + this.unprocessable;
-    }
     merge(other = {}) {
         this.delivered += other.delivered || 0;
         this.opened += other.opened || 0;

package/core/server/services/email-analytics/fetch-mailgun-events.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchMailgunEvents = fetchMailgunEvents;
+// @ts-expect-error This module lacks type definitions.
+const mailgun_client_1 = __importDefault(require("../lib/mailgun-client"));
+const DEFAULT_EVENT_FILTER = 'delivered OR opened OR failed OR unsubscribed OR complained';
+const PAGE_LIMIT = 300;
+/**
+ * Fetch Mailgun email analytics events.
+ */
+async function fetchMailgunEvents({ config, settings, tags, batchHandler, maxEvents, begin, end, events }) {
+    const mailgunClient = new mailgun_client_1.default({ config, settings });
+    const mailgunOptions = {
+        limit: PAGE_LIMIT,
+        event: events ? events.join(' OR ') : DEFAULT_EVENT_FILTER,
+        tags: tags.join(' AND '),
+        begin: begin ? begin.getTime() / 1000 : undefined,
+        end: end ? end.getTime() / 1000 : undefined,
+        ascending: 'yes'
+    };
+    return await mailgunClient.fetchEvents(mailgunOptions, batchHandler, { maxEvents });
+}