dt-common-device 13.10.4 → 13.10.6

package/dist/audit/IAuditProperties.d.ts

@@ -20,7 +20,8 @@ export declare enum Resource {
     ACCESS_BLE = "accessBle",
     EMERGENCY_CODE = "emergencyCode",
     EMERGENCY_RFID = "emergencyRfid",
-    EMERGENCY_BLE = "emergencyBle"
+    EMERGENCY_BLE = "emergencyBle",
+    SERVER = "server"
 }
 export interface IAuditProperties {
     resource: Resource;
@@ -45,3 +46,8 @@ export interface IAuditProperties {
     eventData?: any;
     [key: string]: any;
 }
+export type PartialAuditProperties = Omit<IAuditProperties, "resource" | "source" | "propertyId"> & {
+    resource?: Resource;
+    source?: Source;
+    propertyId?: string;
+};

package/dist/audit/IAuditProperties.js

@@ -24,4 +24,5 @@ var Resource;
     Resource["EMERGENCY_CODE"] = "emergencyCode";
     Resource["EMERGENCY_RFID"] = "emergencyRfid";
     Resource["EMERGENCY_BLE"] = "emergencyBle";
+    Resource["SERVER"] = "server";
 })(Resource || (exports.Resource = Resource = {}));

package/dist/audit/PushAudit.d.ts

@@ -1,10 +1,21 @@
-import { IAuditProperties } from "./IAuditProperties";
+import { IAuditProperties, PartialAuditProperties } from "./IAuditProperties";
 /**
  * Publishes an audit event. Failures are logged and swallowed so callers can
  * fire-and-forget without causing unhandled promise rejections when the audit
  * pipeline returns 5xx or times out (see e.g. Sentry DT-PMS-C).
+ * USE FOR PROPERTY LEVEL AUDITS
  */
 export declare function pushAudit(data: {
     auditType: string;
     auditData: IAuditProperties;
 }): Promise<void>;
+/**
+ * Publishes an audit event. Failures are logged and swallowed so callers can
+ * fire-and-forget without causing unhandled promise rejections when the audit
+ * pipeline returns 5xx or times out (see e.g. Sentry DT-PMS-C).
+ * USE FOR SYSTEM LEVEL AUDITS (If Property ID is not available)
+ */
+export declare function pushSystemAudit(data: {
+    auditType: string;
+    auditData: PartialAuditProperties;
+}): Promise<void>;

package/dist/audit/PushAudit.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pushAudit = pushAudit;
+exports.pushSystemAudit = pushSystemAudit;
 const dt_audit_library_1 = require("dt-audit-library");
 const config_1 = require("../config/config");
 const AuditUtils_1 = require("./AuditUtils");
@@ -12,6 +13,7 @@ const typedi_1 = __importDefault(require("typedi"));
  * Publishes an audit event. Failures are logged and swallowed so callers can
  * fire-and-forget without causing unhandled promise rejections when the audit
  * pipeline returns 5xx or times out (see e.g. Sentry DT-PMS-C).
+ * USE FOR PROPERTY LEVEL AUDITS
  */
 async function pushAudit(data) {
     try {
@@ -33,3 +35,28 @@ async function pushAudit(data) {
             : { auditType: data.auditType });
     }
 }
+/**
+ * Publishes an audit event. Failures are logged and swallowed so callers can
+ * fire-and-forget without causing unhandled promise rejections when the audit
+ * pipeline returns 5xx or times out (see e.g. Sentry DT-PMS-C).
+ * USE FOR SYSTEM LEVEL AUDITS (If Property ID is not available)
+ */
+async function pushSystemAudit(data) {
+    try {
+        await (0, dt_audit_library_1.publishAudit)({
+            eventType: data.auditType,
+            properties: {
+                ...data.auditData,
+                timestamp: new Date().toISOString(),
+                env_type: process.env.NODE_ENV,
+            },
+        });
+    }
+    catch (err) {
+        const status = err?.response?.status;
+        const code = err?.code;
+        (0, config_1.getLogger)().error(`pushSystemAudit failed for ${data.auditType}: ${err?.message ?? err}`, status != null || code != null
+            ? { auditType: data.auditType, status, code }
+            : { auditType: data.auditType });
+    }
+}

package/dist/queue/entities/HybridHttpQueue.js

@@ -99,7 +99,7 @@ let HybridHttpQueue = (() => {
             (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
             // Simple: delay + windowMs + HTTP buffer timeout
-            return queueUtils_1.QueueUtils.waitForJobCompletion(jobId, queueKey, delay, windowMs);
+            return queueUtils_1.QueueUtils.waitForJobCompletion(jobId, queueKey, delay, windowMs, this.queues);
         }
         async processHttpRequest(job) {
             // Log immediately when worker picks up the job
@@ -147,7 +147,7 @@ let HybridHttpQueue = (() => {
             return this.handleRequest(url, method, httpCallOption);
         }
         async handleRequest(url, method, options) {
-            const { connectionId, provider, microservice } = jobUtils_1.JobUtils.extractConnectionDetails(options);
+            const { connectionId, provider } = jobUtils_1.JobUtils.extractConnectionDetails(options);
             // Check rate limit first
             const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
             if (allowed) {

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, jobDelay?: number, windowMs?: number): Promise<any>;
+    static waitForJobCompletion(jobId: string, queueKey: string, jobDelay: number | undefined, windowMs: number | undefined, queues: Map<string, any>): Promise<any>;
 }

package/dist/queue/utils/queueUtils.js

@@ -35,6 +35,8 @@ class QueueUtils {
                 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...`);
+                    // Stale worker detected — surface at WARN level with count context
+                    (0, config_1.getConfig)().LOGGER.warn(`Stale worker for queue ${queueKey} (not running), recreating. Active workers before recreate: ${workers.size}`);
                     try {
                         existingWorker.close();
                     }
@@ -116,7 +118,8 @@ class QueueUtils {
         });
         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}`);
+        // Log total active workers — a growing count here signals a connection-proliferation leak
+        (0, config_1.getConfig)().LOGGER.info(`Worker initialized for queue: ${queueKey} (total active workers: ${workers.size})`);
     }
     static async waitForRateLimitExpiry(connectionId, provider, rateLimitConfigs) {
         const key = `rate_limit:${provider}:${connectionId}`;
@@ -202,22 +205,25 @@ class QueueUtils {
                 queue.getActiveCount(),
             ]);
             console.log(`[${new Date().toISOString()}] [addJobToQueue] Queue state - QueueKey: ${queueKey}, Waiting: ${waiting}, Delayed: ${delayed}, Active: ${active}`);
+            // Warn via structured logger when backlog is building — correlates with heap stats
+            if (waiting + delayed > 1) {
+                (0, config_1.getConfig)().LOGGER.warn(`Queue backlog [${queueKey}]: waiting=${waiting} delayed=${delayed} active=${active}`);
+            }
         }
         catch (e) {
             // Ignore errors getting queue state
         }
         return job.id;
     }
-    static async waitForJobCompletion(jobId, queueKey, jobDelay = 0, windowMs = 60000) {
+    static async waitForJobCompletion(jobId, queueKey, jobDelay = 0, windowMs = 60000, queues) {
         // 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)(),
-        });
+        // Reuse the existing queue instance — never create a new Queue per call
+        // (each new Queue duplicates the Redis connection, causing a connection leak)
+        const queue = this.getOrCreateQueue(queueKey, queues);
         return new Promise(async (resolve, reject) => {
             const checkInterval = setInterval(async () => {
                 try {
@@ -226,7 +232,6 @@ class QueueUtils {
                         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
@@ -236,26 +241,25 @@ class QueueUtils {
                         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"));
                     }
                 }
                 catch (error) {
                     clearInterval(checkInterval);
-                    await queue.close();
                     reject(error);
                 }
             }, 500); // Check every 500ms
             // Timeout
             setTimeout(() => {
                 clearInterval(checkInterval);
-                queue.close();
+                // Log via structured logger before rejecting so the timeout is visible in
+                // CloudWatch alongside the periodic heap stats — correlates queue stalls with memory pressure.
+                (0, config_1.getConfig)().LOGGER.error(`Job ${jobId} timed out after ${totalTimeout}ms [${queueKey}] (jobDelay=${jobDelay}ms)`);
                 reject(new Error(`Request timeout: Maximum wait time exceeded (${totalTimeout}ms). Job delay was ${jobDelay}ms.`));
             }, totalTimeout);
         });

package/package.json

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