@zintrust/core 0.1.42 → 0.1.43

package/packages/workers/src/WorkerInit.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Worker Management System Initializer
+ *
+ * Handles initialization and lifecycle management of the worker management system.
+ * - Registers shutdown handlers
+ * - Initializes monitoring and resource management
+ * - Sets up auto-scaling and health checks
+ * - Ensures graceful startup and shutdown
+ */
+export interface IWorkerInitOptions {
+    /**
+     * Whether to start resource monitoring on initialization
+     * @default true
+     */
+    enableResourceMonitoring?: boolean;
+    /**
+     * Whether to start health monitoring on initialization
+     * @default true
+     */
+    enableHealthMonitoring?: boolean;
+    /**
+     * Whether to start auto-scaling on initialization
+     * @default false - must be explicitly enabled
+     */
+    enableAutoScaling?: boolean;
+    /**
+     * Whether to register graceful shutdown handlers
+     * @default true
+     */
+    registerShutdownHandlers?: boolean;
+    /**
+     * Resource monitoring interval in milliseconds
+     * @default 60000 (1 minute)
+     */
+    resourceMonitoringInterval?: number;
+}
+interface IInitState {
+    initialized: boolean;
+    initializedAt: Date | null;
+    resourceMonitoring: boolean;
+    healthMonitoring: boolean;
+    autoScaling: boolean;
+    shutdownHandlersRegistered: boolean;
+}
+/**
+ * Initialize the worker management system
+ */
+declare function initialize(options?: IWorkerInitOptions): Promise<void>;
+declare function autoStartPersistedWorkers(): Promise<void>;
+/**
+ * Check if worker management system is initialized
+ */
+declare function isInitialized(): boolean;
+/**
+ * Get initialization state
+ */
+declare function getInitState(): Readonly<IInitState>;
+/**
+ * Graceful shutdown of worker management system
+ * (convenience method that delegates to WorkerShutdown)
+ */
+declare function shutdown(): Promise<void>;
+export declare const WorkerInit: Readonly<{
+    /**
+     * Initialize the worker management system
+     */
+    initialize: typeof initialize;
+    /**
+     * Check if worker management system is initialized
+     */
+    isInitialized: typeof isInitialized;
+    /**
+     * Get initialization state
+     */
+    getInitState: typeof getInitState;
+    /**
+     * Graceful shutdown of worker management system
+     */
+    shutdown: typeof shutdown;
+    /**
+     * Start persisted workers after boot completes
+     */
+    autoStartPersistedWorkers: typeof autoStartPersistedWorkers;
+}>;
+export {};
+//# sourceMappingURL=WorkerInit.d.ts.map

package/packages/workers/src/WorkerInit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerInit.d.ts","sourceRoot":"","sources":["../../../../packages/workers/src/WorkerInit.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAaH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAEnC;;;OAGG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAEnC;;;OAGG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACrC;AAED,UAAU,UAAU;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,EAAE,IAAI,GAAG,IAAI,CAAC;IAC3B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,OAAO,CAAC;IACrB,0BAA0B,EAAE,OAAO,CAAC;CACrC;AA4ND;;GAEG;AACH,iBAAe,UAAU,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2DzE;AAED,iBAAe,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CA8BxD;AAED;;GAEG;AACH,iBAAS,aAAa,IAAI,OAAO,CAEhC;AAED;;GAEG;AACH,iBAAS,YAAY,IAAI,QAAQ,CAAC,UAAU,CAAC,CAE5C;AAED;;;GAGG;AACH,iBAAe,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAWvC;AAMD,eAAO,MAAM,UAAU;IACrB;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;EAEH,CAAC"}

package/packages/workers/src/WorkerInit.js

@@ -0,0 +1,307 @@
+/**
+ * Worker Management System Initializer
+ *
+ * Handles initialization and lifecycle management of the worker management system.
+ * - Registers shutdown handlers
+ * - Initializes monitoring and resource management
+ * - Sets up auto-scaling and health checks
+ * - Ensures graceful startup and shutdown
+ */
+import { Env, Logger } from '../../../src/index.js';
+import { ResourceMonitor } from './ResourceMonitor.js';
+import { WorkerFactory } from './WorkerFactory.js';
+import { WorkerShutdown } from './WorkerShutdown.js';
+import { keyPrefix } from './config/workerConfig.js';
+// ============================================================================
+// State
+// ============================================================================
+const state = {
+    initialized: false,
+    initializedAt: null,
+    resourceMonitoring: false,
+    healthMonitoring: false,
+    autoScaling: false,
+    shutdownHandlersRegistered: false,
+};
+// ============================================================================
+// Implementation
+// ============================================================================
+/**
+ * Initialize resource monitoring based on environment and worker settings
+ */
+function initializeResourceMonitoring(enableResourceMonitoring, resourceMonitoringInterval) {
+    // Check global environment gate first
+    const globalResourceMonitoring = Env.getBool('WORKER_RESOURCE_MONITORING', false);
+    if (enableResourceMonitoring && globalResourceMonitoring) {
+        // Check if any workers have resourceMonitoring enabled
+        const shouldStart = shouldStartResourceMonitoring();
+        if (shouldStart) {
+            if (ResourceMonitor.isRunning() === false) {
+                ResourceMonitor.start(resourceMonitoringInterval / 1000);
+            }
+            Logger.debug('✓ Resource monitoring started (worker requested)');
+            return true;
+        }
+        else {
+            Logger.debug('⏸️ Resource monitoring disabled (no workers requested it)');
+        }
+    }
+    else if (!globalResourceMonitoring) {
+        Logger.debug('⏸️ Resource monitoring disabled (WORKER_RESOURCE_MONITORING=false)');
+    }
+    return false;
+}
+const getPersistenceOverride = (driver) => {
+    if (driver === 'redis') {
+        return { driver: 'redis', keyPrefix: keyPrefix() };
+    }
+    if (driver === 'memory') {
+        return { driver: 'memory' };
+    }
+    return {
+        driver: 'database',
+        connection: Env.get('WORKER_PERSISTENCE_DB_CONNECTION', 'default') ?? 'default',
+        table: Env.get('WORKER_PERSISTENCE_TABLE', 'zintrust_workers') ?? 'zintrust_workers',
+    };
+};
+/**
+ * Check if any workers have resource monitoring enabled
+ */
+function shouldStartResourceMonitoring() {
+    try {
+        const workerNames = WorkerFactory.list();
+        return workerNames.some((name) => {
+            const worker = WorkerFactory.get(name);
+            return worker?.config?.features?.resourceMonitoring === true;
+        });
+    }
+    catch {
+        return false;
+    }
+}
+const resolveAutoStartCandidates = (records) => {
+    return records.filter((record) => record.activeStatus !== false && record.autoStart === true);
+};
+const resolvePersistenceTargets = () => {
+    const configuredDriver = (Env.get('WORKER_PERSISTENCE_DRIVER', 'memory') || '')
+        .toLowerCase()
+        .trim();
+    const targets = configuredDriver === 'database'
+        ? [
+            { source: 'database', persistenceOverride: getPersistenceOverride('database') },
+            { source: 'redis', persistenceOverride: getPersistenceOverride('redis') },
+            { source: 'memory', persistenceOverride: { driver: 'memory' } },
+        ]
+        : [
+            { source: 'redis', persistenceOverride: getPersistenceOverride('redis') },
+            { source: 'memory', persistenceOverride: { driver: 'memory' } },
+        ];
+    // Sort so the configured driver comes first (priority)
+    return targets.sort((a, b) => {
+        const aIsConfigured = a.persistenceOverride.driver === configuredDriver;
+        const bIsConfigured = b.persistenceOverride.driver === configuredDriver;
+        if (aIsConfigured && !bIsConfigured)
+            return -1;
+        if (!aIsConfigured && bIsConfigured)
+            return 1;
+        return 0;
+    });
+};
+const collectAutoStartTasks = async () => {
+    const targets = resolvePersistenceTargets();
+    const tasks = [];
+    const seenWorkerNames = new Set();
+    for (const target of targets) {
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            const records = await WorkerFactory.listPersistedRecords(target.persistenceOverride);
+            const candidates = resolveAutoStartCandidates(records);
+            Logger.debug('Auto-start discovery', {
+                source: target.source,
+                totalRecords: records.length,
+                candidateCount: candidates.length,
+            });
+            for (const record of candidates) {
+                if (seenWorkerNames.has(record.name)) {
+                    Logger.warn(`Worker ${record.name} appears in multiple persistence stores; keeping first discovered source and skipping duplicate from ${target.source}.`);
+                    continue;
+                }
+                seenWorkerNames.add(record.name);
+                tasks.push({
+                    ...record,
+                    persistenceOverride: target.persistenceOverride,
+                    source: target.source,
+                });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            Logger.warn(`Auto-start discovery failed for ${target.source} persistence: ${message}`);
+        }
+    }
+    return tasks;
+};
+const isWorkerTrulyRunning = async (name) => {
+    const existing = WorkerFactory.get(name);
+    if (!existing)
+        return false;
+    const workerLike = existing.worker;
+    const isRunning = typeof workerLike.isRunning === 'function'
+        ? await Promise.resolve(workerLike.isRunning())
+        : false;
+    const isPaused = typeof workerLike.isPaused === 'function' ? workerLike.isPaused() : false;
+    return isRunning && !isPaused;
+};
+const autoStartOneWorker = async (record) => {
+    const existing = WorkerFactory.get(record.name);
+    if (existing) {
+        try {
+            if (await isWorkerTrulyRunning(record.name)) {
+                return { name: record.name, started: false, skipped: true };
+            }
+            Logger.warn(`Worker ${record.name} was registered but not truly running. Restarting to recover from stale state.`);
+            await WorkerFactory.restart(record.name, record.persistenceOverride);
+            return { name: record.name, started: true, skipped: false };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            Logger.warn(`Auto-start recovery failed for worker ${record.name}: ${message}`);
+            return { name: record.name, started: false, skipped: false };
+        }
+    }
+    try {
+        await WorkerFactory.startFromPersisted(record.name, record.persistenceOverride);
+        return { name: record.name, started: true, skipped: false };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        Logger.warn(`Auto-start failed for worker ${record.name}: ${message}`);
+        return { name: record.name, started: false, skipped: false };
+    }
+};
+/**
+ * Initialize the worker management system
+ */
+async function initialize(options = {}) {
+    if (state.initialized) {
+        Logger.warn('Worker management system already initialized');
+        return;
+    }
+    const { enableResourceMonitoring = true, enableHealthMonitoring = true, enableAutoScaling = false, registerShutdownHandlers = true, resourceMonitoringInterval = 60000, } = options;
+    Logger.info('🚀 Initializing worker management system', {
+        enableResourceMonitoring,
+        enableHealthMonitoring,
+        enableAutoScaling,
+        registerShutdownHandlers,
+    });
+    try {
+        // 1. Register shutdown handlers first (so they're ready for any failures)
+        if (registerShutdownHandlers) {
+            WorkerShutdown.registerShutdownHandlers();
+            state.shutdownHandlersRegistered = true;
+            Logger.debug('✓ Shutdown handlers registered');
+        }
+        // 2. Start resource monitoring (important for scaling decisions)
+        state.resourceMonitoring = initializeResourceMonitoring(enableResourceMonitoring, resourceMonitoringInterval);
+        // 3. Enable health monitoring (depends on workers being created)
+        if (enableHealthMonitoring) {
+            // Health checks will start automatically when workers are created
+            state.healthMonitoring = true;
+            Logger.debug('✓ Health monitoring enabled');
+        }
+        // 4. Start auto-scaling if explicitly enabled
+        if (enableAutoScaling) {
+            // Auto-scaling will evaluate workers when they are created
+            state.autoScaling = true;
+            Logger.debug('✓ Auto-scaling enabled');
+        }
+        state.initialized = true;
+        state.initializedAt = new Date();
+        Logger.info('✅ Worker management system initialized successfully', {
+            timestamp: state.initializedAt.toISOString(),
+        });
+    }
+    catch (error) {
+        Logger.error('❌ Failed to initialize worker management system', error);
+        throw error;
+    }
+}
+async function autoStartPersistedWorkers() {
+    const envAutoStart = Env.getBool('WORKER_AUTO_START', false);
+    const shouldAutoStart = envAutoStart;
+    Logger.debug('Auto-start check', {
+        envAutoStart,
+        shouldAutoStart,
+    });
+    if (!shouldAutoStart) {
+        Logger.debug('Auto-start disabled - WORKER_AUTO_START is not true');
+        return;
+    }
+    try {
+        const candidates = await collectAutoStartTasks();
+        const results = await Promise.all(candidates.map(async (record) => autoStartOneWorker(record)));
+        const startedCount = results.filter((item) => item.started).length;
+        const skippedCount = results.filter((item) => item.skipped).length;
+        Logger.info('Auto-started persisted workers', {
+            total: candidates.length,
+            started: startedCount,
+            skipped: skippedCount,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        Logger.warn(`Auto-start persisted workers failed: ${message}`);
+    }
+}
+/**
+ * Check if worker management system is initialized
+ */
+function isInitialized() {
+    return state.initialized;
+}
+/**
+ * Get initialization state
+ */
+function getInitState() {
+    return { ...state };
+}
+/**
+ * Graceful shutdown of worker management system
+ * (convenience method that delegates to WorkerShutdown)
+ */
+async function shutdown() {
+    if (!state.initialized) {
+        Logger.warn('Worker management system not initialized, nothing to shutdown');
+        return;
+    }
+    await WorkerShutdown.shutdown();
+    state.initialized = false;
+    state.resourceMonitoring = false;
+    state.healthMonitoring = false;
+    state.autoScaling = false;
+}
+// ============================================================================
+// Public API (Sealed Namespace)
+// ============================================================================
+export const WorkerInit = Object.freeze({
+    /**
+     * Initialize the worker management system
+     */
+    initialize,
+    /**
+     * Check if worker management system is initialized
+     */
+    isInitialized,
+    /**
+     * Get initialization state
+     */
+    getInitState,
+    /**
+     * Graceful shutdown of worker management system
+     */
+    shutdown,
+    /**
+     * Start persisted workers after boot completes
+     */
+    autoStartPersistedWorkers,
+});

package/packages/workers/src/WorkerMetrics.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Worker Metrics Manager
+ * Time-series metrics persistence with Redis Sorted Sets
+ * Sealed namespace for immutability
+ */
+import { type RedisConfig } from '../../../src/index.js';
+export type MetricType = 'processed' | 'errors' | 'duration' | 'memory' | 'cpu' | 'queue-size' | 'active-jobs' | 'waiting-jobs' | 'delayed-jobs' | 'failed-jobs' | 'completed-jobs';
+export type MetricGranularity = 'hourly' | 'daily' | 'monthly';
+export type MetricPoint = {
+    timestamp: Date;
+    value: number;
+    metadata?: Record<string, unknown>;
+};
+export type MetricEntry = {
+    workerName: string;
+    metricType: MetricType;
+    granularity: MetricGranularity;
+    points: ReadonlyArray<MetricPoint>;
+};
+export type MetricQueryOptions = {
+    workerName: string;
+    metricType: MetricType;
+    granularity: MetricGranularity;
+    startDate?: Date;
+    endDate?: Date;
+    limit?: number;
+};
+export type AggregatedMetrics = {
+    workerName: string;
+    metricType: MetricType;
+    period: {
+        start: Date;
+        end: Date;
+    };
+    total: number;
+    average: number;
+    min: number;
+    max: number;
+    count: number;
+};
+export type WorkerHealthScore = {
+    workerName: string;
+    timestamp: Date;
+    score: number;
+    factors: {
+        errorRate: number;
+        throughput: number;
+        latency: number;
+        resourceUsage: number;
+    };
+    status: 'healthy' | 'degraded' | 'unhealthy';
+};
+/**
+ * Worker Metrics Manager - Sealed namespace
+ */
+declare const WorkerMetrics: Readonly<{
+    /**
+     * Initialize the metrics manager with Redis connection
+     */
+    initialize(config: RedisConfig): void;
+    /**
+     * Record a metric point
+     */
+    record(workerName: string, metricType: MetricType, value: number, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Record multiple metrics at once (batch operation)
+     */
+    recordBatch(workerName: string, metrics: Array<{
+        metricType: MetricType;
+        value: number;
+        metadata?: Record<string, unknown>;
+    }>): Promise<void>;
+    /**
+     * Query metrics for a time range
+     */
+    query(options: MetricQueryOptions): Promise<MetricEntry>;
+    /**
+     * Get aggregated metrics for a time range
+     */
+    aggregate(options: MetricQueryOptions): Promise<AggregatedMetrics>;
+    aggregateBatch(optionsList: MetricQueryOptions[]): Promise<AggregatedMetrics[]>;
+    /**
+     * Calculate and store health score
+     */
+    calculateHealth(workerName: string): Promise<WorkerHealthScore>;
+    /**
+     * Get recent health scores
+     */
+    getHealthHistory(workerName: string, hours?: number): Promise<ReadonlyArray<WorkerHealthScore>>;
+    /**
+     * Get latest health score
+     */
+    getLatestHealth(workerName: string): Promise<WorkerHealthScore | null>;
+    /**
+     * Get metrics summary for all workers
+     */
+    getAllWorkersSummary(): Promise<ReadonlyArray<{
+        workerName: string;
+        health: WorkerHealthScore | null;
+        metrics: {
+            processed: number;
+            errors: number;
+            errorRate: number;
+        };
+    }>>;
+    /**
+     * Delete all metrics for a worker
+     */
+    deleteWorkerMetrics(workerName: string): Promise<void>;
+    /**
+     * Shutdown and disconnect
+     */
+    shutdown(): Promise<void>;
+}>;
+export { WorkerMetrics };
+//# sourceMappingURL=WorkerMetrics.d.ts.map

package/packages/workers/src/WorkerMetrics.d.ts.map

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