@rudderstack/integrations-lib 0.2.37 → 0.2.39

package/build/cluster/examples.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=examples.d.ts.map

package/build/cluster/examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"examples.d.ts","sourceRoot":"","sources":["../../src/cluster/examples.ts"],"names":[],"mappings":""}

package/build/cluster/examples.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable require-await */
+const cluster_1 = __importDefault(require("cluster"));
+const manager_1 = require("./manager");
+const logger = __importStar(require("../logger"));
+async function normalExample() {
+    const manager = new manager_1.ClusterManager({
+        numWorkers: 2,
+        pingFrequency: 1000, // Check every second
+        pingTimeout: 5000, // 5 seconds for a worker to respond
+        shutdownTimeout: 5000, // 5 seconds for graceful shutdown
+        primaryFn: async () => {
+            setTimeout(() => {
+                logger.info('Primary process shutting down...');
+                manager.shutdown('manual shutdown');
+            }, 10000);
+        },
+        primaryShutdownFn: async (signal) => {
+            logger.info(`Primary process shutting down due to signal: ${signal}`);
+        },
+        workerFn: async () => {
+            // Simulate some work
+            setInterval(() => {
+                logger.info(`Worker ${cluster_1.default.worker?.id} is doing work`);
+            }, 1000);
+        },
+        workerShutdownFn: async (signal) => {
+            logger.info(`Worker ${cluster_1.default.worker?.id} shutting down due to signal: ${signal}`);
+        },
+    });
+    await manager.start();
+}
+async function stuckExample() {
+    let stuckCounter = 0;
+    const manager = new manager_1.ClusterManager({
+        numWorkers: 2,
+        pingFrequency: 1000, // Check every second
+        pingTimeout: 5000, // 5 seconds for a worker to respond
+        shutdownTimeout: 5000, // 5 seconds for graceful shutdown
+        stuckWorkerRespawnFunc: (worker) => {
+            stuckCounter += 1;
+            if (stuckCounter > 3) {
+                logger.info(`Stuck worker detected: ${worker.id}. Not respawning anymore.`);
+                return false; // Stop respawning after 3 stuck workers
+            }
+            logger.info(`Stuck worker detected: ${worker.id}. Respawning...`);
+            return true; // Respawn the worker
+        },
+        primaryFn: async () => {
+            logger.info('Primary process started');
+        },
+        primaryShutdownFn: async (signal) => {
+            logger.info(`Primary process shutting down due to signal: ${signal}`);
+        },
+        workerFn: async () => {
+            logger.info(`Worker ${cluster_1.default.worker?.id} will simulate being stuck`);
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                // Simulate a stuck worker
+            }
+        },
+        workerShutdownFn: async (signal) => {
+            logger.info(`Worker ${cluster_1.default.worker?.id} shutting down due to signal: ${signal}`);
+        },
+    });
+    await manager.start();
+}
+async function killExample() {
+    const manager = new manager_1.ClusterManager({
+        numWorkers: 2,
+        pingFrequency: 1000, // Check every second
+        pingTimeout: 5000, // 5 seconds for a worker to respond
+        shutdownTimeout: 5000, // 5 seconds for graceful shutdown
+        restartMaxTimes: 3, // Restart a worker up to 3 times
+        primaryFn: async () => {
+            logger.info('Primary process started');
+        },
+        primaryShutdownFn: async (signal) => {
+            logger.info(`Primary process shutting down due to signal: ${signal}`);
+        },
+        workerFn: async () => {
+            logger.info(`Worker ${cluster_1.default.worker?.id} started and will crash after 5 seconds`);
+            // eslint-disable-next-line no-constant-condition
+            setTimeout(() => {
+                logger.info(`Killing worker ${cluster_1.default.worker?.id} process`);
+                process.exit(1); // Simulate a worker crash
+            }, 5000); // Kill the worker after 5 seconds
+        },
+        workerShutdownFn: async (signal) => {
+            logger.info(`Worker ${cluster_1.default.worker?.id} shutting down due to signal: ${signal}`);
+        },
+    });
+    await manager.start();
+}
+// to run use: npx ts-node src/cluster/examples.ts [normal|stuck|kill]
+if (require.main === module) {
+    const mode = process.argv[2] || 'normal';
+    let run;
+    if (mode === 'stuck') {
+        run = stuckExample;
+    }
+    else if (mode === 'kill') {
+        run = killExample;
+    }
+    else {
+        run = normalExample;
+    }
+    run().catch((err) => {
+        logger.error(err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"examples.js","sourceRoot":"","sources":["../../src/cluster/examples.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable require-await */\nimport cluster from 'cluster';\nimport { ClusterManager } from './manager';\nimport * as logger from '../logger';\n\nasync function normalExample() {\n  const manager = new ClusterManager({\n    numWorkers: 2,\n    pingFrequency: 1000, // Check every second\n    pingTimeout: 5000, // 5 seconds for a worker to respond\n    shutdownTimeout: 5000, // 5 seconds for graceful shutdown\n    primaryFn: async () => {\n      setTimeout(() => {\n        logger.info('Primary process shutting down...');\n        manager.shutdown('manual shutdown');\n      }, 10000);\n    },\n    primaryShutdownFn: async (signal) => {\n      logger.info(`Primary process shutting down due to signal: ${signal}`);\n    },\n    workerFn: async () => {\n      // Simulate some work\n      setInterval(() => {\n        logger.info(`Worker ${cluster.worker?.id} is doing work`);\n      }, 1000);\n    },\n    workerShutdownFn: async (signal) => {\n      logger.info(`Worker ${cluster.worker?.id} shutting down due to signal: ${signal}`);\n    },\n  });\n  await manager.start();\n}\n\nasync function stuckExample() {\n  let stuckCounter = 0;\n  const manager = new ClusterManager({\n    numWorkers: 2,\n    pingFrequency: 1000, // Check every second\n    pingTimeout: 5000, // 5 seconds for a worker to respond\n    shutdownTimeout: 5000, // 5 seconds for graceful shutdown\n    stuckWorkerRespawnFunc: (worker) => {\n      stuckCounter += 1;\n      if (stuckCounter > 3) {\n        logger.info(`Stuck worker detected: ${worker.id}. Not respawning anymore.`);\n        return false; // Stop respawning after 3 stuck workers\n      }\n      logger.info(`Stuck worker detected: ${worker.id}. Respawning...`);\n      return true; // Respawn the worker\n    },\n    primaryFn: async () => {\n      logger.info('Primary process started');\n    },\n    primaryShutdownFn: async (signal) => {\n      logger.info(`Primary process shutting down due to signal: ${signal}`);\n    },\n    workerFn: async () => {\n      logger.info(`Worker ${cluster.worker?.id} will simulate being stuck`);\n      // eslint-disable-next-line no-constant-condition\n      while (true) {\n        // Simulate a stuck worker\n      }\n    },\n    workerShutdownFn: async (signal) => {\n      logger.info(`Worker ${cluster.worker?.id} shutting down due to signal: ${signal}`);\n    },\n  });\n  await manager.start();\n}\n\nasync function killExample() {\n  const manager = new ClusterManager({\n    numWorkers: 2,\n    pingFrequency: 1000, // Check every second\n    pingTimeout: 5000, // 5 seconds for a worker to respond\n    shutdownTimeout: 5000, // 5 seconds for graceful shutdown\n    restartMaxTimes: 3, // Restart a worker up to 3 times\n    primaryFn: async () => {\n      logger.info('Primary process started');\n    },\n    primaryShutdownFn: async (signal) => {\n      logger.info(`Primary process shutting down due to signal: ${signal}`);\n    },\n    workerFn: async () => {\n      logger.info(`Worker ${cluster.worker?.id} started and will crash after 5 seconds`);\n      // eslint-disable-next-line no-constant-condition\n      setTimeout(() => {\n        logger.info(`Killing worker ${cluster.worker?.id} process`);\n        process.exit(1); // Simulate a worker crash\n      }, 5000); // Kill the worker after 5 seconds\n    },\n    workerShutdownFn: async (signal) => {\n      logger.info(`Worker ${cluster.worker?.id} shutting down due to signal: ${signal}`);\n    },\n  });\n  await manager.start();\n}\n\n// to run use: npx ts-node src/cluster/examples.ts [normal|stuck|kill]\nif (require.main === module) {\n  const mode = process.argv[2] || 'normal';\n  let run;\n  if (mode === 'stuck') {\n    run = stuckExample;\n  } else if (mode === 'kill') {\n    run = killExample;\n  } else {\n    run = normalExample;\n  }\n  run().catch((err) => {\n    logger.error(err);\n    process.exit(1);\n  });\n}\n"]}

package/build/cluster/index.d.ts

@@ -0,0 +1,4 @@
+export { ClusterManager, ClusterManagerEmitter } from './manager';
+export type { ClusterManagerOptions, ClusterManagerEvents, WorkerState, PingMessage, PongMessage, ShutdownMessage, IPCMessage, } from './types';
+export { validateAndDefaultOptions, delay, timeout, safeExecute } from './utils';
+//# sourceMappingURL=index.d.ts.map

package/build/cluster/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cluster/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAClE,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,WAAW,EACX,WAAW,EACX,WAAW,EACX,eAAe,EACf,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,yBAAyB,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/build/cluster/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeExecute = exports.timeout = exports.delay = exports.validateAndDefaultOptions = exports.ClusterManager = void 0;
+var manager_1 = require("./manager");
+Object.defineProperty(exports, "ClusterManager", { enumerable: true, get: function () { return manager_1.ClusterManager; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "validateAndDefaultOptions", { enumerable: true, get: function () { return utils_1.validateAndDefaultOptions; } });
+Object.defineProperty(exports, "delay", { enumerable: true, get: function () { return utils_1.delay; } });
+Object.defineProperty(exports, "timeout", { enumerable: true, get: function () { return utils_1.timeout; } });
+Object.defineProperty(exports, "safeExecute", { enumerable: true, get: function () { return utils_1.safeExecute; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2x1c3Rlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxQ0FBa0U7QUFBekQseUdBQUEsY0FBYyxPQUFBO0FBVXZCLGlDQUFpRjtBQUF4RSxrSEFBQSx5QkFBeUIsT0FBQTtBQUFFLDhGQUFBLEtBQUssT0FBQTtBQUFFLGdHQUFBLE9BQU8sT0FBQTtBQUFFLG9HQUFBLFdBQVcsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IENsdXN0ZXJNYW5hZ2VyLCBDbHVzdGVyTWFuYWdlckVtaXR0ZXIgfSBmcm9tICcuL21hbmFnZXInO1xuZXhwb3J0IHR5cGUge1xuICBDbHVzdGVyTWFuYWdlck9wdGlvbnMsXG4gIENsdXN0ZXJNYW5hZ2VyRXZlbnRzLFxuICBXb3JrZXJTdGF0ZSxcbiAgUGluZ01lc3NhZ2UsXG4gIFBvbmdNZXNzYWdlLFxuICBTaHV0ZG93bk1lc3NhZ2UsXG4gIElQQ01lc3NhZ2UsXG59IGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0IHsgdmFsaWRhdGVBbmREZWZhdWx0T3B0aW9ucywgZGVsYXksIHRpbWVvdXQsIHNhZmVFeGVjdXRlIH0gZnJvbSAnLi91dGlscyc7XG4iXX0=

package/build/cluster/manager.d.ts

@@ -0,0 +1,141 @@
+import { EventEmitter } from 'events';
+import { ClusterManagerOptions, ClusterManagerEvents } from './types';
+/**
+ * ClusterManager - A cluster lifecycle management system
+ *
+ * The manager supports the following features:
+ * - Graceful shutdown with configurable timeout
+ * - Worker health monitoring with ping/pong mechanism
+ * - Automatic worker restart with configurable limits
+ * - Signal handling for shutdown triggers
+ * - Flexible primary and worker function handlers
+ */
+export declare class ClusterManager extends EventEmitter {
+    private readonly options;
+    private readonly workers;
+    private started;
+    private isShuttingDown;
+    private shutdownPromise;
+    private healthCheckInterval;
+    private signalHandlers;
+    constructor(options?: ClusterManagerOptions);
+    /**
+     * Starts the cluster manager
+     * In primary process: starts workers and health monitoring
+     * In worker process: executes worker function
+     */
+    start(): Promise<void>;
+    /**
+     * Initiates graceful shutdown of the cluster
+     */
+    shutdown(signal?: string): Promise<void>;
+    /**
+     * Sets up signal handlers for graceful shutdown
+     */
+    private setupSignalHandlers;
+    /**
+     * Removes signal handlers
+     */
+    private removeSignalHandlers;
+    /**
+     * Starts the primary process
+     */
+    private startPrimary;
+    /**
+     * Starts a worker process
+     */
+    private startWorker;
+    /**
+     * Sets up cluster event handlers for the primary process
+     */
+    private setupClusterEventHandlers;
+    /**
+     * Sets up IPC message handlers for worker processes
+     */
+    private setupWorkerMessageHandlers;
+    /**
+     * Spawns a new worker and sets up its state
+     */
+    private spawnWorker;
+    /**
+     * Handles messages from workers
+     */
+    private handleWorkerMessage;
+    /**
+     * Handles ping messages in worker processes
+     */
+    private handleWorkerPing;
+    /**
+     * Starts health monitoring for all workers
+     */
+    private startHealthMonitoring;
+    /**
+     * Stops health monitoring
+     */
+    private stopHealthMonitoring;
+    /**
+     * Performs health check on all workers
+     */
+    private performHealthCheck;
+    /**
+     * Sends a ping message to a worker
+     */
+    private sendPingToWorker;
+    /**
+     * Handles a stuck worker
+     */
+    private handleStuckWorker;
+    /**
+     * Handles worker exit events
+     */
+    private handleWorkerExit;
+    /**
+     * Handles unexpected worker exits with restart logic
+     */
+    private handleUnexpectedWorkerExit;
+    /**
+     * Shuts down the primary process
+     */
+    private shutdownPrimary;
+    /**
+     * Shuts down all workers gracefully
+     */
+    private shutdownAllWorkers;
+    /**
+     * Waits for all workers to exit
+     */
+    private waitForAllWorkersToExit;
+    /**
+     * Force kills all remaining workers
+     */
+    private forceKillAllWorkers;
+    /**
+     * Shuts down a worker process
+     */
+    private shutdownWorker;
+    /**
+     * Gets the current number of active workers
+     */
+    getWorkerCount(): number;
+    /**
+     * Gets information about all workers
+     */
+    getWorkerInfo(): Array<{
+        id: number;
+        pid: number;
+        restartCount: number;
+    }>;
+    /**
+     * Checks if the cluster is currently started
+     */
+    isStarted(): boolean;
+    /**
+     * Checks if the cluster is currently shutting down
+     */
+    isShutdown(): boolean;
+}
+export interface ClusterManagerEmitter {
+    on<K extends keyof ClusterManagerEvents>(event: K, listener: ClusterManagerEvents[K]): this;
+    emit<K extends keyof ClusterManagerEvents>(event: K, ...args: Parameters<ClusterManagerEvents[K]>): boolean;
+}
+//# sourceMappingURL=manager.d.ts.map

package/build/cluster/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/cluster/manager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EAMrB,MAAM,SAAS,CAAC;AAGjB;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,YAAY;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAE1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAE1D,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,eAAe,CAA8B;IAErD,OAAO,CAAC,mBAAmB,CAA+B;IAE1D,OAAO,CAAC,cAAc,CAAyC;gBAEnD,OAAO,GAAE,qBAA0B;IAM/C;;;;OAIG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IASnC;;OAEG;IACI,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB/C;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAO5B;;OAEG;YACW,YAAY;IAoB1B;;OAEG;YACW,WAAW;IAUzB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAWjC;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAgBlC;;OAEG;IACH,OAAO,CAAC,WAAW;IAoBnB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAM7B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAO5B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAkB1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAkBxB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA4BzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAsBlC;;OAEG;YACW,eAAe;IAqB7B;;OAEG;YACW,kBAAkB;IAwChC;;OAEG;YACW,uBAAuB;IAOrC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;OAEG;YACW,cAAc;IAqB5B;;OAEG;IACI,cAAc,IAAI,MAAM;IAI/B;;OAEG;IACI,aAAa,IAAI,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAQhF;;OAEG;IACI,SAAS,IAAI,OAAO;IAI3B;;OAEG;IACI,UAAU,IAAI,OAAO;CAG7B;AAGD,MAAM,WAAW,qBAAqB;IACpC,EAAE,CAAC,CAAC,SAAS,MAAM,oBAAoB,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC5F,IAAI,CAAC,CAAC,SAAS,MAAM,oBAAoB,EACvC,KAAK,EAAE,CAAC,EACR,GAAG,IAAI,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,GAC3C,OAAO,CAAC;CACZ"}

package/build/cluster/manager.js

@@ -0,0 +1,440 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterManager = void 0;
+const events_1 = require("events");
+const logger = __importStar(require("../logger"));
+const utils_1 = require("./utils");
+/**
+ * ClusterManager - A cluster lifecycle management system
+ *
+ * The manager supports the following features:
+ * - Graceful shutdown with configurable timeout
+ * - Worker health monitoring with ping/pong mechanism
+ * - Automatic worker restart with configurable limits
+ * - Signal handling for shutdown triggers
+ * - Flexible primary and worker function handlers
+ */
+class ClusterManager extends events_1.EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.workers = new Map();
+        this.started = false;
+        this.isShuttingDown = false;
+        this.shutdownPromise = null;
+        this.healthCheckInterval = null;
+        this.signalHandlers = new Map();
+        this.options = (0, utils_1.validateAndDefaultOptions)(options);
+        this.setupSignalHandlers();
+    }
+    /**
+     * Starts the cluster manager
+     * In primary process: starts workers and health monitoring
+     * In worker process: executes worker function
+     */
+    async start() {
+        if (this.options.cluster.isPrimary) {
+            await this.startPrimary();
+        }
+        else {
+            await this.startWorker();
+        }
+        this.started = true;
+    }
+    /**
+     * Initiates graceful shutdown of the cluster
+     */
+    shutdown(signal) {
+        if (!this.started) {
+            return Promise.resolve();
+        }
+        if (this.shutdownPromise) {
+            return this.shutdownPromise;
+        }
+        this.isShuttingDown = true;
+        this.emit('shutdown:started', signal);
+        if (this.options.cluster.isPrimary) {
+            this.shutdownPromise = this.shutdownPrimary(signal);
+        }
+        else {
+            this.shutdownPromise = this.shutdownWorker(signal);
+        }
+        return this.shutdownPromise;
+    }
+    /**
+     * Sets up signal handlers for graceful shutdown
+     */
+    setupSignalHandlers() {
+        this.options.shutdownSignals.forEach((signal) => {
+            const handler = () => {
+                this.shutdown(signal);
+            };
+            this.signalHandlers.set(signal, handler);
+            process.on(signal, handler);
+        });
+    }
+    /**
+     * Removes signal handlers
+     */
+    removeSignalHandlers() {
+        Array.from(this.signalHandlers.entries()).forEach(([signal, handler]) => {
+            process.removeListener(signal, handler);
+        });
+        this.signalHandlers.clear();
+    }
+    /**
+     * Starts the primary process
+     */
+    async startPrimary() {
+        logger.info(`Primary process (pid: ${process.pid}) starting with ${this.options.numWorkers} workers`);
+        // Execute primary initialization function, any error will stop the cluster from starting
+        await this.options.primaryFn();
+        // Set up cluster event handlers
+        this.setupClusterEventHandlers();
+        // Spawn initial workers
+        for (let i = 0; i < this.options.numWorkers; i += 1) {
+            this.spawnWorker();
+        }
+        // Start health monitoring
+        this.startHealthMonitoring();
+    }
+    /**
+     * Starts a worker process
+     */
+    async startWorker() {
+        logger.info(`Worker ${this.options.cluster.worker?.id} (pid: ${process.pid}) starting`);
+        // Set up IPC message handlers
+        this.setupWorkerMessageHandlers();
+        // Execute worker initialization function, any error will be propagated
+        await this.options.workerFn();
+    }
+    /**
+     * Sets up cluster event handlers for the primary process
+     */
+    setupClusterEventHandlers() {
+        this.options.cluster.on('exit', (worker, code, signal) => {
+            this.handleWorkerExit(worker, code, signal);
+        });
+        this.options.cluster.on('online', (worker) => {
+            logger.info(`Worker ${worker.id} (pid: ${worker.process.pid}) is online`);
+            this.emit('worker:started', worker);
+        });
+    }
+    /**
+     * Sets up IPC message handlers for worker processes
+     */
+    setupWorkerMessageHandlers() {
+        process.on('message', (message) => {
+            switch (message.type) {
+                case 'ping':
+                    this.handleWorkerPing(message);
+                    break;
+                case 'shutdown':
+                    this.shutdown(message.signal);
+                    break;
+                default:
+                    logger.warn(`ignoring unknown message type in worker ${process.pid}: ${message.type}`);
+                    break;
+            }
+        });
+    }
+    /**
+     * Spawns a new worker and sets up its state
+     */
+    spawnWorker() {
+        const worker = this.options.cluster.fork();
+        const workerState = {
+            worker,
+            restartCount: 0,
+            lastPing: Date.now(),
+            pendingPing: false,
+            isShuttingDown: false,
+        };
+        this.workers.set(worker.id, workerState);
+        // Set up worker message handler
+        worker.on('message', (message) => {
+            this.handleWorkerMessage(worker, message);
+        });
+        return worker;
+    }
+    /**
+     * Handles messages from workers
+     */
+    handleWorkerMessage(worker, message) {
+        const workerState = this.workers.get(worker.id);
+        if (!workerState)
+            return;
+        switch (message.type) {
+            case 'pong':
+                workerState.lastPing = Date.now();
+                workerState.pendingPing = false;
+                break;
+            default:
+                logger.warn(`Received unknown message type from worker ${worker.process.pid}: ${message.type}`);
+                break;
+        }
+    }
+    /**
+     * Handles ping messages in worker processes
+     */
+    handleWorkerPing(message) {
+        const pongMessage = {
+            type: 'pong',
+            timestamp: message.timestamp,
+        };
+        if (process.send) {
+            process.send(pongMessage);
+        }
+    }
+    /**
+     * Starts health monitoring for all workers
+     */
+    startHealthMonitoring() {
+        this.healthCheckInterval = setInterval(() => {
+            this.performHealthCheck();
+        }, this.options.pingFrequency);
+    }
+    /**
+     * Stops health monitoring
+     */
+    stopHealthMonitoring() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+    }
+    /**
+     * Performs health check on all workers
+     */
+    performHealthCheck() {
+        if (this.isShuttingDown)
+            return;
+        Array.from(this.workers.values())
+            .filter((workerState) => !workerState.isShuttingDown)
+            .forEach((workerState) => {
+            const timeSinceLastPing = Date.now() - workerState.lastPing;
+            if (workerState.pendingPing && timeSinceLastPing > this.options.pingTimeout) {
+                // Worker is stuck, handle it
+                this.handleStuckWorker(workerState);
+            }
+            else if (!workerState.pendingPing) {
+                // Send ping to worker
+                this.sendPingToWorker(workerState);
+            }
+        });
+    }
+    /**
+     * Sends a ping message to a worker
+     */
+    sendPingToWorker(workerState) {
+        const pingMessage = {
+            type: 'ping',
+            timestamp: Date.now(),
+        };
+        workerState.pendingPing = true;
+        try {
+            workerState.worker.send(pingMessage);
+        }
+        catch (error) {
+            logger.error(`Failed to send ping to worker ${workerState.worker.process.pid}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Handles a stuck worker
+     */
+    handleStuckWorker(workerState) {
+        logger.error(`Worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid}) is stuck, killing it`);
+        this.emit('worker:stuck', workerState.worker);
+        // Remove worker state
+        this.workers.delete(workerState.worker.id);
+        // Kill the worker
+        workerState.worker.kill('SIGKILL');
+        // Determine if we should spawn a replacement
+        const shouldSpawn = this.options.stuckWorkerRespawnFunc(workerState.worker);
+        if (shouldSpawn && !this.isShuttingDown) {
+            logger.info(`Spawning replacement worker for stuck worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid})`);
+            this.spawnWorker();
+        }
+        else {
+            logger.error(`Triggering cluster shutdown due to stuck worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid})`);
+            this.shutdown('STUCK_WORKER');
+        }
+    }
+    /**
+     * Handles worker exit events
+     */
+    handleWorkerExit(worker, code, signal) {
+        logger.info(`Worker ${worker.id} (pid: ${worker.process.pid}) died with code ${code} and signal ${signal}`);
+        this.emit('worker:died', worker, code, signal);
+        const workerState = this.workers.get(worker.id);
+        if (!workerState)
+            return;
+        this.workers.delete(worker.id);
+        // If we're shutting down or worker was killed intentionally, don't restart
+        if (this.isShuttingDown || workerState.isShuttingDown) {
+            return;
+        }
+        // Handle unexpected exit
+        this.handleUnexpectedWorkerExit(workerState);
+    }
+    /**
+     * Handles unexpected worker exits with restart logic
+     */
+    handleUnexpectedWorkerExit(workerState) {
+        const restartCount = workerState.restartCount + 1;
+        if (restartCount <= this.options.restartMaxTimes) {
+            logger.error(`Restarting worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid}) (attempt ${restartCount}/${this.options.restartMaxTimes})`);
+            const newWorker = this.spawnWorker();
+            const newWorkerState = this.workers.get(newWorker.id);
+            if (newWorkerState) {
+                newWorkerState.restartCount = restartCount;
+            }
+            this.emit('worker:restarted', newWorker, workerState.restartCount);
+        }
+        else {
+            logger.error(`Restart limit (${this.options.restartMaxTimes}) exceeded for worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid}), shutting down cluster`);
+            this.emit('worker:restart-limit-exceeded', workerState.worker, workerState.restartCount);
+            this.shutdown('RESTART_LIMIT_EXCEEDED');
+        }
+    }
+    /**
+     * Shuts down the primary process
+     */
+    async shutdownPrimary(signal) {
+        logger.info(`Primary process (pid: ${process.pid}) shutting down (signal: ${signal ?? 'manual'})`);
+        this.stopHealthMonitoring();
+        this.removeSignalHandlers();
+        // Shutdown all workers
+        await this.shutdownAllWorkers(signal);
+        // Execute primary shutdown function
+        await (0, utils_1.safeExecute)(() => this.options.primaryShutdownFn(signal), 'Error in primary shutdown function');
+        logger.info(`Primary process (pid: ${process.pid}) shutdown completed`);
+        this.emit('shutdown:completed');
+    }
+    /**
+     * Shuts down all workers gracefully
+     */
+    async shutdownAllWorkers(signal) {
+        if (this.workers.size === 0)
+            return;
+        logger.info(`Shutting down ${this.workers.size} workers...`);
+        // Mark all workers as shutting down and send shutdown message
+        Array.from(this.workers.values()).forEach((workerState) => {
+            workerState.isShuttingDown = true;
+            // Only send shutdown message if worker is still connected
+            if (!workerState.worker.isDead() && workerState.worker.process.connected) {
+                const shutdownMessage = {
+                    type: 'shutdown',
+                    signal,
+                };
+                try {
+                    workerState.worker.send(shutdownMessage);
+                }
+                catch (error) {
+                    // Worker IPC channel is already closed, which is fine
+                    logger.debug(`Failed to send shutdown message to worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid}): ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        });
+        // Wait for workers to exit gracefully or timeout
+        try {
+            await (0, utils_1.timeout)(this.waitForAllWorkersToExit(), this.options.shutdownTimeout, 'Worker shutdown timeout');
+        }
+        catch (error) {
+            logger.error('Graceful shutdown for workers timed out, forcing shutdown');
+            this.forceKillAllWorkers();
+        }
+    }
+    /**
+     * Waits for all workers to exit
+     */
+    async waitForAllWorkersToExit() {
+        while (this.workers.size > 0) {
+            // eslint-disable-next-line no-await-in-loop
+            await (0, utils_1.delay)(100);
+        }
+    }
+    /**
+     * Force kills all remaining workers
+     */
+    forceKillAllWorkers() {
+        Array.from(this.workers.values()).forEach((workerState) => {
+            logger.error(`Force killing worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid})`);
+            workerState.worker.kill('SIGKILL');
+        });
+        this.workers.clear();
+    }
+    /**
+     * Shuts down a worker process
+     */
+    async shutdownWorker(signal) {
+        logger.info(`Worker ${this.options.cluster.worker?.id} (pid: ${process.pid}) shutting down (signal: ${signal ?? 'manual'})`);
+        this.removeSignalHandlers();
+        // Execute worker shutdown function
+        await (0, utils_1.safeExecute)(() => this.options.workerShutdownFn(signal), `Error in worker ${this.options.cluster.worker?.id} (pid: ${process.pid}) shutdown function`);
+        logger.info(`Worker ${this.options.cluster.worker?.id} (pid: ${process.pid}) shutdown completed`);
+        process.exit(0);
+    }
+    /**
+     * Gets the current number of active workers
+     */
+    getWorkerCount() {
+        return this.workers.size;
+    }
+    /**
+     * Gets information about all workers
+     */
+    getWorkerInfo() {
+        return Array.from(this.workers.values()).map((state) => ({
+            id: state.worker.id,
+            pid: state.worker.process.pid ?? -1,
+            restartCount: state.restartCount,
+        }));
+    }
+    /**
+     * Checks if the cluster is currently started
+     */
+    isStarted() {
+        return this.started;
+    }
+    /**
+     * Checks if the cluster is currently shutting down
+     */
+    isShutdown() {
+        return this.isShuttingDown;
+    }
+}
+exports.ClusterManager = ClusterManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../src/cluster/manager.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable class-methods-use-this */\n/* eslint-disable no-param-reassign */\nimport { Worker } from 'cluster';\nimport { EventEmitter } from 'events';\nimport * as logger from '../logger';\nimport {\n  ClusterManagerOptions,\n  ClusterManagerEvents,\n  WorkerState,\n  IPCMessage,\n  PingMessage,\n  PongMessage,\n  ShutdownMessage,\n} from './types';\nimport { delay, timeout, safeExecute, validateAndDefaultOptions } from './utils';\n\n/**\n * ClusterManager - A cluster lifecycle management system\n *\n * The manager supports the following features:\n * - Graceful shutdown with configurable timeout\n * - Worker health monitoring with ping/pong mechanism\n * - Automatic worker restart with configurable limits\n * - Signal handling for shutdown triggers\n * - Flexible primary and worker function handlers\n */\nexport class ClusterManager extends EventEmitter {\n  private readonly options: Required<ClusterManagerOptions>;\n\n  private readonly workers = new Map<number, WorkerState>();\n\n  private started = false;\n\n  private isShuttingDown = false;\n\n  private shutdownPromise: Promise<void> | null = null;\n\n  private healthCheckInterval: NodeJS.Timeout | null = null;\n\n  private signalHandlers = new Map<NodeJS.Signals, () => void>();\n\n  constructor(options: ClusterManagerOptions = {}) {\n    super();\n    this.options = validateAndDefaultOptions(options);\n    this.setupSignalHandlers();\n  }\n\n  /**\n   * Starts the cluster manager\n   * In primary process: starts workers and health monitoring\n   * In worker process: executes worker function\n   */\n  public async start(): Promise<void> {\n    if (this.options.cluster.isPrimary) {\n      await this.startPrimary();\n    } else {\n      await this.startWorker();\n    }\n    this.started = true;\n  }\n\n  /**\n   * Initiates graceful shutdown of the cluster\n   */\n  public shutdown(signal?: string): Promise<void> {\n    if (!this.started) {\n      return Promise.resolve();\n    }\n\n    if (this.shutdownPromise) {\n      return this.shutdownPromise;\n    }\n\n    this.isShuttingDown = true;\n    this.emit('shutdown:started', signal);\n\n    if (this.options.cluster.isPrimary) {\n      this.shutdownPromise = this.shutdownPrimary(signal);\n    } else {\n      this.shutdownPromise = this.shutdownWorker(signal);\n    }\n\n    return this.shutdownPromise;\n  }\n\n  /**\n   * Sets up signal handlers for graceful shutdown\n   */\n  private setupSignalHandlers(): void {\n    this.options.shutdownSignals.forEach((signal) => {\n      const handler = () => {\n        this.shutdown(signal);\n      };\n      this.signalHandlers.set(signal, handler);\n      process.on(signal, handler);\n    });\n  }\n\n  /**\n   * Removes signal handlers\n   */\n  private removeSignalHandlers(): void {\n    Array.from(this.signalHandlers.entries()).forEach(([signal, handler]) => {\n      process.removeListener(signal, handler);\n    });\n    this.signalHandlers.clear();\n  }\n\n  /**\n   * Starts the primary process\n   */\n  private async startPrimary(): Promise<void> {\n    logger.info(\n      `Primary process (pid: ${process.pid}) starting with ${this.options.numWorkers} workers`,\n    );\n\n    // Execute primary initialization function, any error will stop the cluster from starting\n    await this.options.primaryFn();\n\n    // Set up cluster event handlers\n    this.setupClusterEventHandlers();\n\n    // Spawn initial workers\n    for (let i = 0; i < this.options.numWorkers; i += 1) {\n      this.spawnWorker();\n    }\n\n    // Start health monitoring\n    this.startHealthMonitoring();\n  }\n\n  /**\n   * Starts a worker process\n   */\n  private async startWorker(): Promise<void> {\n    logger.info(`Worker ${this.options.cluster.worker?.id} (pid: ${process.pid}) starting`);\n\n    // Set up IPC message handlers\n    this.setupWorkerMessageHandlers();\n\n    // Execute worker initialization function, any error will be propagated\n    await this.options.workerFn();\n  }\n\n  /**\n   * Sets up cluster event handlers for the primary process\n   */\n  private setupClusterEventHandlers(): void {\n    this.options.cluster.on('exit', (worker: Worker, code: number, signal: string) => {\n      this.handleWorkerExit(worker, code, signal);\n    });\n\n    this.options.cluster.on('online', (worker: Worker) => {\n      logger.info(`Worker ${worker.id} (pid: ${worker.process.pid}) is online`);\n      this.emit('worker:started', worker);\n    });\n  }\n\n  /**\n   * Sets up IPC message handlers for worker processes\n   */\n  private setupWorkerMessageHandlers(): void {\n    process.on('message', (message: IPCMessage) => {\n      switch (message.type) {\n        case 'ping':\n          this.handleWorkerPing(message);\n          break;\n        case 'shutdown':\n          this.shutdown(message.signal);\n          break;\n        default:\n          logger.warn(`ignoring unknown message type in worker ${process.pid}: ${message.type}`);\n          break;\n      }\n    });\n  }\n\n  /**\n   * Spawns a new worker and sets up its state\n   */\n  private spawnWorker(): Worker {\n    const worker = this.options.cluster.fork();\n    const workerState: WorkerState = {\n      worker,\n      restartCount: 0,\n      lastPing: Date.now(),\n      pendingPing: false,\n      isShuttingDown: false,\n    };\n\n    this.workers.set(worker.id, workerState);\n\n    // Set up worker message handler\n    worker.on('message', (message: IPCMessage) => {\n      this.handleWorkerMessage(worker, message);\n    });\n\n    return worker;\n  }\n\n  /**\n   * Handles messages from workers\n   */\n  private handleWorkerMessage(worker: Worker, message: IPCMessage): void {\n    const workerState = this.workers.get(worker.id);\n    if (!workerState) return;\n\n    switch (message.type) {\n      case 'pong':\n        workerState.lastPing = Date.now();\n        workerState.pendingPing = false;\n        break;\n      default:\n        logger.warn(\n          `Received unknown message type from worker ${worker.process.pid}: ${message.type}`,\n        );\n        break;\n    }\n  }\n\n  /**\n   * Handles ping messages in worker processes\n   */\n  private handleWorkerPing(message: PingMessage): void {\n    const pongMessage: PongMessage = {\n      type: 'pong',\n      timestamp: message.timestamp,\n    };\n\n    if (process.send) {\n      process.send(pongMessage);\n    }\n  }\n\n  /**\n   * Starts health monitoring for all workers\n   */\n  private startHealthMonitoring(): void {\n    this.healthCheckInterval = setInterval(() => {\n      this.performHealthCheck();\n    }, this.options.pingFrequency);\n  }\n\n  /**\n   * Stops health monitoring\n   */\n  private stopHealthMonitoring(): void {\n    if (this.healthCheckInterval) {\n      clearInterval(this.healthCheckInterval);\n      this.healthCheckInterval = null;\n    }\n  }\n\n  /**\n   * Performs health check on all workers\n   */\n  private performHealthCheck(): void {\n    if (this.isShuttingDown) return;\n\n    Array.from(this.workers.values())\n      .filter((workerState) => !workerState.isShuttingDown)\n      .forEach((workerState) => {\n        const timeSinceLastPing = Date.now() - workerState.lastPing;\n\n        if (workerState.pendingPing && timeSinceLastPing > this.options.pingTimeout) {\n          // Worker is stuck, handle it\n          this.handleStuckWorker(workerState);\n        } else if (!workerState.pendingPing) {\n          // Send ping to worker\n          this.sendPingToWorker(workerState);\n        }\n      });\n  }\n\n  /**\n   * Sends a ping message to a worker\n   */\n  private sendPingToWorker(workerState: WorkerState): void {\n    const pingMessage: PingMessage = {\n      type: 'ping',\n      timestamp: Date.now(),\n    };\n\n    workerState.pendingPing = true;\n    try {\n      workerState.worker.send(pingMessage);\n    } catch (error) {\n      logger.error(\n        `Failed to send ping to worker ${workerState.worker.process.pid}: ${\n          error instanceof Error ? error.message : String(error)\n        }`,\n      );\n    }\n  }\n\n  /**\n   * Handles a stuck worker\n   */\n  private handleStuckWorker(workerState: WorkerState): void {\n    logger.error(\n      `Worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid}) is stuck, killing it`,\n    );\n    this.emit('worker:stuck', workerState.worker);\n\n    // Remove worker state\n    this.workers.delete(workerState.worker.id);\n\n    // Kill the worker\n    workerState.worker.kill('SIGKILL');\n\n    // Determine if we should spawn a replacement\n    const shouldSpawn = this.options.stuckWorkerRespawnFunc(workerState.worker);\n\n    if (shouldSpawn && !this.isShuttingDown) {\n      logger.info(\n        `Spawning replacement worker for stuck worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid})`,\n      );\n      this.spawnWorker();\n    } else {\n      logger.error(\n        `Triggering cluster shutdown due to stuck worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid})`,\n      );\n      this.shutdown('STUCK_WORKER');\n    }\n  }\n\n  /**\n   * Handles worker exit events\n   */\n  private handleWorkerExit(worker: Worker, code: number | null, signal: string | null): void {\n    logger.info(\n      `Worker ${worker.id} (pid: ${worker.process.pid}) died with code ${code} and signal ${signal}`,\n    );\n    this.emit('worker:died', worker, code, signal);\n\n    const workerState = this.workers.get(worker.id);\n    if (!workerState) return;\n\n    this.workers.delete(worker.id);\n\n    // If we're shutting down or worker was killed intentionally, don't restart\n    if (this.isShuttingDown || workerState.isShuttingDown) {\n      return;\n    }\n\n    // Handle unexpected exit\n    this.handleUnexpectedWorkerExit(workerState);\n  }\n\n  /**\n   * Handles unexpected worker exits with restart logic\n   */\n  private handleUnexpectedWorkerExit(workerState: WorkerState): void {\n    const restartCount = workerState.restartCount + 1;\n\n    if (restartCount <= this.options.restartMaxTimes) {\n      logger.error(\n        `Restarting worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid}) (attempt ${restartCount}/${this.options.restartMaxTimes})`,\n      );\n      const newWorker = this.spawnWorker();\n      const newWorkerState = this.workers.get(newWorker.id);\n      if (newWorkerState) {\n        newWorkerState.restartCount = restartCount;\n      }\n      this.emit('worker:restarted', newWorker, workerState.restartCount);\n    } else {\n      logger.error(\n        `Restart limit (${this.options.restartMaxTimes}) exceeded for worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid}), shutting down cluster`,\n      );\n      this.emit('worker:restart-limit-exceeded', workerState.worker, workerState.restartCount);\n      this.shutdown('RESTART_LIMIT_EXCEEDED');\n    }\n  }\n\n  /**\n   * Shuts down the primary process\n   */\n  private async shutdownPrimary(signal?: string): Promise<void> {\n    logger.info(\n      `Primary process (pid: ${process.pid}) shutting down (signal: ${signal ?? 'manual'})`,\n    );\n\n    this.stopHealthMonitoring();\n    this.removeSignalHandlers();\n\n    // Shutdown all workers\n    await this.shutdownAllWorkers(signal);\n\n    // Execute primary shutdown function\n    await safeExecute(\n      () => this.options.primaryShutdownFn(signal),\n      'Error in primary shutdown function',\n    );\n\n    logger.info(`Primary process (pid: ${process.pid}) shutdown completed`);\n    this.emit('shutdown:completed');\n  }\n\n  /**\n   * Shuts down all workers gracefully\n   */\n  private async shutdownAllWorkers(signal?: string): Promise<void> {\n    if (this.workers.size === 0) return;\n\n    logger.info(`Shutting down ${this.workers.size} workers...`);\n\n    // Mark all workers as shutting down and send shutdown message\n    Array.from(this.workers.values()).forEach((workerState) => {\n      workerState.isShuttingDown = true;\n      // Only send shutdown message if worker is still connected\n      if (!workerState.worker.isDead() && workerState.worker.process.connected) {\n        const shutdownMessage: ShutdownMessage = {\n          type: 'shutdown',\n          signal,\n        };\n        try {\n          workerState.worker.send(shutdownMessage);\n        } catch (error) {\n          // Worker IPC channel is already closed, which is fine\n          logger.debug(\n            `Failed to send shutdown message to worker ${workerState.worker.id} (pid: ${\n              workerState.worker.process.pid\n            }): ${error instanceof Error ? error.message : String(error)}`,\n          );\n        }\n      }\n    });\n\n    // Wait for workers to exit gracefully or timeout\n    try {\n      await timeout(\n        this.waitForAllWorkersToExit(),\n        this.options.shutdownTimeout,\n        'Worker shutdown timeout',\n      );\n    } catch (error) {\n      logger.error('Graceful shutdown for workers timed out, forcing shutdown');\n      this.forceKillAllWorkers();\n    }\n  }\n\n  /**\n   * Waits for all workers to exit\n   */\n  private async waitForAllWorkersToExit(): Promise<void> {\n    while (this.workers.size > 0) {\n      // eslint-disable-next-line no-await-in-loop\n      await delay(100);\n    }\n  }\n\n  /**\n   * Force kills all remaining workers\n   */\n  private forceKillAllWorkers(): void {\n    Array.from(this.workers.values()).forEach((workerState) => {\n      logger.error(\n        `Force killing worker ${workerState.worker.id} (pid: ${workerState.worker.process.pid})`,\n      );\n      workerState.worker.kill('SIGKILL');\n    });\n    this.workers.clear();\n  }\n\n  /**\n   * Shuts down a worker process\n   */\n  private async shutdownWorker(signal?: string): Promise<void> {\n    logger.info(\n      `Worker ${this.options.cluster.worker?.id} (pid: ${process.pid}) shutting down (signal: ${\n        signal ?? 'manual'\n      })`,\n    );\n\n    this.removeSignalHandlers();\n\n    // Execute worker shutdown function\n    await safeExecute(\n      () => this.options.workerShutdownFn(signal),\n      `Error in worker ${this.options.cluster.worker?.id} (pid: ${process.pid}) shutdown function`,\n    );\n\n    logger.info(\n      `Worker ${this.options.cluster.worker?.id} (pid: ${process.pid}) shutdown completed`,\n    );\n    process.exit(0);\n  }\n\n  /**\n   * Gets the current number of active workers\n   */\n  public getWorkerCount(): number {\n    return this.workers.size;\n  }\n\n  /**\n   * Gets information about all workers\n   */\n  public getWorkerInfo(): Array<{ id: number; pid: number; restartCount: number }> {\n    return Array.from(this.workers.values()).map((state) => ({\n      id: state.worker.id,\n      pid: state.worker.process.pid ?? -1,\n      restartCount: state.restartCount,\n    }));\n  }\n\n  /**\n   * Checks if the cluster is currently started\n   */\n  public isStarted(): boolean {\n    return this.started;\n  }\n\n  /**\n   * Checks if the cluster is currently shutting down\n   */\n  public isShutdown(): boolean {\n    return this.isShuttingDown;\n  }\n}\n\n// Type-safe event emitter interface\nexport interface ClusterManagerEmitter {\n  on<K extends keyof ClusterManagerEvents>(event: K, listener: ClusterManagerEvents[K]): this;\n  emit<K extends keyof ClusterManagerEvents>(\n    event: K,\n    ...args: Parameters<ClusterManagerEvents[K]>\n  ): boolean;\n}\n"]}

package/build/cluster/types.d.ts

@@ -0,0 +1,77 @@
+import { Worker } from 'cluster';
+/**
+ * Configuration options for ClusterManager
+ */
+export interface ClusterManagerOptions {
+    cluster?: Cluster;
+    /** Function to execute in the primary process during start */
+    primaryFn?: () => void | Promise<void>;
+    /** Function to execute in the primary process after all workers have been shutdown and just before primary process shutdown */
+    primaryShutdownFn?: (signal?: string) => Promise<void>;
+    /** Function to execute in worker processes during start */
+    workerFn?: () => void | Promise<void>;
+    /** Function to execute in worker processes just before worker process shutdown */
+    workerShutdownFn?: (signal?: string) => Promise<void>;
+    /** Frequency of worker health checks in milliseconds (default: 10000) */
+    pingFrequency?: number;
+    /** Timeout for worker ping responses in milliseconds (default: 30000) */
+    pingTimeout?: number;
+    /** Callback to determine action when a stuck worker is killed, if true a new worker will be spawned, if false cluster will shutdown (default: true) */
+    stuckWorkerRespawnFunc?: (worker: Worker) => boolean;
+    /** Maximum number of times to restart a worker after it has exited unexpectedly (default: 3) */
+    restartMaxTimes?: number;
+    /** Signals that trigger shutdown (default: ['SIGINT', 'SIGTERM']) */
+    shutdownSignals?: NodeJS.Signals[];
+    /** Timeout for graceful worker shutdown in milliseconds (default: 30000) */
+    shutdownTimeout?: number;
+    /** Number of worker processes to spawn (default: number of CPU cores) */
+    numWorkers?: number;
+}
+export interface Cluster {
+    worker?: Worker | undefined;
+    readonly isPrimary: boolean;
+    fork(env?: any): Worker;
+    on(event: string, listener: (...args: any[]) => void): Cluster;
+    on(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
+    on(event: 'online', listener: (worker: Worker) => void): this;
+}
+/**
+ * Internal worker state tracking
+ */
+export interface WorkerState {
+    worker: Worker;
+    restartCount: number;
+    lastPing: number;
+    pendingPing: boolean;
+    isShuttingDown: boolean;
+}
+/**
+ * Events emitted by ClusterManager
+ */
+export interface ClusterManagerEvents {
+    'worker:started': (worker: Worker) => void;
+    'worker:died': (worker: Worker, code: number | null, signal: string | null) => void;
+    'worker:stuck': (worker: Worker) => void;
+    'worker:restarted': (worker: Worker, restartCount: number) => void;
+    'worker:restart-limit-exceeded': (worker: Worker, restartCount: number) => void;
+    'shutdown:started': (signal?: string) => void;
+    'shutdown:completed': () => void;
+    error: (error: Error) => void;
+}
+/**
+ * Message types for inter-process communication
+ */
+export interface PingMessage {
+    type: 'ping';
+    timestamp: number;
+}
+export interface PongMessage {
+    type: 'pong';
+    timestamp: number;
+}
+export interface ShutdownMessage {
+    type: 'shutdown';
+    signal?: string;
+}
+export type IPCMessage = PingMessage | PongMessage | ShutdownMessage;
+//# sourceMappingURL=types.d.ts.map

package/build/cluster/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/cluster/types.ts"],"names":[],"mappings":"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"}

package/build/cluster/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/build/cluster/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Utility functions for ClusterManager
+ */
+/**
+ * Creates a promise that resolves after the specified timeout
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * Creates a promise that rejects after the specified timeout
+ */
+export declare function timeout<T>(promise: Promise<T>, ms: number, errorMessage?: string): Promise<T>;
+/**
+ * Safely executes an async function with error handling
+ */
+export declare function safeExecute<T>(fn: () => T | Promise<T>, errorMessage: string): Promise<T | undefined>;
+/**
+ * Validates ClusterManagerOptions and provides defaults
+ */
+export declare function validateAndDefaultOptions(options: import('./types').ClusterManagerOptions): Required<import('./types').ClusterManagerOptions>;
+//# sourceMappingURL=utils.d.ts.map

package/build/cluster/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/cluster/utils.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;GAEG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI/C;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAa7F;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACxB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAOxB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,OAAO,SAAS,EAAE,qBAAqB,GAC/C,QAAQ,CAAC,OAAO,SAAS,EAAE,qBAAqB,CAAC,CAgBnD"}

package/build/cluster/utils.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+exports.timeout = timeout;
+exports.safeExecute = safeExecute;
+exports.validateAndDefaultOptions = validateAndDefaultOptions;
+const os_1 = require("os");
+const cluster_1 = __importDefault(require("cluster"));
+const logger = __importStar(require("../logger"));
+/**
+ * Utility functions for ClusterManager
+ */
+/**
+ * Creates a promise that resolves after the specified timeout
+ */
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+/**
+ * Creates a promise that rejects after the specified timeout
+ */
+function timeout(promise, ms, errorMessage) {
+    let timeoutHandle;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+            reject(new Error(errorMessage ?? `Operation timed out after ${ms}ms`));
+        }, ms);
+    });
+    return Promise.race([
+        promise.finally(() => {
+            clearTimeout(timeoutHandle);
+        }),
+        timeoutPromise,
+    ]);
+}
+/**
+ * Safely executes an async function with error handling
+ */
+async function safeExecute(fn, errorMessage) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        logger.error(`${errorMessage}:`, error);
+        return undefined;
+    }
+}
+/**
+ * Validates ClusterManagerOptions and provides defaults
+ */
+function validateAndDefaultOptions(options) {
+    const numCPUs = (0, os_1.cpus)().length;
+    return {
+        cluster: options.cluster ?? cluster_1.default,
+        primaryFn: options.primaryFn ?? (() => { }),
+        primaryShutdownFn: options.primaryShutdownFn ?? (async () => { }),
+        workerFn: options.workerFn ?? (() => { }),
+        workerShutdownFn: options.workerShutdownFn ?? (async () => { }),
+        pingFrequency: options.pingFrequency ?? 10000,
+        pingTimeout: options.pingTimeout ?? 30000,
+        stuckWorkerRespawnFunc: options.stuckWorkerRespawnFunc ?? (() => true),
+        restartMaxTimes: options.restartMaxTimes ?? 3,
+        shutdownSignals: options.shutdownSignals ?? ['SIGINT', 'SIGTERM'],
+        shutdownTimeout: options.shutdownTimeout ?? 30000,
+        numWorkers: options.numWorkers ?? numCPUs,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rudderstack/integrations-lib",
-  "version": "0.2.37",
+  "version": "0.2.39",
   "description": "",
   "main": "build/index.js",
   "module": "build/index.js",