@cloudnux/local-cloud-provider 0.7.0 → 0.11.0

package/dist/queue-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;
@@ -94,6 +92,7 @@ interface QueueManager {
 interface QueueDecoratorOptions {
     config: QueueConfig;
     queues: Record<string, QueueService>;
+    dirtyQueues: Set<string>;
     saveQueueState?: (queueName: string, queueService: QueueService) => Promise<void>;
     loadQueueState?: (queueName: string) => Promise<void>;
     scheduleProcessing: (queueName: string, queueService: QueueService) => void;

package/dist/queue-plugin/index.js

@@ -866,12 +866,14 @@ var errorToString = (error) => {
 
 // ../../utils/src/logging/index.ts
 var currentLogLevel = logLevels[env("LOG_LEVEL")?.toLowerCase()] ?? logLevels.info;
+var module = "default";
+var requestId = "";
 var logger = {
   fatal: (message, meta) => {
     if (currentLogLevel >= logLevels.fatal) {
       console.error(
         `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgRed.white(" fatal ")}${EOL}`,
+        `${chalk.bgRed.white(" fatal ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
         errorToString(message),
         meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
       );
@@ -881,7 +883,7 @@ var logger = {
     if (currentLogLevel >= logLevels.error) {
       console.error(
         `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgRed.white(" error ")}${EOL}`,
+        `${chalk.bgRed.white(" error ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
         errorToString(message),
         meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
       );
@@ -891,7 +893,7 @@ var logger = {
     if (currentLogLevel >= logLevels.warn) {
       console.warn(
         `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgYellow.black(" warn ")}${EOL}`,
+        `${chalk.bgYellow.black(" warn ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
         errorToString(message),
         meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
       );
@@ -901,7 +903,7 @@ var logger = {
     if (currentLogLevel >= logLevels.info) {
       console.info(
         `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgBlue.white(" info ")}${EOL}`,
+        `${chalk.bgBlue.white(" info ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
         message,
         meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
       );
@@ -911,7 +913,7 @@ var logger = {
     if (currentLogLevel >= logLevels.debug) {
       console.debug(
         `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgWhite.black(" debug ")}${EOL}`,
+        `${chalk.bgWhite.black(" debug ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
         message,
         meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
       );
@@ -943,15 +945,14 @@ var mergeConfig = (defaultConfig, userConfig) => ({
     ...userConfig?.persistence || {}
   }
 });
-var createQueueService = (handler, module) => ({
+var createQueueService = (handler, module2) => ({
   handler,
   incoming: [],
   processing: [],
   dlq: [],
   timeoutId: null,
   processingBatch: false,
-  activeProcessing: 0,
-  module
+  module: module2
 });
 var createQueueMessage = (body, headers) => {
   const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
@@ -997,7 +998,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,
@@ -1039,7 +1039,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)}`);
@@ -1072,7 +1072,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;
@@ -1090,8 +1090,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;
@@ -1133,18 +1133,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);
       };
@@ -1153,7 +1156,8 @@ var createPersistenceInitializer = (config, loadAllQueueStates, saveAllQueueStat
     }
     logger.debug(`${logSymbols2.success} ${chalk3.green("Queue persistence initialized:")} ${chalk3.yellow(config.persistence.directory)}`);
   } catch (error) {
-    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to initialize queue persistence:")} ${chalk3.yellow(error.message)}`);
+    console.log("[logger]", logger);
+    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to initialize queue persistence:")} ${chalk3.yellow(error?.message)}`);
   }
 };
 var createQueueStateSaver = (config) => async (queueName, queueService) => {
@@ -1165,9 +1169,9 @@ var createQueueStateSaver = (config) => async (queueName, queueService) => {
     const tempFilePath = path.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);
+    logger.error(`Failed to save queue state for ${queueName}:`, error?.message);
   }
 };
 var createAllQueuesStateSaver = (config, saveQueueState) => (queues) => async () => {
@@ -1177,7 +1181,21 @@ var createAllQueuesStateSaver = (config, saveQueueState) => (queues) => async ()
     }
     logger.debug(`${logSymbols2.success} ${chalk3.green("All queue states saved to")} ${chalk3.yellow(config.persistence.directory)}`);
   } catch (error) {
-    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save all queue states:")} ${chalk3.yellow(error.message)}`);
+    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) => {
@@ -1216,7 +1234,7 @@ var createQueueStateLoader = (config, scheduleProcessing, processMessage) => (qu
       }
     }
   } catch (error) {
-    logger.error(`Failed to load queue state for ${queueName}:`, error);
+    logger.error(`Failed to load queue state for ${queueName}:`, error?.message);
   }
 };
 var createAllQueuesStateLoader = (config, loadQueueState) => async () => {
@@ -1229,7 +1247,7 @@ var createAllQueuesStateLoader = (config, loadQueueState) => async () => {
     }
     logger.debug("All queue states loaded");
   } catch (error) {
-    logger.error("Failed to load queue states:", error);
+    logger.error("Failed to load queue states:", error?.message);
   }
 };
 
@@ -1297,6 +1315,7 @@ var isValidQueueName = (queueName) => {
 var createQueueManager = ({
   config,
   queues,
+  dirtyQueues,
   saveQueueState,
   loadQueueState,
   scheduleProcessing,
@@ -1315,7 +1334,7 @@ var createQueueManager = ({
       throw new Error("Handler must be a function");
     }
   };
-  const addQueue = async (queueName, handler, module) => {
+  const addQueue = async (queueName, handler, module2) => {
     try {
       validateQueueName(queueName);
       validateHandler(handler);
@@ -1323,7 +1342,7 @@ var createQueueManager = ({
         logger.warn(`${logSymbols3.warning} ${chalk4.yellow("Queue already exists:")} ${chalk4.magenta(queueName)}.`);
         return;
       }
-      queues[queueName] = createQueueService(handler, module);
+      queues[queueName] = createQueueService(handler, module2);
       if (config.persistence.enabled && loadQueueState) {
         await loadQueueState(queueName);
       }
@@ -1365,10 +1384,10 @@ var createQueueManager = ({
       return false;
     }
   };
-  const listQueues = (module) => {
+  const listQueues = (module2) => {
     return Object.keys(queues).filter((queueName) => {
       const queueService = queues[queueName];
-      return !module || queueService.module === module;
+      return !module2 || queueService.module === module2;
     }).sort();
   };
   const getQueueStats = (queueName) => {
@@ -1407,8 +1426,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,
@@ -1429,8 +1448,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",
@@ -1451,8 +1470,8 @@ var createQueueManager = ({
       };
     }
     logDLQOperation("Purging", purgedCount, queueName);
-    if (saveQueueState) {
-      await saveQueueState(queueName, queues[queueName]);
+    if (config.persistence.enabled) {
+      dirtyQueues.add(queueName);
     }
     return {
       status: "success",
@@ -1483,14 +1502,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(
@@ -1501,11 +1524,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,