@adalo/metrics 0.1.164 → 0.1.166

package/src/metrics/baseMetricsClient.js

@@ -20,7 +20,6 @@ class BaseMetricsClient {
    * @param {string} [config.pushgatewaySecret] Basic auth secret (Base64 of user:password)
    * @param {number} [config.intervalSec] Interval in seconds for pushing metrics
    * @param {boolean} [config.removeOldMetrics] Enable to clear metrics by service name
-   * @param {boolean} [config.skipFirstPush] Skip the first push (first push after interval); set METRICS_SKIP_FIRST_PUSH=true to give old instance time to exit
    * @param {function} [config.startupValidation] Add to validate on start push.
    * @param {boolean} [config.disablePushgateway] Disable pushing to Pushgateway (use HTTP scraping instead)
    */
@@ -49,14 +48,6 @@ class BaseMetricsClient {
     this.removeOldMetrics =
       config.removeOldMetrics ??
       process.env.METRICS_REMOVE_OLD_METRICS === 'true'
-    /** When true, skip the immediate first push; first push runs after the first interval. Set METRICS_SKIP_FIRST_PUSH=true. */
-    this.skipFirstPush =
-      config.skipFirstPush ?? process.env.METRICS_SKIP_FIRST_PUSH === 'true'
-    /** If true (default), cleanup() calls process.exit(0). Set to false when the app handles SIGTERM itself (e.g. graceful HTTP shutdown). */
-    this.cleanupExitsProcess = config.cleanupExitsProcess ?? true
-
-    /** @type {NodeJS.Timeout | null} Push interval handle so it can be cleared on shutdown */
-    this._pushIntervalId = null
 
     this.prefixLogs = `[${this.processType}] [${this.appName}] [${this.dynoId}] [Monitoring]`
 
@@ -223,27 +214,19 @@ class BaseMetricsClient {
     }
 
     if (customPushMetics && typeof customPushMetics === 'function') {
-      this._pushIntervalId = setInterval(
-        () => customPushMetics(),
-        interval * 1000
-      )
+      setInterval(() => customPushMetics(), interval * 1000)
     } else {
-      this._pushIntervalId = setInterval(() => {
+      setInterval(() => {
         runPush().catch(err => {
           console.error(`${this.prefixLogs} Failed to push metrics:`, err)
         })
       }, interval * 1000)
     }
 
-    // First push: skip when skipFirstPush, otherwise push immediately
-    if (!this.skipFirstPush) {
-      runPush().catch(err => {
-        console.error(
-          `${this.prefixLogs} Failed to push metrics (initial):`,
-          err
-        )
-      })
-    }
+    // First push immediately so metrics appear without waiting for the first interval
+    runPush().catch(err => {
+      console.error(`${this.prefixLogs} Failed to push metrics (initial):`, err)
+    })
 
     let pushOrigin = 'none'
     try {
@@ -258,20 +241,6 @@ class BaseMetricsClient {
     )
   }
 
-  /**
-   * Stop periodic metrics push (clears the interval).
-   * Call this before process exit to avoid pushing during shutdown and to reduce connection overlap on redeploy.
-   */
-  stopPush = () => {
-    if (this._pushIntervalId) {
-      clearInterval(this._pushIntervalId)
-      this._pushIntervalId = null
-      console.warn(
-        `${this.prefixLogs} Metrics collection stopped (push interval cleared).`
-      )
-    }
-  }
-
   pushMetrics = async () => {
     return this._pushMetrics()
   }
@@ -291,19 +260,14 @@ class BaseMetricsClient {
   }
 
   /**
-   * Cleanup metrics and optionally exit process.
-   * Stops the push interval immediately (to avoid overlap on redeploy), then deletes this instance's metrics from the gateway, then exits if cleanupExitsProcess is true.
+   * Cleanup metrics and exit process.
    * @returns {Promise<void>}
    */
   cleanup = async () => {
-    console.warn(`${this.prefixLogs} Metrics cleanup started (shutdown).`)
-    this.stopPush()
     if (this.enabled) {
       await this.gatewayDelete()
     }
-    if (this.cleanupExitsProcess !== false) {
-      process.exit(0)
-    }
+    process.exit(0)
   }
 
   /**
@@ -330,9 +294,6 @@ class BaseMetricsClient {
       this.pushgatewayUrl &&
       this.pushgatewayUrl.trim()
     ) {
-      console.warn(
-        `${this.prefixLogs} Deleting this instance's metrics from VM (app=${this.appName}, dyno_id=${this.dynoId}, process_type=${this.processType}).`
-      )
       await this._deleteFromVMByLabels().catch(err => {
         console.warn(
           `${this.prefixLogs} Deletion from VM on shutdown failed:`,
@@ -494,10 +455,8 @@ class BaseMetricsClient {
   }
 
   _setCleanupHandlers = () => {
-    if (this.cleanupExitsProcess) {
-      process.on('SIGINT', this.cleanup)
-      process.on('SIGTERM', this.cleanup)
-    }
+    process.on('SIGINT', this.cleanup)
+    process.on('SIGTERM', this.cleanup)
   }
 
   // GETTERS

package/src/metrics/metricsQueueRedisClient.js

@@ -11,7 +11,6 @@ class QueueRedisMetricsClient extends RedisMetricsClient {
   /**
    * @param {Object} options
    * @param {any} options.redisClient - Redis client instance (required)
-   * @param {boolean} [options.gracefulShutdownRedis] - Passed to RedisMetricsClient
    * @param {string} [options.appName] - Application name (from BaseMetricsClient)
    * @param {string} [options.dynoId] - Dyno/instance ID (from BaseMetricsClient)
    * @param {string} [options.processType] - Process type (from BaseMetricsClient)
@@ -336,7 +335,6 @@ class QueueRedisMetricsClient extends RedisMetricsClient {
 
   /**
    * Cleanup queues and exit process.
-   * Closes queues then runs Redis metrics cleanup (stop push, delete from VM, close Redis).
    * @returns {Promise<void>}
    */
   cleanup = async () => {
@@ -347,7 +345,7 @@ class QueueRedisMetricsClient extends RedisMetricsClient {
         console.error(`[queue-metrics] Error closing queue ${queueName}:`, err)
       }
     }
-    await super.cleanup()
+    process.exit(0)
   }
 }
 

package/src/metrics/metricsRedisClient.js

@@ -9,9 +9,6 @@ const {
 const redisConnectionStableFields = ['name', 'flags', 'cmd']
 const redisConnectionFields = ['name', 'flags', 'tot-mem', 'cmd']
 
-/** Stream entries older than this (ms) are trimmed so messages are not kept in Redis. Fixed 60s. */
-const GRACEFUL_SHUTDOWN_STREAM_MAXAGE_MS = 60000
-
 /**
  * RedisMetricsClient extends BaseMetricsClient to collect
  * Redis metrics periodically and push them to Prometheus Pushgateway.
@@ -21,8 +18,7 @@ const GRACEFUL_SHUTDOWN_STREAM_MAXAGE_MS = 60000
 class RedisMetricsClient extends BaseMetricsClient {
   /**
    * @param {Object} options
-   * @param {any} options.redisClient - Redis client instance (required). Used for metrics and publish. Subscriber is created internally (duplicate() or REDIS_URL).
-   * @param {boolean} [options.gracefulShutdownRedis] - Default true. When true, new instance publishes on start and old instances exit on message. Set false or METRICS_GRACEFUL_SHUTDOWN_REDIS=false to disable.
+   * @param {any} options.redisClient - Redis client instance (required)
    * @param {string} [options.appName] - Application name (from BaseMetricsClient)
    * @param {string} [options.dynoId] - Dyno/instance ID (from BaseMetricsClient)
    * @param {string} [options.processType] - Process type (from BaseMetricsClient)
@@ -55,36 +51,34 @@ class RedisMetricsClient extends BaseMetricsClient {
     this.redisClient = redisClient
     this.redisClientType = getRedisClientType(redisClient)
 
-    /** Dedicated Redis connection for subscribe (subscriber mode); closed in cleanup. */
-    this._subClient = null
-
-    this._initGracefulShutdown(metricsConfig.gracefulShutdownRedis)
+    /** Label names for Redis metrics: app + process_type only (no dyno_id). */
+    this._redisLabelNames = ['app', 'process_type']
 
-    /** Counter for Redis client connections */
+    /** Counter for Redis connection metrics */
     this.redisConnectionsGauge = this.createGauge({
       name: 'app_redis_connections_count',
       help: 'Redis client connections',
-      labelNames: this.withDefaultLabels(redisConnectionStableFields),
+      labelNames: [...this._redisLabelNames, ...redisConnectionStableFields],
     })
 
     this.redisConnectionsMemoryGauge = this.createGauge({
       name: 'app_redis_connections_memory_usage_count',
       help: 'Redis client connections',
-      labelNames: this.withDefaultLabels(redisConnectionStableFields),
+      labelNames: [...this._redisLabelNames, ...redisConnectionStableFields],
     })
 
     /** Gauge for Redis memory usage */
     this.redisMemoryGauge = this.createGauge({
       name: 'app_redis_memory_bytes',
       help: 'Redis memory usage in bytes',
-      labelNames: this.withDefaultLabels(['memory_type']),
+      labelNames: [...this._redisLabelNames, 'memory_type'],
     })
 
     /** Gauge for Redis operation stats */
     this.redisStatsGauge = this.createGauge({
       name: 'app_redis_stats_total',
       help: 'Redis operation statistics',
-      labelNames: this.withDefaultLabels(['operation']),
+      labelNames: [...this._redisLabelNames, 'operation'],
     })
 
     // Track emitted connection label combinations so we can:
@@ -99,211 +93,6 @@ class RedisMetricsClient extends BaseMetricsClient {
     this._setCleanupHandlers()
   }
 
-  /**
-   * Initialize graceful-shutdown state and subscribe when enabled. Called from constructor.
-   * @param {boolean} [gracefulShutdownRedis] - Explicit false to disable; otherwise enabled unless METRICS_GRACEFUL_SHUTDOWN_REDIS=false.
-   */
-  _initGracefulShutdown(gracefulShutdownRedis) {
-    const disabledByParam = gracefulShutdownRedis === false
-    const disabledByEnv =
-      process.env.METRICS_GRACEFUL_SHUTDOWN_REDIS === 'false'
-    this._gracefulShutdownRedis = !disabledByParam && !disabledByEnv
-    this._gracefulShutdownStream = this._gracefulShutdownRedis
-      ? `metrics:graceful-shutdown:${this.appName}:${this.processType}`
-      : null
-    this._gracefulShutdownAckChannel = this._gracefulShutdownRedis
-      ? `metrics:graceful-shutdown-ack:${this.appName}:${this.processType}`
-      : null
-    this._gracefulShutdownLogPrefix = `[graceful-shutdown] [${this.processType}] [${this.appName}] [${this.dynoId}]`
-    if (this._gracefulShutdownRedis && this._gracefulShutdownStream) {
-      this._setupGracefulShutdownSubscribe()
-    }
-  }
-
-  /**
-   * Create a dedicated Redis client for subscribe (pub/sub). Uses duplicate() when available, else createClient from REDIS_URL. Branches by redisClientType (IOREDIS, REDIS_V3, REDIS_V4).
-   * @returns {any|null} Subscriber client or null if not possible.
-   */
-  _createSubscriberClient() {
-    if (this.redisClientType === IOREDIS && this.redisClient && typeof this.redisClient.duplicate === 'function') {
-      return this.redisClient.duplicate()
-    }
-    if ((this.redisClientType === REDIS_V3 || this.redisClientType === REDIS_V4) && this.redisClient && typeof this.redisClient.duplicate === 'function') {
-      return this.redisClient.duplicate()
-    }
-    if ((this.redisClientType === REDIS_V3 || this.redisClientType === REDIS_V4) && process.env.REDIS_URL) {
-      try {
-        const redis = require('redis')
-        if (typeof redis.createClient !== 'function') return null
-        try {
-          return redis.createClient({ url: process.env.REDIS_URL })
-        } catch {
-          return redis.createClient(process.env.REDIS_URL)
-        }
-      } catch {
-        return null
-      }
-    }
-    return null
-  }
-
-  /**
-   * Set up Redis subscribe for graceful shutdown. Uses _createSubscriberClient() so subscriber matches client type (ioredis vs node-redis v3/v4).
-   */
-  /**
-   * Set up Redis stream read for graceful shutdown. Uses _createSubscriberClient() and XREAD BLOCK; stream is trimmed (MAXLEN and MINID) so messages are not kept in Redis forever.
-   */
-  _setupGracefulShutdownSubscribe() {
-    const streamKey = this._gracefulShutdownStream
-    if (!streamKey) return
-
-    const subClient = this._createSubscriberClient()
-    if (subClient && typeof subClient.on === 'function') {
-      subClient.on('error', () => {})
-    }
-
-    if (!subClient) return
-
-    this._subClient = subClient
-    this._streamReadLoop(streamKey)
-  }
-
-  _streamReadLoop(streamKey) {
-    const self = this
-    const blockMs = 5000
-
-    const runRead = () => {
-      if (!self._subClient) return
-      self._xreadBlock(streamKey, blockMs)
-        .then((entries) => {
-          if (!entries || entries.length === 0) {
-            setImmediate(runRead)
-            return
-          }
-          self._cleanupAndPublishAck()
-        })
-        .catch(() => {
-          setImmediate(runRead)
-        })
-    }
-    runRead()
-  }
-
-  _xreadBlock(streamKey, blockMs) {
-    const client = this._subClient || this.redisClient
-    if (!client) return Promise.resolve([])
-
-    if (this.redisClientType === REDIS_V3) {
-      return new Promise((resolve, reject) => {
-        client.send_command('XREAD', ['BLOCK', String(blockMs), 'STREAMS', streamKey, '$'], (err, result) => {
-          if (err) return reject(err)
-          resolve(this._parseXreadReply(result, streamKey))
-        })
-      })
-    }
-    if (this.redisClientType === REDIS_V4) {
-      const p = client.sendCommand(['XREAD', 'BLOCK', String(blockMs), 'STREAMS', streamKey, '$'])
-      return Promise.resolve(p).then(result => this._parseXreadReply(result, streamKey)).catch(() => [])
-    }
-    if (this.redisClientType === IOREDIS) {
-      const p = client.call('XREAD', 'BLOCK', blockMs, 'STREAMS', streamKey, '$')
-      return Promise.resolve(p).then(result => this._parseXreadReply(result, streamKey)).catch(() => [])
-    }
-    return Promise.resolve([])
-  }
-
-  _parseXreadReply(reply, streamKey) {
-    if (!reply || !Array.isArray(reply)) return []
-    const streamReply = reply.find(r => r && r[0] === streamKey)
-    if (!streamReply || !Array.isArray(streamReply[1])) return []
-    return streamReply[1].map(entry => (Array.isArray(entry) ? [entry[0], entry[1] || []] : [entry, []]))
-  }
-
-  /**
-   * Old instance: stop push, clear metrics from VM, then publish ack so new can start; then exit.
-   */
-  async _cleanupAndPublishAck() {
-    this.stopPush()
-    if (this.enabled) {
-      await this.gatewayDelete()
-    }
-    await this._publishAck()
-    if (this._subClient) {
-      try {
-        if (this.redisClientType === REDIS_V3) {
-          await new Promise((resolve, reject) => {
-            if (typeof this._subClient.quit === 'function') {
-              this._subClient.quit(err => (err ? reject(err) : resolve()))
-            } else resolve()
-          })
-        } else if (this.redisClientType === REDIS_V4) {
-          if (this._subClient.quit) await this._subClient.quit()
-        } else if (this.redisClientType === IOREDIS) {
-          if (this._subClient.disconnect) await this._subClient.disconnect()
-        }
-      } catch {
-        // ignore
-      }
-      this._subClient = null
-    }
-    try {
-      if (this.redisClient) {
-        if (this.redisClientType === REDIS_V3 || this.redisClientType === REDIS_V4) {
-          await this.redisClient.quit()
-        } else if (this.redisClientType === IOREDIS) {
-          await this.redisClient.disconnect()
-        }
-      }
-    } catch {
-      // ignore
-    }
-    process.exit(0)
-  }
-
-  _publishAck() {
-    const ackChannel = this._gracefulShutdownAckChannel
-    if (!ackChannel || !this.redisClient) return Promise.resolve()
-    console.warn(
-      `${this._gracefulShutdownLogPrefix} OLD: clearing metrics and exiting.`
-    )
-    const msg = this.dynoId || 'stopped'
-    if (this.redisClientType === REDIS_V3) {
-      return new Promise((resolve) => {
-        this.redisClient.send_command('PUBLISH', [ackChannel, msg], () => resolve())
-      })
-    }
-    if (this.redisClientType === REDIS_V4) {
-      return this.redisClient.sendCommand(['PUBLISH', ackChannel, msg]).catch(() => {})
-    }
-    if (this.redisClientType === IOREDIS) {
-      return this.redisClient.publish(ackChannel, msg).catch(() => {})
-    }
-    return Promise.resolve()
-  }
-
-  /**
-   * Publish "new instance started" to stream so old instances exit. Stream is trimmed (MAXLEN ~ 10 and MINID older than 1 min) so messages are not kept in Redis forever.
-   */
-  _publishNewInstanceStarted() {
-    const streamKey = this._gracefulShutdownStream
-    if (!streamKey || !this.redisClient) return
-    const value = this.dynoId || '1'
-    const noop = () => {}
-    const maxAgeMs = GRACEFUL_SHUTDOWN_STREAM_MAXAGE_MS
-    const minId = `${Date.now() - maxAgeMs}-0`
-
-    if (this.redisClientType === REDIS_V3) {
-      this.redisClient.send_command('XADD', [streamKey, 'MAXLEN', '~', '10', '*', 'dyno_id', value], noop)
-      this.redisClient.send_command('XTRIM', [streamKey, 'MINID', minId], noop)
-    } else if (this.redisClientType === REDIS_V4) {
-      this.redisClient.sendCommand(['XADD', streamKey, 'MAXLEN', '~', '10', '*', 'dyno_id', value]).catch(noop)
-      this.redisClient.sendCommand(['XTRIM', streamKey, 'MINID', minId]).catch(noop)
-    } else if (this.redisClientType === IOREDIS) {
-      this.redisClient.call('XADD', streamKey, 'MAXLEN', '~', 10, '*', 'dyno_id', value).catch(noop)
-      this.redisClient.call('XTRIM', streamKey, 'MINID', minId).catch(noop)
-    }
-  }
-
   getRedisConnections = async () => {
     if (!this.redisClient) throw new Error('Redis client not provided')
 
@@ -396,7 +185,7 @@ class RedisMetricsClient extends BaseMetricsClient {
           this.getRedisConnections(),
         ])
 
-      const labels = this.getDefaultLabels()
+      const labels = { app: this.appName, process_type: this.processType }
 
       const connections = this.parseRedisConnections(connectionsInfoStr)
 
@@ -553,7 +342,7 @@ class RedisMetricsClient extends BaseMetricsClient {
         )
       }
     } catch (error) {
-      console.error(
+      console.warn(
         `[queue-metrics] Failed to collect Redis metrics:`,
         error.message
       )
@@ -569,6 +358,14 @@ class RedisMetricsClient extends BaseMetricsClient {
       await this.collectRedisMetrics()
       await this.gatewayPush()
       this.clearAllCounters()
+
+      if (this.metricsLogValues) {
+        const metricObjects = await this.registry.getMetricsAsJSON()
+        console.info(
+          `[queue-metrics] Collected metrics for Redis`,
+          JSON.stringify(metricObjects, null, 2)
+        )
+      }
     } catch (error) {
       console.error(
         `[queue-metrics] Failed to collect Redis metrics: ${error.message}`
@@ -578,7 +375,8 @@ class RedisMetricsClient extends BaseMetricsClient {
   }
 
   /**
-   * Start periodic collection. When graceful shutdown is on: new publishes "new started" so old exits and clears; new does not push until after one interval (skipFirstPush), giving old time to stop.
+   * Start periodic collection.
+   * @param {number} [intervalSec=this.intervalSec] - Interval in seconds
    */
   startPush = (intervalSec = this.intervalSec) => {
     this._startPush(intervalSec, () => {
@@ -586,39 +384,13 @@ class RedisMetricsClient extends BaseMetricsClient {
         console.error(`[queue-metrics] Failed to push Redis metrics:`, err)
       })
     })
-    if (this._gracefulShutdownRedis) {
-      this._publishNewInstanceStarted()
-    }
   }
 
   /**
    * Cleanup Redis client and exit process.
-   * Stops push, deletes this instance's metrics from VM (if removeOldMetrics), closes subscriber and main Redis, then exits.
    * @returns {Promise<void>}
    */
   cleanup = async () => {
-    this.stopPush()
-    if (this.enabled) {
-      await this.gatewayDelete()
-    }
-    if (this._subClient) {
-      try {
-        if (this.redisClientType === REDIS_V3) {
-          await new Promise((resolve, reject) => {
-            if (typeof this._subClient.quit === 'function') {
-              this._subClient.quit(err => (err ? reject(err) : resolve()))
-            } else resolve()
-          })
-        } else if (this.redisClientType === REDIS_V4) {
-          if (this._subClient.quit) await this._subClient.quit()
-        } else if (this.redisClientType === IOREDIS) {
-          if (this._subClient.disconnect) await this._subClient.disconnect()
-        }
-      } catch (err) {
-        console.error('[queue-metrics] Error closing subscriber client:', err)
-      }
-      this._subClient = null
-    }
     try {
       if (!this.redisClient) return
 
@@ -633,7 +405,7 @@ class RedisMetricsClient extends BaseMetricsClient {
     } catch (err) {
       console.error('[queue-metrics] Error closing Redis client:', err)
     }
-    await super.cleanup()
+    process.exit(0)
   }
 
   _setCleanupHandlers = () => {