@cloudnux/local-cloud-provider 0.6.0 → 0.10.0

package/dist/dev-console-plugin/index.d.ts

@@ -20,7 +20,6 @@ interface QueueService {
     dlq: QueueMessage[];
     timeoutId: NodeJS.Timeout | null;
     processingBatch: boolean;
-    activeProcessing: number;
     module?: string;
 }
 interface QueueConfig {
@@ -43,7 +42,6 @@ interface QueueSummary {
     processing: number;
     dlq: number;
     isProcessing: boolean;
-    activeProcessing: number;
     configuration: {
         batchSize: number;
         batchWindowMs: number;

package/dist/dev-console-plugin/index.js

@@ -962,7 +962,6 @@ var createQueueService = (handler, module) => ({
   dlq: [],
   timeoutId: null,
   processingBatch: false,
-  activeProcessing: 0,
   module
 });
 var createQueueMessage = (body, headers) => {
@@ -1009,7 +1008,6 @@ var createQueueSummary = (queueService, config) => ({
   processing: queueService.processing.length,
   dlq: queueService.dlq.length,
   isProcessing: queueService.processingBatch,
-  activeProcessing: queueService.activeProcessing,
   configuration: {
     batchSize: config.batchSize,
     batchWindowMs: config.batchWindowMs,
@@ -1051,7 +1049,7 @@ var logError = (message, messageId, queueName, error) => {
   logger.error(`${logSymbols.error} ${chalk2.red(message)} ${chalk2.yellow(messageId)} in queue ${chalk2.magenta(queueName)}: ${error}`);
 };
 var logRetryScheduled = (messageId, delayMs) => {
-  logger.info(`${chalk2.blue("\u23F1\uFE0F Scheduling retry")} for message ${chalk2.yellow(messageId)} in ${chalk2.cyan(delayMs)}ms`);
+  logger.debug(`${chalk2.blue("\u23F1\uFE0F Scheduling retry")} for message ${chalk2.yellow(messageId)} in ${chalk2.cyan(delayMs)}ms`);
 };
 var logDLQOperation = (operation, count, queueName) => {
   logger.warn(`${logSymbols.warning} ${chalk2.yellow(operation)} ${chalk2.red(count)} messages from DLQ for ${chalk2.green(queueName)}`);
@@ -1084,7 +1082,7 @@ var handleProcessingError = async (queueName, message, queueService, error, conf
     }, delayMs);
   }
 };
-var createBatchProcessor = (processMessage, config, saveQueueState) => async (queueName, queueService) => {
+var createBatchProcessor = (processMessage, config, dirtyQueues) => async (queueName, queueService) => {
   if (queueService.timeoutId) {
     clearTimeout(queueService.timeoutId);
     queueService.timeoutId = null;
@@ -1102,8 +1100,8 @@ var createBatchProcessor = (processMessage, config, saveQueueState) => async (qu
     await Promise.all(messagesToProcess.map((message) => {
       return processMessage(queueName, message, queueService);
     }));
-    if (config.persistence.enabled && saveQueueState) {
-      await saveQueueState(queueName);
+    if (config.persistence.enabled && dirtyQueues) {
+      dirtyQueues.add(queueName);
     }
   } finally {
     queueService.processingBatch = false;
@@ -1145,18 +1143,21 @@ var restoreDates = (messages) => {
     if (msg.failedAt) msg.failedAt = new Date(msg.failedAt);
   });
 };
-var createPersistenceInitializer = (config, loadAllQueueStates, saveAllQueueStates) => async () => {
+var createPersistenceInitializer = (config, loadAllQueueStates, saveDirtyQueueStates, saveAllQueueStates, intervalIdHolder) => async () => {
   try {
     await fs.mkdir(config.persistence.directory, { recursive: true });
     if (config.persistence.loadOnStartup) {
       await loadAllQueueStates();
     }
     if (config.persistence.saveInterval > 0) {
-      setInterval(saveAllQueueStates, config.persistence.saveInterval);
+      intervalIdHolder.id = setInterval(saveDirtyQueueStates, config.persistence.saveInterval);
     }
     if (config.persistence.saveOnShutdown) {
       const shutdownHandler = async () => {
         logger.debug("Saving queue state before shutdown...");
+        if (intervalIdHolder.id) {
+          clearInterval(intervalIdHolder.id);
+        }
         await saveAllQueueStates();
         process.exit(0);
       };
@@ -1177,7 +1178,7 @@ var createQueueStateSaver = (config) => async (queueName, queueService) => {
     const tempFilePath = path2.join(config.persistence.directory, `${queueName}.${now}temp.json`);
     await fs.writeFile(tempFilePath, JSON.stringify(queueData, null, 2), "utf8");
     await fs.rename(tempFilePath, queueFilePath);
-    logger.info(`${logSymbols2.info} ${chalk3.blue("Queue state saved:")} ${chalk3.green(queueName)}`);
+    logger.debug(`${logSymbols2.info} ${chalk3.blue("Queue state saved:")} ${chalk3.green(queueName)}`);
   } catch (error) {
     logger.error(`Failed to save queue state for ${queueName}:`, error);
   }
@@ -1192,6 +1193,20 @@ var createAllQueuesStateSaver = (config, saveQueueState) => (queues) => async ()
     logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save all queue states:")} ${chalk3.yellow(error.message)}`);
   }
 };
+var createDirtyQueuesStateSaver = (saveQueueState, dirtyQueues) => (queues) => async () => {
+  if (dirtyQueues.size === 0) return;
+  try {
+    const queueNames = [...dirtyQueues];
+    dirtyQueues.clear();
+    for (const queueName of queueNames) {
+      if (queues[queueName]) {
+        await saveQueueState(queueName, queues[queueName]);
+      }
+    }
+  } catch (error) {
+    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save dirty queue states:")} ${chalk3.yellow(error.message)}`);
+  }
+};
 var createQueueStateLoader = (config, scheduleProcessing, processMessage) => (queues) => async (queueName) => {
   try {
     if (!queues[queueName]) {
@@ -1309,6 +1324,7 @@ var isValidQueueName = (queueName) => {
 var createQueueManager = ({
   config,
   queues,
+  dirtyQueues,
   saveQueueState,
   loadQueueState,
   scheduleProcessing,
@@ -1419,8 +1435,8 @@ var createQueueManager = ({
     queues[queueName].incoming.push(message);
     scheduleProcessing(queueName, queues[queueName]);
     handleImmediateProcessing(queues[queueName], config, processBatch, queueName);
-    if (config.persistence.enabled && saveQueueState) {
-      await saveQueueState(queueName, queues[queueName]);
+    if (config.persistence.enabled) {
+      dirtyQueues.add(queueName);
     }
     return {
       id: message.id,
@@ -1441,8 +1457,8 @@ var createQueueManager = ({
     }
     logDLQOperation("Moving", processedCount, queueName);
     scheduleProcessing(queueName, queues[queueName]);
-    if (saveQueueState) {
-      await saveQueueState(queueName, queues[queueName]);
+    if (config.persistence.enabled) {
+      dirtyQueues.add(queueName);
     }
     return {
       status: "success",
@@ -1463,8 +1479,8 @@ var createQueueManager = ({
       };
     }
     logDLQOperation("Purging", purgedCount, queueName);
-    if (saveQueueState) {
-      await saveQueueState(queueName, queues[queueName]);
+    if (config.persistence.enabled) {
+      dirtyQueues.add(queueName);
     }
     return {
       status: "success",
@@ -1495,14 +1511,18 @@ var createQueueDecorator = (queueManager) => (app) => {
 var queuesPlugin = fsPlugin(async (app, options) => {
   const config = mergeConfig(DEFAULT_CONFIG, options.config);
   const queues = {};
+  const dirtyQueues = /* @__PURE__ */ new Set();
+  const intervalIdHolder = {};
   const processMessage = createProcessMessageHandler(config);
   const saveQueueState = config.persistence.enabled ? createQueueStateSaver(config) : void 0;
   const saveAllQueueStates = config.persistence.enabled && saveQueueState ? createAllQueuesStateSaver(config, saveQueueState)(queues) : async () => {
   };
+  const saveDirtyQueueStates = config.persistence.enabled && saveQueueState ? createDirtyQueuesStateSaver(saveQueueState, dirtyQueues)(queues) : async () => {
+  };
   const processBatch = createBatchProcessor(
     processMessage,
     config,
-    saveQueueState ? (queueName) => saveQueueState(queueName, queues[queueName]) : void 0
+    config.persistence.enabled ? dirtyQueues : void 0
   );
   const scheduleProcessing = createProcessingScheduler(processBatch, config);
   const loadQueueState = config.persistence.enabled ? createQueueStateLoader(
@@ -1513,11 +1533,12 @@ var queuesPlugin = fsPlugin(async (app, options) => {
   };
   const loadAllQueueStates = config.persistence.enabled ? createAllQueuesStateLoader(config, loadQueueState) : async () => {
   };
-  const initializePersistence = config.persistence.enabled ? createPersistenceInitializer(config, loadAllQueueStates, saveAllQueueStates) : async () => {
+  const initializePersistence = config.persistence.enabled ? createPersistenceInitializer(config, loadAllQueueStates, saveDirtyQueueStates, saveAllQueueStates, intervalIdHolder) : async () => {
   };
   const queueManager = createQueueManager({
     config,
     queues,
+    dirtyQueues,
     saveQueueState: saveQueueState ? (queueName) => saveQueueState(queueName, queues[queueName]) : void 0,
     loadQueueState,
     scheduleProcessing,
@@ -1921,17 +1942,22 @@ var scheduleJob = (scheduler, state, executeJobFn) => {
     updatedScheduler.timerId = setTimeout(() => {
       executeJobFn(updatedScheduler);
     }, timeUntilNextRun);
-    logger.info(`${chalk6.blue("\u{1F4C5} Scheduled job")} ${chalk6.green(scheduler.job.name)} to run in ${chalk6.cyan(Math.round(timeUntilNextRun / 1e3))}s`);
+    logger.debug(`${chalk6.blue("\u{1F4C5} Scheduled job")} ${chalk6.green(scheduler.job.name)} to run in ${chalk6.cyan(Math.round(timeUntilNextRun / 1e3))}s`);
   }
   return updatedScheduler;
 };
 var executeJobWithTimeout = async (handler, job, execution, timeoutMs) => {
-  return Promise.race([
-    handler(job, execution),
-    new Promise(
-      (_, reject) => setTimeout(() => reject(new Error("Job execution timeout")), timeoutMs)
-    )
-  ]);
+  let timerId;
+  try {
+    return await Promise.race([
+      handler(job, execution),
+      new Promise((_, reject) => {
+        timerId = setTimeout(() => reject(new Error("Job execution timeout")), timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timerId);
+  }
 };
 var updateJobAfterExecution = (job, execution, config) => {
   const updatedJob = {
@@ -1974,7 +2000,7 @@ var saveSchedulerState = async (state) => {
     const tempFile = createTempFilePath(state.config.persistence.directory);
     await fs2.writeFile(tempFile, JSON.stringify(serializedState, null, 2), "utf8");
     await fs2.rename(tempFile, stateFile);
-    logger.info(`${logSymbols5.info} ${chalk7.blue("Enhanced scheduler state saved")}`);
+    logger.debug(`${logSymbols5.info} ${chalk7.blue("Enhanced scheduler state saved")}`);
   } catch (error) {
     logger.error("Failed to save scheduler state:", error);
   }
@@ -1986,7 +2012,7 @@ var loadSchedulerStateData = async (directory) => {
     return JSON.parse(data);
   } catch (error) {
     if (error.code === "ENOENT") {
-      logger.info(`${chalk7.blue("No previous scheduler state found - starting fresh")}`);
+      logger.debug(`${chalk7.blue("No previous scheduler state found - starting fresh")}`);
     } else {
       logger.error("Failed to load scheduler state:", error);
     }
@@ -1999,20 +2025,20 @@ var validateAndAdjustNextRun = (job, savedNextRun, lastRestartTime, config) => {
     return calculateNextRunFromLastRun(job, job.lastRun, config);
   }
   if (savedNextRun <= now) {
-    logger.info(`${chalk7.yellow("\u23F0 Saved next run is in the past for")} ${chalk7.green(job.name)} - recalculating`);
+    logger.debug(`${chalk7.yellow("\u23F0 Saved next run is in the past for")} ${chalk7.green(job.name)} - recalculating`);
     return calculateNextRunFromLastRun(job, job.lastRun, config);
   }
   const timeSinceRestart = now.getTime() - lastRestartTime.getTime();
   const isRapidRestart = timeSinceRestart < config.restartBehavior.rapidRestartThreshold;
   if (isRapidRestart) {
-    logger.info(`${chalk7.blue("\u26A1 Rapid restart detected for")} ${chalk7.green(job.name)} - preserving saved timing`);
+    logger.debug(`${chalk7.blue("\u26A1 Rapid restart detected for")} ${chalk7.green(job.name)} - preserving saved timing`);
     return savedNextRun;
   }
   if (job.cronExpression || job.intervalMs) {
     const expectedNextRun = calculateNextRunFromLastRun(job, job.lastRun, config);
     const timeDiff = Math.abs(savedNextRun.getTime() - expectedNextRun.getTime());
     if (timeDiff > config.restartBehavior.maxTimingDrift) {
-      logger.info(`${chalk7.yellow("\u{1F527} Adjusting timing for")} ${chalk7.green(job.name)} - drift of ${Math.round(timeDiff / 1e3)}s detected`);
+      logger.debug(`${chalk7.yellow("\u{1F527} Adjusting timing for")} ${chalk7.green(job.name)} - drift of ${Math.round(timeDiff / 1e3)}s detected`);
       return expectedNextRun;
     }
   }
@@ -2026,7 +2052,7 @@ var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) =>
     lastRun: savedJob.lastRun ? new Date(savedJob.lastRun) : void 0
   };
   if (definitionChanged) {
-    logger.info(`${chalk7.yellow("\u{1F504} Job definition changed:")} ${chalk7.green(savedJob.name)} - recalculating schedule`);
+    logger.debug(`${chalk7.yellow("\u{1F504} Job definition changed:")} ${chalk7.green(savedJob.name)} - recalculating schedule`);
     updatedJob.nextRun = calculateNextRunFromLastRun(updatedJob, updatedJob.lastRun, config);
   } else {
     const savedNextRun = savedJob.nextRun ? new Date(savedJob.nextRun) : void 0;
@@ -2036,7 +2062,7 @@ var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) =>
     const result = parseCronExpression(updatedJob.cronExpression, updatedJob.lastRun, {
       timezone: updatedJob.timezone
     });
-    logger.info(`${chalk7.blue("\u{1F4C5} Job restored:")} ${chalk7.green(savedJob.name)} - ${result.description} - next: ${chalk7.cyan(updatedJob.nextRun.toLocaleString())}`);
+    logger.debug(`${chalk7.blue("\u{1F4C5} Job restored:")} ${chalk7.green(savedJob.name)} - ${result.description} - next: ${chalk7.cyan(updatedJob.nextRun.toLocaleString())}`);
   }
   return { ...scheduler, job: updatedJob };
 };
@@ -2079,16 +2105,11 @@ var cleanupExecutionHistory = (state) => {
       0,
       state.executionHistory.length - state.config.cleanup.maxExecutionHistory
     );
-    logger.info(`${chalk8.blue("\u{1F9F9} Cleaned up")} ${removed.length} old execution records`);
+    logger.debug(`${chalk8.blue("\u{1F9F9} Cleaned up")} ${removed.length} old execution records`);
     return removed;
   }
   return [];
 };
-var startCleanupInterval = (state) => {
-  return setInterval(() => {
-    cleanupExecutionHistory(state);
-  }, state.config.cleanup.cleanupInterval);
-};
 
 // src/schedule-plugin/core.ts
 var DEFAULT_CONFIG2 = {
@@ -2140,6 +2161,8 @@ var createInitialState = (config) => {
     executionHistory: [],
     isShuttingDown: false,
     runningExecutions: 0,
+    isDirty: false,
+    lastCleanupTime: Date.now(),
     lastRestartTime: /* @__PURE__ */ new Date(),
     config
   };
@@ -2172,18 +2195,18 @@ var createSchedulerFunctions = (state) => {
       );
       const completedExecution = handleExecutionSuccess(execution, result);
       state.executions[execution.id] = completedExecution;
-      scheduler.job = updateJobAfterExecution(scheduler.job, execution, state.config);
     } catch (error) {
       const failedExecution = handleExecutionError(execution, error);
       state.executions[execution.id] = failedExecution;
     } finally {
       scheduler.isRunning = false;
       state.runningExecutions--;
+      scheduler.job = updateJobAfterExecution(scheduler.job, execution, state.config);
       if (scheduler.job.enabled && !state.isShuttingDown) {
         scheduleJobFn(scheduler);
       }
       if (state.config.persistence.enabled) {
-        await saveSchedulerState(state);
+        state.isDirty = true;
       }
     }
   };
@@ -2205,11 +2228,18 @@ var initializeScheduler = async (state, scheduleJobFn) => {
       );
       state.schedulers = schedulers;
       state.executionHistory = executionHistory;
-      if (state.config.persistence.saveInterval > 0) {
-        setInterval(() => saveSchedulerState(state), state.config.persistence.saveInterval);
-      }
     }
-    state.cleanupInterval = startCleanupInterval(state);
+    const tickInterval = state.config.persistence.saveInterval > 0 ? state.config.persistence.saveInterval : state.config.cleanup.cleanupInterval;
+    state.tickInterval = setInterval(async () => {
+      if (state.isDirty && state.config.persistence.enabled) {
+        state.isDirty = false;
+        await saveSchedulerState(state);
+      }
+      if (Date.now() - state.lastCleanupTime >= state.config.cleanup.cleanupInterval) {
+        state.lastCleanupTime = Date.now();
+        cleanupExecutionHistory(state);
+      }
+    }, tickInterval);
     for (const scheduler of Object.values(state.schedulers)) {
       if (scheduler.job.enabled) {
         scheduleJobFn(scheduler);
@@ -2240,11 +2270,11 @@ var createJobFromDefinition = (jobDef, config) => {
     const result = parseCronExpression(cronExpression, void 0, {
       timezone: jobDef.timezone ?? config.cron.defaultTimezone
     });
-    logger.info(`${chalk10.blue("\u{1F4C5} Job")} ${chalk10.green(jobDef.name)}: ${result.description} - Next: ${chalk10.cyan(result.nextRun.toLocaleString())}`);
+    logger.debug(`${chalk10.blue("\u{1F4C5} Job")} ${chalk10.green(jobDef.name)}: ${result.description} - Next: ${chalk10.cyan(result.nextRun.toLocaleString())}`);
     const upcoming = getNextExecutions(cronExpression, 3, {
       timezone: jobDef.timezone ?? config.cron.defaultTimezone
     });
-    logger.info(`${chalk10.blue("   Upcoming:")} ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
+    logger.debug(`${chalk10.blue("   Upcoming:")} ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
   }
   const job = {
     id: generateJobId(),
@@ -2308,19 +2338,19 @@ var createExecutionsData = (state) => ({
   running: Object.values(state.executions).filter((e) => e.status === "running")
 });
 var registerDashboardRoute = (app, state) => {
-  app.get("/dashboard", async function(_, reply) {
+  app.get("/schedule/dashboard", async function(_, reply) {
     const dashboardData = createDashboardData(state);
     return reply.status(200).send(dashboardData);
   });
 };
 var registerExecutionsRoute = (app, state) => {
-  app.get("/executions", async function(_, reply) {
+  app.get("/schedule/executions", async function(_, reply) {
     const executionsData = createExecutionsData(state);
     return reply.status(200).send(executionsData);
   });
 };
 var registerTriggerJobRoute = (app, state, executeJobFn) => {
-  app.post("/jobs/:jobId/trigger", async function(request, reply) {
+  app.post("/schedule/jobs/:jobId/trigger", async function(request, reply) {
     const scheduler = state.schedulers[request.params.jobId];
     if (!scheduler) {
       return reply.status(404).send({ error: "Job not found" });
@@ -2333,7 +2363,7 @@ var registerTriggerJobRoute = (app, state, executeJobFn) => {
   });
 };
 var registerEnableJobRoute = (app, state, scheduleJobFn) => {
-  app.put("/jobs/:jobId/enable", async function(request, reply) {
+  app.put("/schedule/jobs/:jobId/enable", async function(request, reply) {
     const scheduler = state.schedulers[request.params.jobId];
     if (!scheduler) {
       return reply.status(404).send({ error: "Job not found" });
@@ -2345,7 +2375,7 @@ var registerEnableJobRoute = (app, state, scheduleJobFn) => {
   });
 };
 var registerDisableJobRoute = (app, state) => {
-  app.put("/jobs/:jobId/disable", async function(request, reply) {
+  app.put("/schedule/jobs/:jobId/disable", async function(request, reply) {
     const scheduler = state.schedulers[request.params.jobId];
     if (!scheduler) {
       return reply.status(404).send({ error: "Job not found" });
@@ -2459,7 +2489,7 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (scheduler.job.enabled) {
-        logger.info(`${logSymbols9.info} ${chalk11.blue("Job is already enabled:")} ${chalk11.magenta(jobName)}`);
+        logger.debug(`${logSymbols9.info} ${chalk11.blue("Job is already enabled:")} ${chalk11.magenta(jobName)}`);
         return;
       }
       scheduler.job.enabled = true;
@@ -2478,7 +2508,7 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (!scheduler.job.enabled) {
-        logger.info(`${logSymbols9.info} ${chalk11.blue("Job is already disabled:")} ${chalk11.magenta(jobName)}`);
+        logger.debug(`${logSymbols9.info} ${chalk11.blue("Job is already disabled:")} ${chalk11.magenta(jobName)}`);
         return;
       }
       scheduler.job.enabled = false;