dt-common-device 9.2.3 → 9.2.5

package/dist/audit/PushAudit.js

@@ -10,8 +10,7 @@ const typedi_1 = __importDefault(require("typedi"));
 const ExcludeAudits_1 = require("./ExcludeAudits");
 async function pushAudit(data) {
     const audit = await typedi_1.default.get(AuditUtils_1.AuditUtils).buildAuditProperties(data.auditData);
-    if (ExcludeAudits_1.excludeEvents.includes(data.auditType) &&
-        !ExcludeAudits_1.propertyIdsToPush.includes(data.auditData.propertyId)) {
+    if (ExcludeAudits_1.excludeEvents.includes(data.auditType)) {
         console.log("Audit event excluded:", data.auditType);
     }
     else {

package/dist/queue/entities/HybridHttpQueue.js

@@ -72,6 +72,7 @@ let HybridHttpQueue = (() => {
                 const earliestRequest = recentRequests[0];
                 const nextAvailableTime = earliestRequest + windowMs;
                 delay = Math.max(nextAvailableTime - now, 1000); // At least 1s delay
+                console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Rate limit exceeded, calculated delay: ${delay}ms for job`);
             }
             // Create job data
             const jobData = {
@@ -82,26 +83,57 @@ let HybridHttpQueue = (() => {
                 options,
                 timestamp: Date.now(),
             };
+            console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Adding job to queue - ${method} ${url} -> ${provider} [${connectionId}], delay: ${delay}ms`);
             // Add job to BullMQ queue with delay
             const jobId = await queueUtils_1.QueueUtils.addJobToQueue(queueKey, jobData, delay, this.queues);
+            console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Job added to queue - JobId: ${jobId}, QueueKey: ${queueKey}`);
             // Initialize worker if not exists
+            console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Initializing worker for queue: ${queueKey}`);
             queueUtils_1.QueueUtils.getOrCreateWorker(queueKey, this.workers, this.processHttpRequest.bind(this), this.jobResults);
+            // Verify worker was created
+            if (this.workers.has(queueKey)) {
+                console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Worker confirmed for queue: ${queueKey}`);
+            }
+            else {
+                console.log(`[${new Date().toISOString()}] [HybridHttpQueue] WARNING: Worker NOT found for queue: ${queueKey}`);
+            }
             (0, config_1.getConfig)().LOGGER.info(`Request queued: ${method} ${url} -> ${provider} [${connectionId}]. Job ID: ${jobId}, Delay: ${delay}ms`);
             // Wait for job completion and return result
-            // Pass the delay so timeout calculation accounts for it
-            return queueUtils_1.QueueUtils.waitForJobCompletion(jobId, queueKey, this.jobResults, delay);
+            // Simple: delay + windowMs + HTTP buffer timeout
+            return queueUtils_1.QueueUtils.waitForJobCompletion(jobId, queueKey, delay, windowMs);
         }
         async processHttpRequest(job) {
-            const { connectionId, provider, url, method, options } = job.data;
-            // Check rate limit before processing
-            const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
-            if (!allowed) {
-                // This shouldn't happen since we calculate delay, but handle it gracefully
-                (0, config_1.getConfig)().LOGGER.warn(`Job ${job.id} still rate limited after delay, waiting for window to expire...`);
-                await queueUtils_1.QueueUtils.waitForRateLimitExpiry(connectionId, provider, this.rateLimitConfigs);
+            // Log immediately when worker picks up the job
+            const startTime = Date.now();
+            console.log(`[${new Date().toISOString()}] [Worker] processHttpRequest CALLED - JobId: ${job?.id}, QueueName: ${job?.queueName}, JobName: ${job?.name}, JobData: ${JSON.stringify(job?.data || {})}`);
+            try {
+                if (!job?.data) {
+                    throw new Error(`Job ${job?.id} has no data`);
+                }
+                const { connectionId, provider, url, method, options } = job.data;
+                if (!connectionId || !provider || !url || !method) {
+                    throw new Error(`Missing required job data fields. ConnectionId: ${connectionId}, Provider: ${provider}, URL: ${url}, Method: ${method}`);
+                }
+                console.log(`[${new Date().toISOString()}] [Worker] Processing job - JobId: ${job.id}, ${method} ${url} -> ${provider} [${connectionId}]`);
+                // Check rate limit before processing
+                const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
+                if (!allowed) {
+                    // This shouldn't happen since we calculate delay, but handle it gracefully
+                    console.log(`[${new Date().toISOString()}] [Worker] Job ${job.id} still rate limited, waiting for window to expire...`);
+                    (0, config_1.getConfig)().LOGGER.warn(`Job ${job.id} still rate limited after delay, waiting for window to expire...`);
+                    await queueUtils_1.QueueUtils.waitForRateLimitExpiry(connectionId, provider, this.rateLimitConfigs);
+                    console.log(`[${new Date().toISOString()}] [Worker] Rate limit wait completed for job ${job.id}, proceeding with HTTP request`);
+                }
+                // Execute the HTTP request
+                console.log(`[${new Date().toISOString()}] [Worker] Executing HTTP request for job ${job.id}`);
+                const result = await queueUtils_1.QueueUtils.executeHttpRequest(url, method, options, connectionId, provider);
+                console.log(`[${new Date().toISOString()}] [Worker] HTTP request completed successfully for job ${job.id}`);
+                return result;
+            }
+            catch (error) {
+                console.log(`[${new Date().toISOString()}] [Worker] ERROR in processHttpRequest for job ${job?.id}: ${error.message}, Stack: ${error.stack}`);
+                throw error;
             }
-            // Execute the HTTP request
-            return queueUtils_1.QueueUtils.executeHttpRequest(url, method, options, connectionId, provider);
         }
         async request(options) {
             const { method, url, body, params, headers, queueOptions } = options;

package/dist/queue/utils/queueUtils.d.ts

@@ -8,5 +8,5 @@ export declare class QueueUtils {
     static waitForRateLimitExpiry(connectionId: string, provider: string, rateLimitConfigs: Map<string, IRateLimitConfig>): Promise<void>;
     static executeHttpRequest(url: string, method: string, options: HttpCallOption, connectionId: string, provider: string): Promise<any>;
     static addJobToQueue(queueKey: string, jobData: any, delay: number, queues: Map<string, any>): Promise<string>;
-    static waitForJobCompletion(jobId: string, queueKey: string, jobResults: Map<string, any>, jobDelay?: number): Promise<any>;
+    static waitForJobCompletion(jobId: string, queueKey: string, jobDelay?: number, windowMs?: number): Promise<any>;
 }

package/dist/queue/utils/queueUtils.js

@@ -25,37 +25,110 @@ class QueueUtils {
                 .get(queueKey));
     }
     static getOrCreateWorker(queueKey, workers, processFunction, jobResults) {
-        if (workers.has(queueKey))
-            return;
+        if (workers.has(queueKey)) {
+            const existingWorker = workers.get(queueKey);
+            console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Worker already exists for queue: ${queueKey}, checking if it's running...`);
+            // Check if worker is still connected/running
+            // If worker is closed or errored, recreate it
+            if (existingWorker && typeof existingWorker.isRunning === "function") {
+                const isRunning = existingWorker.isRunning();
+                console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Existing worker running status: ${isRunning}`);
+                if (!isRunning) {
+                    console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Worker not running, closing and recreating...`);
+                    try {
+                        existingWorker.close();
+                    }
+                    catch (e) {
+                        // Ignore errors when closing
+                    }
+                    workers.delete(queueKey);
+                    // Continue to create new worker below
+                }
+                else {
+                    return; // Worker is running, keep using it
+                }
+            }
+            else {
+                // Worker object exists but might be stale, try to use it
+                console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Existing worker found but cannot verify status, keeping it`);
+                return;
+            }
+        }
+        console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Creating new worker for queue: ${queueKey}`);
         const { Worker } = require("bullmq");
-        const worker = new Worker(queueKey, processFunction, {
+        // Wrap the process function to catch any errors during execution
+        const wrappedProcessFunction = async (job) => {
+            const wrapperStartTime = Date.now();
+            console.log(`[${new Date().toISOString()}] [Worker Wrapper] Worker picked up job - JobId: ${job?.id}, QueueKey: ${queueKey}, JobName: ${job?.name}, Delay: ${job?.opts?.delay || 0}ms`);
+            try {
+                const result = await processFunction(job);
+                const processingTime = Date.now() - wrapperStartTime;
+                console.log(`[${new Date().toISOString()}] [Worker Wrapper] Job processed successfully - JobId: ${job?.id}, ProcessingTime: ${processingTime}ms, ResultType: ${typeof result}, HasResult: ${result !== undefined && result !== null}`);
+                return result;
+            }
+            catch (error) {
+                const processingTime = Date.now() - wrapperStartTime;
+                console.log(`[${new Date().toISOString()}] [Worker Wrapper] Error processing job - JobId: ${job?.id}, Error: ${error.message}, Stack: ${error.stack}, ProcessingTime: ${processingTime}ms`);
+                throw error;
+            }
+        };
+        const worker = new Worker(queueKey, wrappedProcessFunction, {
             connection: (0, redis_1.getRedisClient)(),
             concurrency: 1,
-            removeOnComplete: true,
-            removeOnFail: true,
+            removeOnComplete: { count: 100, age: 3600 }, // Keep completed jobs for debugging
+            removeOnFail: { count: 100, age: 3600 },
             lockDuration: 300000,
-            stalledInterval: 60000,
+            stalledInterval: 30000, // Check for stalled jobs more frequently
         });
+        console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Worker instance created for queue: ${queueKey}`);
         // Event handlers for job tracking
+        worker.on("active", (job) => {
+            console.log(`[${new Date().toISOString()}] [Worker Event] Job active - JobId: ${job.id}, QueueKey: ${queueKey}, JobName: ${job.name}, Data: ${JSON.stringify(job.data || {})}`);
+        });
+        worker.on("waiting", (jobId) => {
+            console.log(`[${new Date().toISOString()}] [Worker Event] Job waiting - JobId: ${jobId}, QueueKey: ${queueKey}`);
+        });
+        worker.on("delayed", (job) => {
+            console.log(`[${new Date().toISOString()}] [Worker Event] Job delayed - JobId: ${job.id}, QueueKey: ${queueKey}, Delay: ${job.opts?.delay || 0}ms`);
+        });
         worker.on("completed", (job) => {
+            console.log(`[${new Date().toISOString()}] [Worker Event] Job completed - JobId: ${job.id}, QueueKey: ${queueKey}, ReturnValueType: ${typeof job.returnvalue}, HasReturnValue: ${job.returnvalue !== undefined}`);
             (0, config_1.getConfig)().LOGGER.info(`HTTP request completed: ${job.id} [${queueKey}]`);
             const result = job.returnvalue;
-            jobResults.set(job.id, {
+            const jobResult = {
                 result,
                 resolved: true,
                 timestamp: Date.now(),
-            });
+            };
+            console.log(`[${new Date().toISOString()}] [Worker Event] Storing job result - JobId: ${job.id}, ResultType: ${typeof result}, Resolved: true`);
+            jobResults.set(job.id, jobResult);
+            console.log(`[${new Date().toISOString()}] [Worker Event] Job result stored in jobResults - JobId: ${job.id}, StoredResult: ${JSON.stringify(jobResult)}`);
         });
         worker.on("failed", (job, err) => {
+            console.log(`[${new Date().toISOString()}] [Worker Event] Job failed - JobId: ${job?.id}, QueueKey: ${queueKey}, Error: ${err.message}`);
             (0, config_1.getConfig)().LOGGER.error(`HTTP request failed: ${job?.id} [${queueKey}], Error: ${err.message}`);
             jobResults.set(job.id, {
                 error: err.message,
                 resolved: true,
                 timestamp: Date.now(),
             });
+            console.log(`[${new Date().toISOString()}] [Worker Event] Job error stored in jobResults - JobId: ${job?.id}`);
+        });
+        worker.on("error", (err) => {
+            console.log(`[${new Date().toISOString()}] [Worker Event] Worker error - QueueKey: ${queueKey}, Error: ${err.message}, Stack: ${err.stack}`);
+            (0, config_1.getConfig)().LOGGER.error(`Worker error for ${queueKey}: ${err.message}`);
+        });
+        worker.on("ready", () => {
+            console.log(`[${new Date().toISOString()}] [Worker Event] Worker ready - QueueKey: ${queueKey}`);
+        });
+        worker.on("closing", () => {
+            console.log(`[${new Date().toISOString()}] [Worker Event] Worker closing - QueueKey: ${queueKey}`);
+        });
+        worker.on("closed", () => {
+            console.log(`[${new Date().toISOString()}] [Worker Event] Worker closed - QueueKey: ${queueKey}`);
         });
-        worker.on("error", (err) => (0, config_1.getConfig)().LOGGER.error(`Worker error for ${queueKey}: ${err.message}`));
         workers.set(queueKey, worker);
+        console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Worker initialized and stored for queue: ${queueKey}`);
         (0, config_1.getConfig)().LOGGER.info(`Worker initialized for queue: ${queueKey}`);
     }
     static async waitForRateLimitExpiry(connectionId, provider, rateLimitConfigs) {
@@ -63,6 +136,7 @@ class QueueUtils {
         const config = rateLimitConfigs.get(provider);
         if (!config)
             return;
+        console.log(`[${new Date().toISOString()}] [waitForRateLimitExpiry] Starting wait for ${provider} [${connectionId}]`);
         while (true) {
             const timestamps = await rateLimit_utils_1.RateLimitUtils.getRawRequestTimestamps(key);
             const now = Date.now();
@@ -70,18 +144,21 @@ class QueueUtils {
             const recentRequests = timestamps.filter((t) => t > windowStart);
             if (recentRequests.length < config.maxRequests) {
                 // Rate limit not exceeded, we can proceed
+                console.log(`[${new Date().toISOString()}] [waitForRateLimitExpiry] Rate limit cleared, proceeding`);
                 break;
             }
             // Calculate when the earliest request will expire
             const earliestRequest = recentRequests[0];
             const nextAvailableTime = earliestRequest + config.windowMs;
             const delay = Math.max(nextAvailableTime - now, 1000); // At least 1 second
+            console.log(`[${new Date().toISOString()}] [waitForRateLimitExpiry] Rate limit exceeded, waiting ${delay}ms. Requests in window: ${recentRequests.length}/${config.maxRequests}`);
             (0, config_1.getConfig)().LOGGER.info(`Rate limit exceeded for ${provider} [${connectionId}]. Waiting ${delay}ms until next allowed request. Current requests in window: ${recentRequests.length}/${config.maxRequests}`);
             // Wait for the calculated delay
             await new Promise((resolve) => setTimeout(resolve, delay));
         }
     }
     static async executeHttpRequest(url, method, options, connectionId, provider) {
+        console.log(`[${new Date().toISOString()}] [executeHttpRequest] Starting HTTP request - ${method} ${url} -> ${provider} [${connectionId}]`);
         (0, config_1.getConfig)().LOGGER.info(`Executing: ${method} ${url} -> ${provider} [${connectionId}]`);
         try {
             // Record the request first
@@ -95,11 +172,13 @@ class QueueUtils {
                 ...(options.body && { data: options.body }),
                 ...(options.params && { params: options.params }),
             });
+            console.log(`[${new Date().toISOString()}] [executeHttpRequest] HTTP request successful - ${method} ${url} for ${provider} [${connectionId}]`);
             (0, config_1.getConfig)().LOGGER.info(`HTTP request successful: ${method} ${url} for ${provider} [${connectionId}]`);
             // Return only the response data
             return response.data;
         }
         catch (error) {
+            console.log(`[${new Date().toISOString()}] [executeHttpRequest] HTTP request failed - ${method} ${url} for ${provider} [${connectionId}], Error: ${error.message}`);
             (0, config_1.getConfig)().LOGGER.error(`HTTP request failed: ${error.message}`);
             await (0, dt_audit_library_1.publishAudit)({
                 eventType: "http.request.error",
@@ -119,62 +198,77 @@ class QueueUtils {
         }
     }
     static async addJobToQueue(queueKey, jobData, delay, queues) {
+        console.log(`[${new Date().toISOString()}] [addJobToQueue] Adding job to BullMQ queue - QueueKey: ${queueKey}, Delay: ${delay}ms`);
         const queue = this.getOrCreateQueue(queueKey, queues);
         const job = await queue.add("http-request", jobData, {
             delay,
             attempts: 1,
-            removeOnComplete: { age: 300, count: 1 },
-            removeOnFail: { age: 300, count: 1 },
+            removeOnComplete: { age: 300, count: 100 },
+            removeOnFail: { age: 300, count: 100 },
         });
+        console.log(`[${new Date().toISOString()}] [addJobToQueue] Job added to BullMQ - JobId: ${job.id}, QueueKey: ${queueKey}, Delay: ${delay}ms`);
+        // Log queue state for debugging
+        try {
+            const [waiting, delayed, active] = await Promise.all([
+                queue.getWaitingCount(),
+                queue.getDelayedCount(),
+                queue.getActiveCount(),
+            ]);
+            console.log(`[${new Date().toISOString()}] [addJobToQueue] Queue state - QueueKey: ${queueKey}, Waiting: ${waiting}, Delayed: ${delayed}, Active: ${active}`);
+        }
+        catch (e) {
+            // Ignore errors getting queue state
+        }
         return job.id;
     }
-    static async waitForJobCompletion(jobId, queueKey, jobResults, jobDelay = 0) {
-        return new Promise((resolve, reject) => {
-            let timeoutId;
-            let backupTimeoutId;
-            let checkCount = 0;
-            // Calculate timeout: delay + execution buffer
-            // Buffer includes: HTTP request timeout (60s) + rate limit wait + processing overhead
-            const baseBuffer = queueKey.toLowerCase().includes("cloudbeds")
-                ? 180000
-                : 90000;
-            const totalTimeout = jobDelay + baseBuffer;
-            // Calculate max checks based on total timeout
-            // Use 50ms for first 10 checks, then 100ms for remaining
-            // Max checks should cover the total timeout
-            const maxChecks = Math.ceil((totalTimeout - 500) / 100 + 10);
-            (0, config_1.getConfig)().LOGGER.info(`Waiting for job ${jobId}: delay=${jobDelay}ms, totalTimeout=${totalTimeout}ms, maxChecks=${maxChecks}`);
-            const checkJob = async () => {
-                if (++checkCount >= maxChecks) {
-                    clearTimeout(timeoutId);
-                    clearTimeout(backupTimeoutId);
-                    return reject(new Error(`Job timeout: Request took too long (waited ${totalTimeout}ms, delay was ${jobDelay}ms)`));
-                }
+    static async waitForJobCompletion(jobId, queueKey, jobDelay = 0, windowMs = 60000) {
+        // Simple: delay (wait) + windowMs (execute) + HTTP timeout buffer
+        const httpTimeout = 60000;
+        const totalTimeout = jobDelay + windowMs + httpTimeout;
+        console.log(`[${new Date().toISOString()}] [waitForJobCompletion] Waiting for job ${jobId} - delay: ${jobDelay}ms, timeout: ${totalTimeout}ms`);
+        const startTime = Date.now();
+        const { Queue } = require("bullmq");
+        const queue = new Queue(queueKey, {
+            connection: (0, redis_1.getRedisClient)(),
+        });
+        return new Promise(async (resolve, reject) => {
+            const checkInterval = setInterval(async () => {
                 try {
-                    const memoryResult = jobResults.get(jobId);
-                    if (memoryResult?.resolved) {
-                        clearTimeout(timeoutId);
-                        clearTimeout(backupTimeoutId);
-                        return memoryResult.result !== undefined
-                            ? resolve(memoryResult.result)
-                            : reject(new Error(memoryResult.error || "Unknown error"));
+                    const job = await queue.getJob(jobId);
+                    if (!job) {
+                        const elapsed = Date.now() - startTime;
+                        if (elapsed > totalTimeout) {
+                            clearInterval(checkInterval);
+                            await queue.close();
+                            return reject(new Error(`Job ${jobId} not found and timeout exceeded`));
+                        }
+                        return; // Job not found yet, keep checking
+                    }
+                    const state = await job.getState();
+                    if (state === "completed") {
+                        console.log(`[${new Date().toISOString()}] [waitForJobCompletion] Job ${jobId} completed`);
+                        clearInterval(checkInterval);
+                        const result = job.returnvalue;
+                        await queue.close();
+                        return resolve(result);
+                    }
+                    if (state === "failed") {
+                        console.log(`[${new Date().toISOString()}] [waitForJobCompletion] Job ${jobId} failed: ${job.failedReason}`);
+                        clearInterval(checkInterval);
+                        await queue.close();
+                        return reject(new Error(job.failedReason || "Job failed"));
                     }
-                    // Continue checking
-                    timeoutId = setTimeout(checkJob, checkCount < 10 ? 50 : 100);
                 }
                 catch (error) {
-                    clearTimeout(timeoutId);
-                    clearTimeout(backupTimeoutId);
-                    reject(new Error(`Error checking job: ${error.message}`));
+                    clearInterval(checkInterval);
+                    await queue.close();
+                    reject(error);
                 }
-            };
-            checkJob();
-            // const waitTime = queueKey.toLowerCase().includes("cloudbeds")
-            //   ? 180000
-            //   : 60000;
-            // Backup timeout with the calculated total timeout
-            backupTimeoutId = setTimeout(() => {
-                clearTimeout(timeoutId);
+            }, 500); // Check every 500ms
+            // Timeout
+            setTimeout(() => {
+                clearInterval(checkInterval);
+                queue.close();
                 reject(new Error(`Request timeout: Maximum wait time exceeded (${totalTimeout}ms). Job delay was ${jobDelay}ms.`));
             }, totalTimeout);
         });

package/dist/queue/utils/rateLimit.utils.js

@@ -76,7 +76,7 @@ class RateLimitUtils {
             maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.SMARTTHINGS, {
-            maxRequests: 12,
+            maxRequests: 30,
             windowMs: 60000, // 1 minute
             provider: constants_1.CONNECTION_PROVIDERS.SMARTTHINGS,
             maxTimeoutWindowMs: 120000,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "9.2.3",
+  "version": "9.2.5",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [