@adalo/metrics 0.1.56 → 0.1.58

package/src/metricsRedisClient.js

@@ -1,89 +1,43 @@
-const Queue = require('bee-queue')
 const { MetricsClient } = require('.')
 
 /**
  * RedisMetricsClient extends MetricsClient to collect
- * Redis and Bee Queue metrics periodically and push them to Prometheus Pushgateway.
+ * Redis metrics periodically and push them to Prometheus Pushgateway.
  *
  * @extends MetricsClient
  */
 class RedisMetricsClient extends MetricsClient {
   /**
-   * @param {Object} options - Metrics client options + Redis client
+   * @param {Object} options
    * @param {any} options.redisClient - Redis client instance (required)
-   * @param {Object} [options.metricsConfig] - MetricsClient configuration overrides
+   * @param {string} [options.appName] - Application name (from MetricsClient)
+   * @param {string} [options.dynoId] - Dyno/instance ID (from MetricsClient)
+   * @param {string} [options.processType] - Process type (from MetricsClient)
+   * @param {boolean} [options.enabled] - Enable metrics collection (from MetricsClient)
+   * @param {boolean} [options.logValues] - Log metrics values (from MetricsClient)
+   * @param {string} [options.pushgatewayUrl] - PushGateway URL (from MetricsClient)
+   * @param {string} [options.pushgatewaySecret] - PushGateway secret token (from MetricsClient)
+   * @param {number} [options.intervalSec] - Interval in seconds for pushing metrics (from MetricsClient)
+   * @param {boolean} [options.removeOldMetrics] - Remove old metrics by service (from MetricsClient)
+   * @param {boolean} [options.scripDefaultMetrics] - Skip default metrics creation (from MetricsClient)
+   * @param {function} [options.startupValidation] - Function to validate startup (from MetricsClient)
    */
-  constructor({ redisClient, metricsConfig = {} } = {}) {
-    const METRICS_QUEUE_INTERVAL_SEC =
+  constructor({ redisClient, ...metricsConfig } = {}) {
+    const intervalSec =
       metricsConfig.intervalSec ||
       parseInt(process.env.METRICS_QUEUE_INTERVAL_SEC || '', 10) ||
       5
 
-    const getConfiguredQueueNames = () => {
-      if (!process.env.METRICS_APP_REDIS_BQ) {
-        throw new Error(
-          'No queues configured for monitoring. Set METRICS_APP_REDIS_BQ with comma-separated queue names'
-        )
-      }
-
-      const allQueues = process.env.METRICS_APP_REDIS_BQ.split(',')
-        .map(q => q.trim())
-        .filter(Boolean)
-
-      if (allQueues.length === 0) {
-        throw new Error(
-          'METRICS_APP_REDIS_BQ is empty or contains only whitespace. ' +
-            'Example: METRICS_APP_REDIS_BQ="adalo-compile,adalo-migrations"'
-        )
-      }
-
-      return [...new Set(allQueues)]
-    }
-
-    const startupValidation = () => {
-      try {
-        const queueNames = getConfiguredQueueNames()
-        console.info(
-          `[queue-metrics] Queue & Redis metrics collection starting for ${queueNames.length} queues`
-        )
-        return true
-      } catch (error) {
-        console.error(`[queue-metrics] ❌ Cannot start: ${error.message}`)
-        console.error(
-          `[queue-metrics] 💡 Example: METRICS_APP_REDIS_BQ="adalo-compile,adalo-migrations"`
-        )
-        console.error(
-          `[queue-metrics] 💡 Optional: METRICS_QUEUE_INTERVAL_SEC="10"`
-        )
-        console.error(`[queue-metrics] Skipping queue metrics collection`)
-        return false
-      }
-    }
-
     super({
       ...metricsConfig,
       scripDefaultMetrics: true,
-      processType: metricsConfig.processType || 'queue-metrics',
-      intervalSec: METRICS_QUEUE_INTERVAL_SEC,
-      startupValidation,
+      processType: metricsConfig.processType || 'redis-metrics',
+      intervalSec,
     })
 
-    this.getConfiguredQueueNames = getConfiguredQueueNames
-    this.startupValidation = startupValidation
-
-    /** Redis client used for queue & Redis metrics */
+    /** Redis client used for metrics */
     this.redisClient = redisClient
 
-    /** Cache for queue objects to avoid multiple connections */
-    this.queueCache = new Map()
-
-    /** Gauge for queue jobs by status */
-    this.queueJobsGauge = this.createGauge({
-      name: 'app_queue_jobs_count',
-      help: 'Number of app jobs in the queue by status',
-      labelNames: this.withDefaultLabels(['queue_name', 'status']),
-    })
-
     /** Gauge for Redis client connections */
     this.redisConnectionsGauge = this.createGauge({
       name: 'app_redis_connections_count',
@@ -178,98 +132,25 @@ class RedisMetricsClient extends MetricsClient {
   }
 
   /**
-   * Collect metrics for a single Bee Queue and set gauges
-   * @param {string} queueName - Name of the queue
+   * Collect metrics for all Redis and push to Prometheus Pushgateway
    * @returns {Promise<void>}
    */
-  collectSingleQueueMetrics = async queueName => {
+  pushRedisMetrics = async () => {
     try {
-      if (!this.queueCache.has(queueName)) {
-        this.queueCache.set(
-          queueName,
-          new Queue(queueName, {
-            redis: this.redisClient,
-            isWorker: false,
-            getEvents: false,
-            sendEvents: false,
-          })
-        )
-      }
-
-      const queue = this.queueCache.get(queueName)
-      const health = await queue.checkHealth()
-
-      const labels = {
-        ...this.getDefaultLabels(),
-        queue_name: queueName,
-      }
-
-      this.queueJobsGauge.set(
-        { ...labels, status: 'waiting' },
-        health.waiting || 0
-      )
-      this.queueJobsGauge.set(
-        { ...labels, status: 'active' },
-        health.active || 0
-      )
-      this.queueJobsGauge.set(
-        { ...labels, status: 'succeeded' },
-        health.succeeded || 0
-      )
-      this.queueJobsGauge.set(
-        { ...labels, status: 'failed' },
-        health.failed || 0
-      )
-      this.queueJobsGauge.set(
-        { ...labels, status: 'delayed' },
-        health.delayed || 0
-      )
-    } catch (error) {
-      console.warn(
-        `[queue-metrics] Failed to collect metrics for queue ${queueName}:`,
-        error.message
-      )
-    }
-  }
-
-  /**
-   * Collect metrics for all queues and Redis, then push to Pushgateway
-   * @returns {Promise<void>}
-   */
-  collectQueueMetrics = async () => {
-    try {
-      const queueNames = this.getConfiguredQueueNames()
-
       await this.collectRedisMetrics()
-      await Promise.allSettled(
-        queueNames.map(queueName => this.collectSingleQueueMetrics(queueName))
-      )
-
       await this.gatewayPush()
 
       if (this.metricsLogValues) {
         const metricObjects = await this.registry.getMetricsAsJSON()
         console.info(
-          `[queue-metrics] Collected metrics for ${queueNames.length} queues:`,
+          `[redis-metrics] Collected metrics for Redis`,
           JSON.stringify(metricObjects, null, 2)
         )
       }
     } catch (error) {
-      if (
-        error.message?.includes('No queues configured') ||
-        error.message?.includes('METRICS_APP_REDIS_BQ')
-      ) {
-        console.error(
-          `[queue-metrics] ❌ Configuration error: ${error.message}`
-        )
-        console.error(
-          `[queue-metrics] 💡 Example config: METRICS_APP_REDIS_BQ="adalo-compile,adalo-migrations"`
-        )
-      } else {
-        console.error(
-          `[queue-metrics] Failed to collect queue metrics: ${error.message}`
-        )
-      }
+      console.error(
+        `[redis-metrics] Failed to collect Redis metrics: ${error.message}`
+      )
       throw error
     }
   }
@@ -280,36 +161,28 @@ class RedisMetricsClient extends MetricsClient {
    */
   startPush = (intervalSec = this.intervalSec) => {
     this._startPush(intervalSec, () => {
-      this.collectQueueMetrics().catch(err => {
-        console.error(
-          `[queue-metrics] Failed to collect queue & Redis metrics:`,
-          err
-        )
+      this.pushRedisMetrics().catch(err => {
+        console.error(`[redis-metrics] Failed to push Redis metrics:`, err)
       })
     })
   }
 
-  _setCleanupHandlers = () => {
-    process.on('SIGINT', this.cleanup)
-    process.on('SIGTERM', this.cleanup)
-  }
-
   /**
-   * Cleanup queues and Redis client
+   * Cleanup Redis client
    */
   cleanup = async () => {
-    for (const [queueName, queue] of this.queueCache) {
-      try {
-        await queue.close()
-      } catch (err) {
-        console.error(`[queue-metrics] Error closing queue ${queueName}:`, err)
-      }
+    try {
+      this.redisClient?.quit()
+    } catch (err) {
+      console.error('[redis-metrics] Error closing Redis client:', err)
     }
-
-    // Close Redis connection
-    this.redisClient?.quit()
     process.exit(0)
   }
+
+  _setCleanupHandlers = () => {
+    process.on('SIGINT', this.cleanup)
+    process.on('SIGTERM', this.cleanup)
+  }
 }
 
 module.exports = { RedisMetricsClient }

package/src/redisUtils.js

@@ -4,7 +4,7 @@
  * @param {string} [defaultAppName='undefined-app'] - Fallback app name if METRICS_APP_NAME is not set.
  * @returns {(client: import('redis').RedisClient, name: string) => void}
  */
-const createSetClientName = (defaultAppName = 'undefined-app') => {
+const createSetClientNameForRedisV3 = (defaultAppName = 'undefined-app') => {
   return (client, name) => {
     const appName = process.env.METRICS_APP_NAME || defaultAppName
     const dyno = process.env.BUILD_DYNO_PROCESS_TYPE || 'undefined-dyno'
@@ -27,4 +27,60 @@ const createSetClientName = (defaultAppName = 'undefined-app') => {
   }
 }
 
-module.exports = { createSetClientName }
+/**
+ * Creates a function to set Redis client name for ioredis
+ * @param {string} defaultAppName
+ * @returns {(client: Redis, name: string) => void}
+ */
+const createSetClientNameForIoredis = (defaultAppName = 'undefined-app') => {
+  return (client, name) => {
+    const appName = process.env.METRICS_APP_NAME || defaultAppName
+    const dyno = process.env.BUILD_DYNO_PROCESS_TYPE || 'undefined-dyno'
+
+    if (process.env.NODE_ENV !== 'test') {
+      client.once('connect', () => {
+        client
+          .call('CLIENT', ['SETNAME', `${appName}:${dyno}:${name}`])
+          .then(() => {
+            console.log(`Connected to Redis for pid:${process.pid} (${name})`)
+          })
+          .catch(err => {
+            console.error(`Failed to set client name for ${name}:`, err)
+          })
+      })
+    }
+  }
+}
+
+/**
+ * Creates a function to set Redis client name for node-redis v4
+ * @param {string} defaultAppName
+ * @returns {(client: ReturnType<createClient>, name: string) => void}
+ */
+const createSetClientNameForRedisV4 = (defaultAppName = 'undefined-app') => {
+  return (client, name) => {
+    const appName = process.env.METRICS_APP_NAME || defaultAppName
+    const dyno = process.env.BUILD_DYNO_PROCESS_TYPE || 'undefined-dyno'
+
+    if (process.env.NODE_ENV !== 'test') {
+      client.on('ready', async () => {
+        try {
+          await client.sendCommand([
+            'CLIENT',
+            'SETNAME',
+            `${appName}:${dyno}:${name}`,
+          ])
+          console.log(`Connected to Redis for pid:${process.pid} (${name})`)
+        } catch (err) {
+          console.error(`Failed to set client name for ${name}:`, err)
+        }
+      })
+    }
+  }
+}
+
+module.exports = {
+  createSetClientNameForRedisV3,
+  createSetClientNameForRedisV4,
+  createSetClientNameForIoredis,
+}