bunqueue 1.9.7 → 1.9.9

package/dist/application/queueManager.js

@@ -13,7 +13,7 @@ import { RWLock } from '../shared/lock';
 import { shardIndex, SHARD_COUNT } from '../shared/hash';
 import { pushJob, pushJobBatch } from './operations/push';
 import { pullJob, pullJobBatch } from './operations/pull';
-import { ackJob, ackJobBatch, ackJobBatchWithResults, failJob, } from './operations/ack';
+import { ackJob, ackJobBatch, ackJobBatchWithResults, failJob } from './operations/ack';
 import * as queueControl from './operations/queueControl';
 import * as jobMgmt from './operations/jobManagement';
 import * as queryOps from './operations/queryOperations';
@@ -25,6 +25,7 @@ import { DEFAULT_CONFIG } from './types';
 import * as lockMgr from './lockManager';
 import * as bgTasks from './backgroundTasks';
 import * as statsMgr from './statsManager';
+import { ContextFactory } from './contextFactory';
 /**
  * QueueManager - Central coordinator
  */
@@ -46,7 +47,7 @@ export class QueueManager {
     pendingDepChecks = new Set();
     // Two-phase stall detection
     stalledCandidates = new Set();
-    // Lock-based job ownership tracking (BullMQ-style)
+    // Lock-based job ownership tracking
     jobLocks = new Map();
     clientJobs = new Map();
     // Cron scheduler
@@ -66,9 +67,11 @@ export class QueueManager {
     };
     startTime = Date.now();
     // Background task handles
-    backgroundTaskHandles = null;
-    // Queue names cache for O(1) listQueues
+    backgroundTaskHandles;
+    // Queue names cache
     queueNamesCache = new Set();
+    // Context factory
+    contextFactory;
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
         this.storage = config.dataPath ? new SqliteStorage({ path: config.dataPath }) : null;
@@ -91,32 +94,28 @@ export class QueueManager {
         this.cronScheduler.setPushCallback(async (queue, input) => {
             await this.push(queue, input);
         });
+        // Set up persistence callback for cron state
+        if (this.storage) {
+            const storage = this.storage;
+            this.cronScheduler.setPersistCallback((name, executions, nextRun) => {
+                storage.updateCron(name, executions, nextRun);
+            });
+        }
         // Initialize managers
         this.webhookManager = new WebhookManager();
         this.workerManager = new WorkerManager();
         this.eventsManager = new EventsManager(this.webhookManager);
+        // Initialize context factory
+        this.contextFactory = new ContextFactory(this.getContextDependencies(), this.getContextCallbacks());
         // Load and start
-        bgTasks.recover(this.getBackgroundContext());
-        // Load cron jobs from storage
+        bgTasks.recover(this.contextFactory.getBackgroundContext());
         if (this.storage) {
             this.cronScheduler.load(this.storage.loadCronJobs());
         }
-        this.backgroundTaskHandles = bgTasks.startBackgroundTasks(this.getBackgroundContext(), this.cronScheduler);
-    }
-    // ============ Context Builders ============
-    getLockContext() {
-        return {
-            jobIndex: this.jobIndex,
-            jobLocks: this.jobLocks,
-            clientJobs: this.clientJobs,
-            processingShards: this.processingShards,
-            processingLocks: this.processingLocks,
-            shards: this.shards,
-            shardLocks: this.shardLocks,
-            eventsManager: this.eventsManager,
-        };
+        this.backgroundTaskHandles = bgTasks.startBackgroundTasks(this.contextFactory.getBackgroundContext(), this.cronScheduler);
     }
-    getBackgroundContext() {
+    // ============ Context Dependencies ============
+    getContextDependencies() {
         return {
             config: this.config,
             storage: this.storage,
@@ -138,68 +137,16 @@ export class QueueManager {
             webhookManager: this.webhookManager,
             metrics: this.metrics,
             startTime: this.startTime,
-            fail: this.fail.bind(this),
-            registerQueueName: this.registerQueueName.bind(this),
-            unregisterQueueName: this.unregisterQueueName.bind(this),
-        };
-    }
-    getStatsContext() {
-        return {
-            shards: this.shards,
-            processingShards: this.processingShards,
-            completedJobs: this.completedJobs,
-            jobIndex: this.jobIndex,
-            jobResults: this.jobResults,
-            jobLogs: this.jobLogs,
-            customIdMap: this.customIdMap,
-            jobLocks: this.jobLocks,
-            clientJobs: this.clientJobs,
-            pendingDepChecks: this.pendingDepChecks,
-            stalledCandidates: this.stalledCandidates,
-            metrics: this.metrics,
-            startTime: this.startTime,
-        };
-    }
-    getPushContext() {
-        return {
-            storage: this.storage,
-            shards: this.shards,
-            shardLocks: this.shardLocks,
-            completedJobs: this.completedJobs,
-            customIdMap: this.customIdMap,
-            jobIndex: this.jobIndex,
-            totalPushed: this.metrics.totalPushed,
-            broadcast: this.eventsManager.broadcast.bind(this.eventsManager),
-        };
-    }
-    getPullContext() {
-        return {
-            storage: this.storage,
-            shards: this.shards,
-            shardLocks: this.shardLocks,
-            processingShards: this.processingShards,
-            processingLocks: this.processingLocks,
-            jobIndex: this.jobIndex,
-            totalPulled: this.metrics.totalPulled,
-            broadcast: this.eventsManager.broadcast.bind(this.eventsManager),
+            maxLogsPerJob: this.maxLogsPerJob,
         };
     }
-    getAckContext() {
+    getContextCallbacks() {
         return {
-            storage: this.storage,
-            shards: this.shards,
-            shardLocks: this.shardLocks,
-            processingShards: this.processingShards,
-            processingLocks: this.processingLocks,
-            completedJobs: this.completedJobs,
-            jobResults: this.jobResults,
-            jobIndex: this.jobIndex,
-            totalCompleted: this.metrics.totalCompleted,
-            totalFailed: this.metrics.totalFailed,
-            broadcast: this.eventsManager.broadcast.bind(this.eventsManager),
+            fail: this.fail.bind(this),
+            registerQueueName: this.registerQueueName.bind(this),
+            unregisterQueueName: this.unregisterQueueName.bind(this),
             onJobCompleted: this.onJobCompleted.bind(this),
             onJobsCompleted: this.onJobsCompleted.bind(this),
-            needsBroadcast: this.eventsManager.needsBroadcast.bind(this.eventsManager),
             hasPendingDeps: this.hasPendingDeps.bind(this),
             onRepeat: this.handleRepeat.bind(this),
         };
@@ -229,115 +176,87 @@ export class QueueManager {
             },
         });
     }
-    getJobMgmtContext() {
-        return {
-            storage: this.storage,
-            shards: this.shards,
-            shardLocks: this.shardLocks,
-            processingShards: this.processingShards,
-            processingLocks: this.processingLocks,
-            jobIndex: this.jobIndex,
-            webhookManager: this.webhookManager,
-        };
-    }
-    getQueryContext() {
-        return {
-            storage: this.storage,
-            shards: this.shards,
-            shardLocks: this.shardLocks,
-            processingShards: this.processingShards,
-            processingLocks: this.processingLocks,
-            jobIndex: this.jobIndex,
-            completedJobs: this.completedJobs,
-            jobResults: this.jobResults,
-            customIdMap: this.customIdMap,
-        };
-    }
-    getDlqContext() {
-        return {
-            shards: this.shards,
-            jobIndex: this.jobIndex,
-            storage: this.storage,
-        };
-    }
     // ============ Core Operations ============
     async push(queue, input) {
         this.registerQueueName(queue);
-        return pushJob(queue, input, this.getPushContext());
+        return pushJob(queue, input, this.contextFactory.getPushContext());
     }
     async pushBatch(queue, inputs) {
         this.registerQueueName(queue);
-        return pushJobBatch(queue, inputs, this.getPushContext());
+        return pushJobBatch(queue, inputs, this.contextFactory.getPushContext());
     }
     async pull(queue, timeoutMs = 0) {
-        return pullJob(queue, timeoutMs, this.getPullContext());
+        return pullJob(queue, timeoutMs, this.contextFactory.getPullContext());
     }
     async pullWithLock(queue, owner, timeoutMs = 0, lockTtl = DEFAULT_LOCK_TTL) {
-        const job = await pullJob(queue, timeoutMs, this.getPullContext());
+        const job = await pullJob(queue, timeoutMs, this.contextFactory.getPullContext());
         if (!job)
             return { job: null, token: null };
-        const token = lockMgr.createLock(job.id, owner, this.getLockContext(), lockTtl);
+        const token = lockMgr.createLock(job.id, owner, this.contextFactory.getLockContext(), lockTtl);
         return { job, token };
     }
     async pullBatch(queue, count, timeoutMs = 0) {
-        return pullJobBatch(queue, count, timeoutMs, this.getPullContext());
+        return pullJobBatch(queue, count, timeoutMs, this.contextFactory.getPullContext());
     }
     async pullBatchWithLock(queue, count, owner, timeoutMs = 0, lockTtl = DEFAULT_LOCK_TTL) {
-        const jobs = await pullJobBatch(queue, count, timeoutMs, this.getPullContext());
+        const jobs = await pullJobBatch(queue, count, timeoutMs, this.contextFactory.getPullContext());
         const tokens = [];
         for (const job of jobs) {
-            const token = lockMgr.createLock(job.id, owner, this.getLockContext(), lockTtl);
+            const token = lockMgr.createLock(job.id, owner, this.contextFactory.getLockContext(), lockTtl);
             tokens.push(token ?? '');
         }
         return { jobs, tokens };
     }
     async ack(jobId, result, token) {
-        if (token && !lockMgr.verifyLock(jobId, token, this.getLockContext())) {
+        if (token && !lockMgr.verifyLock(jobId, token, this.contextFactory.getLockContext())) {
             throw new Error(`Invalid or expired lock token for job ${jobId}`);
         }
-        await ackJob(jobId, result, this.getAckContext());
-        lockMgr.releaseLock(jobId, this.getLockContext(), token);
+        await ackJob(jobId, result, this.contextFactory.getAckContext());
+        lockMgr.releaseLock(jobId, this.contextFactory.getLockContext(), token);
     }
     async ackBatch(jobIds, tokens) {
+        const lockCtx = this.contextFactory.getLockContext();
         if (tokens?.length === jobIds.length) {
             for (let i = 0; i < jobIds.length; i++) {
                 const t = tokens[i];
-                if (t && !lockMgr.verifyLock(jobIds[i], t, this.getLockContext())) {
+                if (t && !lockMgr.verifyLock(jobIds[i], t, lockCtx)) {
                     throw new Error(`Invalid or expired lock token for job ${jobIds[i]}`);
                 }
             }
         }
-        await ackJobBatch(jobIds, this.getAckContext());
+        await ackJobBatch(jobIds, this.contextFactory.getAckContext());
         if (tokens) {
             for (let i = 0; i < jobIds.length; i++) {
-                lockMgr.releaseLock(jobIds[i], this.getLockContext(), tokens[i]);
+                lockMgr.releaseLock(jobIds[i], lockCtx, tokens[i]);
             }
         }
     }
     async ackBatchWithResults(items) {
+        const lockCtx = this.contextFactory.getLockContext();
         for (const item of items) {
-            if (item.token && !lockMgr.verifyLock(item.id, item.token, this.getLockContext())) {
+            if (item.token && !lockMgr.verifyLock(item.id, item.token, lockCtx)) {
                 throw new Error(`Invalid or expired lock token for job ${item.id}`);
             }
         }
-        await ackJobBatchWithResults(items, this.getAckContext());
+        await ackJobBatchWithResults(items, this.contextFactory.getAckContext());
         for (const item of items) {
-            lockMgr.releaseLock(item.id, this.getLockContext(), item.token);
+            lockMgr.releaseLock(item.id, lockCtx, item.token);
         }
     }
     async fail(jobId, error, token) {
-        if (token && !lockMgr.verifyLock(jobId, token, this.getLockContext())) {
+        const lockCtx = this.contextFactory.getLockContext();
+        if (token && !lockMgr.verifyLock(jobId, token, lockCtx)) {
             throw new Error(`Invalid or expired lock token for job ${jobId}`);
         }
-        await failJob(jobId, error, this.getAckContext());
-        lockMgr.releaseLock(jobId, this.getLockContext(), token);
+        await failJob(jobId, error, this.contextFactory.getAckContext());
+        lockMgr.releaseLock(jobId, lockCtx, token);
     }
     jobHeartbeat(jobId, token) {
         const loc = this.jobIndex.get(jobId);
         if (loc?.type !== 'processing')
             return false;
         if (token) {
-            return lockMgr.renewJobLock(jobId, token, this.getLockContext());
+            return lockMgr.renewJobLock(jobId, token, this.contextFactory.getLockContext());
         }
         const processing = this.processingShards[loc.shardIdx];
         const job = processing.get(jobId);
@@ -355,66 +274,66 @@ export class QueueManager {
         }
         return count;
     }
-    // ============ Lock Management (delegated) ============
+    // ============ Lock Management ============
     createLock(jobId, owner, ttl = DEFAULT_LOCK_TTL) {
-        return lockMgr.createLock(jobId, owner, this.getLockContext(), ttl);
+        return lockMgr.createLock(jobId, owner, this.contextFactory.getLockContext(), ttl);
     }
     verifyLock(jobId, token) {
-        return lockMgr.verifyLock(jobId, token, this.getLockContext());
+        return lockMgr.verifyLock(jobId, token, this.contextFactory.getLockContext());
     }
     renewJobLock(jobId, token, newTtl) {
-        return lockMgr.renewJobLock(jobId, token, this.getLockContext(), newTtl);
+        return lockMgr.renewJobLock(jobId, token, this.contextFactory.getLockContext(), newTtl);
     }
     renewJobLockBatch(items) {
-        return lockMgr.renewJobLockBatch(items, this.getLockContext());
+        return lockMgr.renewJobLockBatch(items, this.contextFactory.getLockContext());
     }
     releaseLock(jobId, token) {
-        return lockMgr.releaseLock(jobId, this.getLockContext(), token);
+        return lockMgr.releaseLock(jobId, this.contextFactory.getLockContext(), token);
     }
     getLockInfo(jobId) {
-        return lockMgr.getLockInfo(jobId, this.getLockContext());
+        return lockMgr.getLockInfo(jobId, this.contextFactory.getLockContext());
     }
-    // ============ Client-Job Tracking (delegated) ============
+    // ============ Client-Job Tracking ============
     registerClientJob(clientId, jobId) {
-        lockMgr.registerClientJob(clientId, jobId, this.getLockContext());
+        lockMgr.registerClientJob(clientId, jobId, this.contextFactory.getLockContext());
     }
     unregisterClientJob(clientId, jobId) {
-        lockMgr.unregisterClientJob(clientId, jobId, this.getLockContext());
+        lockMgr.unregisterClientJob(clientId, jobId, this.contextFactory.getLockContext());
     }
     releaseClientJobs(clientId) {
-        return lockMgr.releaseClientJobs(clientId, this.getLockContext());
+        return lockMgr.releaseClientJobs(clientId, this.contextFactory.getLockContext());
     }
-    // ============ Query Operations (delegated) ============
+    // ============ Query Operations ============
     async getJob(jobId) {
-        return queryOps.getJob(jobId, this.getQueryContext());
+        return queryOps.getJob(jobId, this.contextFactory.getQueryContext());
     }
     getResult(jobId) {
-        return queryOps.getJobResult(jobId, this.getQueryContext());
+        return queryOps.getJobResult(jobId, this.contextFactory.getQueryContext());
     }
     getJobByCustomId(customId) {
-        return queryOps.getJobByCustomId(customId, this.getQueryContext());
+        return queryOps.getJobByCustomId(customId, this.contextFactory.getQueryContext());
     }
     getProgress(jobId) {
-        return queryOps.getJobProgress(jobId, this.getQueryContext());
+        return queryOps.getJobProgress(jobId, this.contextFactory.getQueryContext());
     }
     count(queue) {
-        return queueControl.getQueueCount(queue, { shards: this.shards, jobIndex: this.jobIndex });
+        return queueControl.getQueueCount(queue, this.contextFactory.getQueueControlContext());
     }
-    // ============ Queue Control (delegated) ============
+    // ============ Queue Control ============
     pause(queue) {
-        queueControl.pauseQueue(queue, { shards: this.shards, jobIndex: this.jobIndex });
+        queueControl.pauseQueue(queue, this.contextFactory.getQueueControlContext());
     }
     resume(queue) {
-        queueControl.resumeQueue(queue, { shards: this.shards, jobIndex: this.jobIndex });
+        queueControl.resumeQueue(queue, this.contextFactory.getQueueControlContext());
     }
     isPaused(queue) {
-        return queueControl.isQueuePaused(queue, { shards: this.shards, jobIndex: this.jobIndex });
+        return queueControl.isQueuePaused(queue, this.contextFactory.getQueueControlContext());
     }
     drain(queue) {
-        return queueControl.drainQueue(queue, { shards: this.shards, jobIndex: this.jobIndex });
+        return queueControl.drainQueue(queue, this.contextFactory.getQueueControlContext());
     }
     obliterate(queue) {
-        queueControl.obliterateQueue(queue, { shards: this.shards, jobIndex: this.jobIndex });
+        queueControl.obliterateQueue(queue, this.contextFactory.getQueueControlContext());
         this.unregisterQueueName(queue);
     }
     listQueues() {
@@ -427,7 +346,7 @@ export class QueueManager {
         this.queueNamesCache.delete(queue);
     }
     clean(queue, graceMs, state, limit) {
-        return queueControl.cleanQueue(queue, graceMs, { shards: this.shards, jobIndex: this.jobIndex }, state, limit);
+        return queueControl.cleanQueue(queue, graceMs, this.contextFactory.getQueueControlContext(), state, limit);
     }
     getCountsPerPriority(queue) {
         const idx = shardIndex(queue);
@@ -435,80 +354,24 @@ export class QueueManager {
         return Object.fromEntries(counts);
     }
     getJobs(queue, options = {}) {
-        const { state, start = 0, end = 100, asc = true } = options;
         const idx = shardIndex(queue);
-        const shard = this.shards[idx];
-        const now = Date.now();
-        const jobs = [];
-        if (!state || state === 'waiting') {
-            jobs.push(...shard
-                .getQueue(queue)
-                .values()
-                .filter((j) => j.runAt <= now));
-        }
-        if (!state || state === 'delayed') {
-            jobs.push(...shard
-                .getQueue(queue)
-                .values()
-                .filter((j) => j.runAt > now));
-        }
-        if (!state || state === 'active') {
-            for (let i = 0; i < SHARD_COUNT; i++) {
-                for (const job of this.processingShards[i].values()) {
-                    if (job.queue === queue)
-                        jobs.push(job);
-                }
-            }
-        }
-        if (!state || state === 'failed') {
-            jobs.push(...shard.getDlq(queue));
-        }
-        jobs.sort((a, b) => (asc ? a.createdAt - b.createdAt : b.createdAt - a.createdAt));
-        return jobs.slice(start, end);
+        return queryOps.getJobs(queue, idx, options, {
+            ...this.contextFactory.getQueryContext(),
+            shardCount: SHARD_COUNT,
+        });
     }
-    // ============ DLQ Operations (delegated) ============
+    // ============ DLQ Operations ============
     getDlq(queue, count) {
-        return dlqOps.getDlqJobs(queue, this.getDlqContext(), count);
+        return dlqOps.getDlqJobs(queue, this.contextFactory.getDlqContext(), count);
     }
     retryDlq(queue, jobId) {
-        return dlqOps.retryDlqJobs(queue, this.getDlqContext(), jobId);
+        return dlqOps.retryDlqJobs(queue, this.contextFactory.getDlqContext(), jobId);
     }
     purgeDlq(queue) {
-        return dlqOps.purgeDlqJobs(queue, this.getDlqContext());
+        return dlqOps.purgeDlqJobs(queue, this.contextFactory.getDlqContext());
     }
     retryCompleted(queue, jobId) {
-        if (jobId) {
-            if (!this.completedJobs.has(jobId))
-                return 0;
-            const job = this.storage?.getJob(jobId);
-            if (job?.queue !== queue)
-                return 0;
-            return this.requeueCompletedJob(job);
-        }
-        let count = 0;
-        for (const id of this.completedJobs) {
-            const job = this.storage?.getJob(id);
-            if (job?.queue === queue)
-                count += this.requeueCompletedJob(job);
-        }
-        return count;
-    }
-    requeueCompletedJob(job) {
-        job.attempts = 0;
-        job.startedAt = null;
-        job.completedAt = null;
-        job.runAt = Date.now();
-        job.progress = 0;
-        const idx = shardIndex(job.queue);
-        const shard = this.shards[idx];
-        shard.getQueue(job.queue).push(job);
-        shard.incrementQueued(job.id, false, job.createdAt, job.queue, job.runAt);
-        this.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: job.queue });
-        this.completedJobs.delete(job.id);
-        this.jobResults.delete(job.id);
-        this.storage?.updateForRetry(job);
-        shard.notify();
-        return 1;
+        return dlqOps.retryCompletedJobs(queue, this.contextFactory.getRetryCompletedContext(), jobId);
     }
     // ============ Rate Limiting ============
     setRateLimit(queue, limit) {
@@ -523,45 +386,37 @@ export class QueueManager {
     clearConcurrency(queue) {
         this.shards[shardIndex(queue)].clearConcurrency(queue);
     }
-    // ============ Job Management (delegated) ============
+    // ============ Job Management ============
     async cancel(jobId) {
-        return jobMgmt.cancelJob(jobId, this.getJobMgmtContext());
+        return jobMgmt.cancelJob(jobId, this.contextFactory.getJobMgmtContext());
     }
     async updateProgress(jobId, progress, message) {
-        return jobMgmt.updateJobProgress(jobId, progress, this.getJobMgmtContext(), message);
+        return jobMgmt.updateJobProgress(jobId, progress, this.contextFactory.getJobMgmtContext(), message);
     }
     async updateJobData(jobId, data) {
-        return jobMgmt.updateJobData(jobId, data, this.getJobMgmtContext());
+        return jobMgmt.updateJobData(jobId, data, this.contextFactory.getJobMgmtContext());
     }
     async changePriority(jobId, priority) {
-        return jobMgmt.changeJobPriority(jobId, priority, this.getJobMgmtContext());
+        return jobMgmt.changeJobPriority(jobId, priority, this.contextFactory.getJobMgmtContext());
     }
     async promote(jobId) {
-        return jobMgmt.promoteJob(jobId, this.getJobMgmtContext());
+        return jobMgmt.promoteJob(jobId, this.contextFactory.getJobMgmtContext());
     }
     async moveToDelayed(jobId, delay) {
-        return jobMgmt.moveJobToDelayed(jobId, delay, this.getJobMgmtContext());
+        return jobMgmt.moveJobToDelayed(jobId, delay, this.contextFactory.getJobMgmtContext());
     }
     async discard(jobId) {
-        return jobMgmt.discardJob(jobId, this.getJobMgmtContext());
+        return jobMgmt.discardJob(jobId, this.contextFactory.getJobMgmtContext());
     }
-    // ============ Job Logs (delegated) ============
+    // ============ Job Logs ============
     addLog(jobId, message, level = 'info') {
-        return logsOps.addJobLog(jobId, message, { jobIndex: this.jobIndex, jobLogs: this.jobLogs, maxLogsPerJob: this.maxLogsPerJob }, level);
+        return logsOps.addJobLog(jobId, message, this.contextFactory.getLogsContext(), level);
     }
     getLogs(jobId) {
-        return logsOps.getJobLogs(jobId, {
-            jobIndex: this.jobIndex,
-            jobLogs: this.jobLogs,
-            maxLogsPerJob: this.maxLogsPerJob,
-        });
+        return logsOps.getJobLogs(jobId, this.contextFactory.getLogsContext());
     }
     clearLogs(jobId) {
-        logsOps.clearJobLogs(jobId, {
-            jobIndex: this.jobIndex,
-            jobLogs: this.jobLogs,
-            maxLogsPerJob: this.maxLogsPerJob,
-        });
+        logsOps.clearJobLogs(jobId, this.contextFactory.getLogsContext());
     }
     // ============ Metrics ============
     getPrometheusMetrics() {
@@ -599,7 +454,6 @@ export class QueueManager {
     getCompletedJobs() {
         return this.completedJobs;
     }
-    /** Expose shards for testing (internal use only) */
     getShards() {
         return this.shards;
     }
@@ -617,15 +471,15 @@ export class QueueManager {
         }
         return false;
     }
-    // ============ Stats (delegated) ============
+    // ============ Stats ============
     getStats() {
-        return statsMgr.getStats(this.getStatsContext(), this.cronScheduler);
+        return statsMgr.getStats(this.contextFactory.getStatsContext(), this.cronScheduler);
     }
     getMemoryStats() {
-        return statsMgr.getMemoryStats(this.getStatsContext());
+        return statsMgr.getMemoryStats(this.contextFactory.getStatsContext());
     }
     compactMemory() {
-        statsMgr.compactMemory(this.getStatsContext());
+        statsMgr.compactMemory(this.contextFactory.getStatsContext());
     }
     // ============ Lifecycle ============
     shutdown() {