@adalo/metrics 0.0.0-staging.1

package/lib/health/healthCheckCache.js

@@ -0,0 +1,187 @@
+"use strict";
+
+const {
+  getRedisClientType,
+  REDIS_V4,
+  IOREDIS,
+  REDIS_V3
+} = require('../redisUtils');
+
+/**
+ * HealthCheckCache provides a shared cache layer for health check results.
+ * It uses Redis if available for cross-process sharing, with graceful fallback
+ * to in-memory cache if Redis is not configured or unavailable.
+ */
+class HealthCheckCache {
+  /**
+   * @param {Object} options
+   * @param {any} [options.redisClient]
+   * @param {string} [options.cacheKey] - Redis key (e.g. 'health:database:status')
+   * @param {string} [options.appName] - Used when cacheKey not set: healthcheck:${appName}
+   * @param {number} [options.staleThresholdMs]
+   */
+  constructor(options = {}) {
+    this.redisClient = options.redisClient || null;
+    this.appName = options.appName || process.env.BUILD_APP_NAME || 'unknown-app';
+    this.staleThresholdMs = options.staleThresholdMs ?? 180_000;
+    this.cacheKey = options.cacheKey || `healthcheck:${this.appName}`;
+
+    /** In-memory fallback cache */
+    this._memoryCache = null;
+    this._memoryCacheTimestamp = null;
+    if (this.redisClient) {
+      this._redisClientType = getRedisClientType(this.redisClient);
+      this._redisAvailable = true;
+    } else {
+      this._redisAvailable = false;
+      console.warn(`[HealthCheckCache] Redis not configured for ${this.appName}, using in-memory cache only (not shared across processes)`);
+    }
+  }
+
+  /**
+   * Checks if Redis is available and working.
+   * @returns {Promise<boolean>}
+   * @private
+   */
+  async _checkRedisAvailable() {
+    if (!this.redisClient || !this._redisAvailable) {
+      return false;
+    }
+    try {
+      let pong;
+      if (this._redisClientType === REDIS_V3) {
+        pong = await new Promise((resolve, reject) => {
+          this.redisClient.ping((err, result) => {
+            if (err) reject(err);else resolve(result);
+          });
+        });
+      } else if (this._redisClientType === REDIS_V4 || this._redisClientType === IOREDIS) {
+        pong = await this.redisClient.ping();
+      } else {
+        return false;
+      }
+      return pong === 'PONG';
+    } catch (err) {
+      if (this._redisAvailable) {
+        console.warn(`[HealthCheckCache] Redis became unavailable: ${err.message}`);
+        this._redisAvailable = false;
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Gets cached health check result from Redis (if available) or in-memory cache.
+   * Throws error if Redis is configured but read fails (so caller can return proper error format).
+   * @returns {Promise<Object | null>} Cached result or null
+   * @throws {Error} If Redis is configured but read fails
+   */
+  async get() {
+    if (this.redisClient) {
+      try {
+        let cachedStr;
+        if (this._redisClientType === REDIS_V3) {
+          cachedStr = await new Promise((resolve, reject) => {
+            this.redisClient.get(this.cacheKey, (err, result) => {
+              if (err) reject(err);else resolve(result);
+            });
+          });
+        } else if (this._redisClientType === REDIS_V4 || this._redisClientType === IOREDIS) {
+          cachedStr = await this.redisClient.get(this.cacheKey);
+        }
+        if (cachedStr) {
+          try {
+            const cached = JSON.parse(cachedStr);
+            if (cached.result && cached.timestamp) {
+              this._memoryCache = cached.result;
+              this._memoryCacheTimestamp = cached.timestamp;
+              return cached.result;
+            }
+          } catch (parseErr) {
+            console.warn(`[HealthCheckCache] Failed to parse Redis cache:`, parseErr.message);
+          }
+        }
+        return null;
+      } catch (redisErr) {
+        this._redisAvailable = false;
+        throw new Error(`Redis cache read failed: ${redisErr.message}`);
+      }
+    }
+    if (this._memoryCache && this._memoryCacheTimestamp) {
+      return this._memoryCache;
+    }
+    return null;
+  }
+
+  /**
+   * Sets cached health check result in Redis (if available) and in-memory.
+   * @param {Object} result - Health check result to cache
+   * @returns {Promise<void>}
+   */
+  async set(result) {
+    const cacheData = {
+      result,
+      timestamp: Date.now()
+    };
+    this._memoryCache = result;
+    this._memoryCacheTimestamp = cacheData.timestamp;
+    if (await this._checkRedisAvailable()) {
+      try {
+        const cacheStr = JSON.stringify(cacheData);
+        const ttlSeconds = Math.ceil(this.staleThresholdMs / 1000) + 60;
+        if (this._redisClientType === REDIS_V3) {
+          await new Promise((resolve, reject) => {
+            this.redisClient.setex(this.cacheKey, ttlSeconds, cacheStr, err => {
+              if (err) reject(err);else resolve();
+            });
+          });
+        } else if (this._redisClientType === REDIS_V4) {
+          await this.redisClient.set(this.cacheKey, cacheStr, {
+            EX: ttlSeconds
+          });
+        } else if (this._redisClientType === IOREDIS) {
+          await this.redisClient.setex(this.cacheKey, ttlSeconds, cacheStr);
+        }
+      } catch (redisErr) {
+        console.warn(`[HealthCheckCache] Redis write failed (in-memory cache updated):`, redisErr.message);
+        this._redisAvailable = false;
+      }
+    }
+  }
+
+  /**
+   * Clears the cache (both Redis and in-memory).
+   * @returns {Promise<void>}
+   */
+  async clear() {
+    this._memoryCache = null;
+    this._memoryCacheTimestamp = null;
+    if (await this._checkRedisAvailable()) {
+      try {
+        if (this._redisClientType === REDIS_V3) {
+          await new Promise((resolve, reject) => {
+            this.redisClient.del(this.cacheKey, err => {
+              if (err) reject(err);else resolve();
+            });
+          });
+        } else if (this._redisClientType === REDIS_V4 || this._redisClientType === IOREDIS) {
+          await this.redisClient.del(this.cacheKey);
+        }
+      } catch (redisErr) {
+        console.warn(`[HealthCheckCache] Redis clear failed:`, redisErr.message);
+      }
+    }
+  }
+
+  /**
+   * Checks if Redis is configured and available.
+   * @returns {boolean}
+   */
+  isRedisAvailable() {
+    return this._redisAvailable && this.redisClient !== null;
+  }
+}
+module.exports = {
+  HealthCheckCache
+};
+//# sourceMappingURL=healthCheckCache.js.map

package/lib/health/healthCheckCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"healthCheckCache.js","names":["getRedisClientType","REDIS_V4","IOREDIS","REDIS_V3","require","HealthCheckCache","constructor","options","redisClient","appName","process","env","BUILD_APP_NAME","staleThresholdMs","cacheKey","_memoryCache","_memoryCacheTimestamp","_redisClientType","_redisAvailable","console","warn","_checkRedisAvailable","pong","Promise","resolve","reject","ping","err","result","message","get","cachedStr","cached","JSON","parse","timestamp","parseErr","redisErr","Error","set","cacheData","Date","now","cacheStr","stringify","ttlSeconds","Math","ceil","setex","EX","clear","del","isRedisAvailable","module","exports"],"sources":["../../src/health/healthCheckCache.js"],"sourcesContent":["const {\n  getRedisClientType,\n  REDIS_V4,\n  IOREDIS,\n  REDIS_V3,\n} = require('../redisUtils')\n\n/**\n * HealthCheckCache provides a shared cache layer for health check results.\n * It uses Redis if available for cross-process sharing, with graceful fallback\n * to in-memory cache if Redis is not configured or unavailable.\n */\nclass HealthCheckCache {\n  /**\n   * @param {Object} options\n   * @param {any} [options.redisClient]\n   * @param {string} [options.cacheKey] - Redis key (e.g. 'health:database:status')\n   * @param {string} [options.appName] - Used when cacheKey not set: healthcheck:${appName}\n   * @param {number} [options.staleThresholdMs]\n   */\n  constructor(options = {}) {\n    this.redisClient = options.redisClient || null\n    this.appName =\n      options.appName || process.env.BUILD_APP_NAME || 'unknown-app'\n    this.staleThresholdMs = options.staleThresholdMs ?? 180_000\n    this.cacheKey = options.cacheKey || `healthcheck:${this.appName}`\n\n    /** In-memory fallback cache */\n    this._memoryCache = null\n    this._memoryCacheTimestamp = null\n\n    if (this.redisClient) {\n      this._redisClientType = getRedisClientType(this.redisClient)\n      this._redisAvailable = true\n    } else {\n      this._redisAvailable = false\n      console.warn(\n        `[HealthCheckCache] Redis not configured for ${this.appName}, using in-memory cache only (not shared across processes)`\n      )\n    }\n  }\n\n  /**\n   * Checks if Redis is available and working.\n   * @returns {Promise<boolean>}\n   * @private\n   */\n  async _checkRedisAvailable() {\n    if (!this.redisClient || !this._redisAvailable) {\n      return false\n    }\n\n    try {\n      let pong\n      if (this._redisClientType === REDIS_V3) {\n        pong = await new Promise((resolve, reject) => {\n          this.redisClient.ping((err, result) => {\n            if (err) reject(err)\n            else resolve(result)\n          })\n        })\n      } else if (\n        this._redisClientType === REDIS_V4 ||\n        this._redisClientType === IOREDIS\n      ) {\n        pong = await this.redisClient.ping()\n      } else {\n        return false\n      }\n      return pong === 'PONG'\n    } catch (err) {\n      if (this._redisAvailable) {\n        console.warn(\n          `[HealthCheckCache] Redis became unavailable: ${err.message}`\n        )\n        this._redisAvailable = false\n      }\n      return false\n    }\n  }\n\n  /**\n   * Gets cached health check result from Redis (if available) or in-memory cache.\n   * Throws error if Redis is configured but read fails (so caller can return proper error format).\n   * @returns {Promise<Object | null>} Cached result or null\n   * @throws {Error} If Redis is configured but read fails\n   */\n  async get() {\n    if (this.redisClient) {\n      try {\n        let cachedStr\n        if (this._redisClientType === REDIS_V3) {\n          cachedStr = await new Promise((resolve, reject) => {\n            this.redisClient.get(this.cacheKey, (err, result) => {\n              if (err) reject(err)\n              else resolve(result)\n            })\n          })\n        } else if (\n          this._redisClientType === REDIS_V4 ||\n          this._redisClientType === IOREDIS\n        ) {\n          cachedStr = await this.redisClient.get(this.cacheKey)\n        }\n\n        if (cachedStr) {\n          try {\n            const cached = JSON.parse(cachedStr)\n            if (cached.result && cached.timestamp) {\n              this._memoryCache = cached.result\n              this._memoryCacheTimestamp = cached.timestamp\n              return cached.result\n            }\n          } catch (parseErr) {\n            console.warn(\n              `[HealthCheckCache] Failed to parse Redis cache:`,\n              parseErr.message\n            )\n          }\n        }\n        return null\n      } catch (redisErr) {\n        this._redisAvailable = false\n        throw new Error(`Redis cache read failed: ${redisErr.message}`)\n      }\n    }\n\n    if (this._memoryCache && this._memoryCacheTimestamp) {\n      return this._memoryCache\n    }\n\n    return null\n  }\n\n  /**\n   * Sets cached health check result in Redis (if available) and in-memory.\n   * @param {Object} result - Health check result to cache\n   * @returns {Promise<void>}\n   */\n  async set(result) {\n    const cacheData = {\n      result,\n      timestamp: Date.now(),\n    }\n\n    this._memoryCache = result\n    this._memoryCacheTimestamp = cacheData.timestamp\n\n    if (await this._checkRedisAvailable()) {\n      try {\n        const cacheStr = JSON.stringify(cacheData)\n        const ttlSeconds = Math.ceil(this.staleThresholdMs / 1000) + 60\n\n        if (this._redisClientType === REDIS_V3) {\n          await new Promise((resolve, reject) => {\n            this.redisClient.setex(this.cacheKey, ttlSeconds, cacheStr, err => {\n              if (err) reject(err)\n              else resolve()\n            })\n          })\n        } else if (this._redisClientType === REDIS_V4) {\n          await this.redisClient.set(this.cacheKey, cacheStr, {\n            EX: ttlSeconds,\n          })\n        } else if (this._redisClientType === IOREDIS) {\n          await this.redisClient.setex(this.cacheKey, ttlSeconds, cacheStr)\n        }\n      } catch (redisErr) {\n        console.warn(\n          `[HealthCheckCache] Redis write failed (in-memory cache updated):`,\n          redisErr.message\n        )\n        this._redisAvailable = false\n      }\n    }\n  }\n\n  /**\n   * Clears the cache (both Redis and in-memory).\n   * @returns {Promise<void>}\n   */\n  async clear() {\n    this._memoryCache = null\n    this._memoryCacheTimestamp = null\n\n    if (await this._checkRedisAvailable()) {\n      try {\n        if (this._redisClientType === REDIS_V3) {\n          await new Promise((resolve, reject) => {\n            this.redisClient.del(this.cacheKey, err => {\n              if (err) reject(err)\n              else resolve()\n            })\n          })\n        } else if (\n          this._redisClientType === REDIS_V4 ||\n          this._redisClientType === IOREDIS\n        ) {\n          await this.redisClient.del(this.cacheKey)\n        }\n      } catch (redisErr) {\n        console.warn(`[HealthCheckCache] Redis clear failed:`, redisErr.message)\n      }\n    }\n  }\n\n  /**\n   * Checks if Redis is configured and available.\n   * @returns {boolean}\n   */\n  isRedisAvailable() {\n    return this._redisAvailable && this.redisClient !== null\n  }\n}\n\nmodule.exports = { HealthCheckCache }\n"],"mappings":"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","ignoreList":[]}

package/lib/health/healthCheckClient.d.ts

@@ -0,0 +1,124 @@
+export type HealthResource = {
+    env: string;
+    url?: string;
+} | {
+    env: string;
+    client?: any;
+};
+/**
+ * @typedef {{ env: string, url?: string } | { env: string, client?: any }} HealthResource
+ */
+export class HealthCheckClient {
+    /**
+     * @param {Object} options
+     * @param {HealthResource[]} options.resources - Must include Redis resource with client
+     * @param {Object} [options.config]
+     * @param {string} [options.appName] - For cache key: healthcheck:${appName}
+     * @param {string} [options.cacheKey] - Redis key (overrides appName)
+     */
+    constructor(options?: {
+        resources: HealthResource[];
+        config?: Object | undefined;
+        appName?: string | undefined;
+        cacheKey?: string | undefined;
+    });
+    healthConfig: {
+        constructor?: Function | undefined;
+        toString?: (() => string) | undefined;
+        toLocaleString?: (() => string) | undefined;
+        valueOf?: (() => Object) | undefined;
+        hasOwnProperty?: ((v: PropertyKey) => boolean) | undefined;
+        isPrototypeOf?: ((v: Object) => boolean) | undefined;
+        propertyIsEnumerable?: ((v: PropertyKey) => boolean) | undefined;
+        checkIntervalMs: number;
+        staleThresholdMs: number;
+        checkTimeoutMs: number;
+        maxDbConnectLatencyMs: number;
+    };
+    appName: string;
+    prefixLogs: string;
+    _refreshPromise: any;
+    /** @type {Map<string, { pool: any, type: string }>} */
+    _databasePools: Map<string, {
+        pool: any;
+        type: string;
+    }>;
+    /** @type {HealthResource[]} */
+    _resources: HealthResource[];
+    _redisClientType: string | undefined;
+    _cache: HealthCheckCache;
+    _getEnv(resource: any): any;
+    _getRedisClientForCache(): any;
+    _getPool(env: any, url: any): {
+        pool: any;
+        type: string;
+    } | undefined;
+    _checkDatabase(resource: any): Promise<{
+        status: string;
+        connectMs: number;
+    } | {
+        connectMs?: any;
+        status: string;
+        error: string;
+    }>;
+    _checkRedis(resource: any): Promise<{
+        status: string;
+        error?: undefined;
+    } | {
+        status: string;
+        error: string;
+    }>;
+    _performHealthCheckInternal(): Promise<{
+        status: string;
+        lastCheckAt: number;
+        resources: {};
+        isStale: boolean;
+        config: {
+            constructor?: Function | undefined;
+            toString?: (() => string) | undefined;
+            toLocaleString?: (() => string) | undefined;
+            valueOf?: (() => Object) | undefined;
+            hasOwnProperty?: ((v: PropertyKey) => boolean) | undefined;
+            isPrototypeOf?: ((v: Object) => boolean) | undefined;
+            propertyIsEnumerable?: ((v: PropertyKey) => boolean) | undefined;
+            checkIntervalMs: number;
+            staleThresholdMs: number;
+            checkTimeoutMs: number;
+            maxDbConnectLatencyMs: number;
+        };
+    }>;
+    _formatResult(result: any, cached?: boolean): any;
+    performHealthCheck(): Promise<any>;
+    getCachedResult(): Promise<any>;
+    refreshCache(): Promise<{
+        status: string;
+        lastCheckAt: number;
+        resources: {};
+        isStale: boolean;
+        config: {
+            constructor?: Function | undefined;
+            toString?: (() => string) | undefined;
+            toLocaleString?: (() => string) | undefined;
+            valueOf?: (() => Object) | undefined;
+            hasOwnProperty?: ((v: PropertyKey) => boolean) | undefined;
+            isPrototypeOf?: ((v: Object) => boolean) | undefined;
+            propertyIsEnumerable?: ((v: PropertyKey) => boolean) | undefined;
+            checkIntervalMs: number;
+            staleThresholdMs: number;
+            checkTimeoutMs: number;
+            maxDbConnectLatencyMs: number;
+        };
+    }>;
+    clearCache(): void;
+    healthHandler(): (req: any, res: any) => Promise<void>;
+    cleanup(): Promise<void>;
+}
+/** @type {{ checkIntervalMs: number, staleThresholdMs: number, checkTimeoutMs: number, maxDbConnectLatencyMs: number }} */
+export const DEFAULT_HEALTH_CONFIG: {
+    checkIntervalMs: number;
+    staleThresholdMs: number;
+    checkTimeoutMs: number;
+    maxDbConnectLatencyMs: number;
+};
+import { HealthCheckCache } from "./healthCheckCache";
+//# sourceMappingURL=healthCheckClient.d.ts.map

package/lib/health/healthCheckClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"healthCheckClient.d.ts","sourceRoot":"","sources":["../../src/health/healthCheckClient.js"],"names":[],"mappings":"6BA6Ea;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,GAAG,CAAA;CAAE;AAD1E;;GAEG;AACH;IACE;;;;;;OAMG;IACH;QALqC,SAAS,EAAnC,cAAc,EAAE;QACC,MAAM;QACN,OAAO;QACP,QAAQ;OA2BnC;IAxBC;;;;;;;;;;;;MAAmE;IACnE,gBACgE;IAEhE,mBAAmD;IAEnD,qBAA2B;IAC3B,uDAAuD;IACvD;cAD+B,GAAG;cAAQ,MAAM;OACjB;IAE/B,+BAA+B;IAC/B,YADW,cAAc,EAAE,CACc;IAIvC,qCAAuD;IAGzD,yBAKE;IAGJ,4BAEC;IAED,+BAGC;IAED;cA5BiC,GAAG;cAAQ,MAAM;kBAsCjD;IAED;;;;;;;OAoCC;IAED;;;;;;OA4BC;IAED;;;;;;;;;;;;;;;;;;OA8BC;IAED,kDAeC;IAED,mCAgBC;IAED,gCAiBC;IAED;;;;;;;;;;;;;;;;;;OAIC;IAED,mBAEC;IAED,uDAiCC;IAED,yBASC;CACF;AAhUD,2HAA2H;AAC3H,oCADW;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,qBAAqB,EAAE,MAAM,CAAA;CAAE,CAOtH"}

package/lib/health/healthCheckClient.js

@@ -0,0 +1,324 @@
+"use strict";
+
+const {
+  createDatabasePool,
+  runHealthCheck,
+  closePool
+} = require('./databaseChecker');
+const {
+  getRedisClientType,
+  REDIS_V4,
+  IOREDIS,
+  REDIS_V3
+} = require('../redisUtils');
+const {
+  HealthCheckCache
+} = require('./healthCheckCache');
+
+/**
+ * @param {string} name
+ * @returns {number | undefined}
+ */
+function readNumberEnv(name) {
+  const raw = process.env[name];
+  if (raw == null || raw === '') return undefined;
+  const num = Number(raw);
+  return Number.isFinite(num) ? num : undefined;
+}
+
+/** @type {{ checkIntervalMs: number, staleThresholdMs: number, checkTimeoutMs: number, maxDbConnectLatencyMs: number }} */
+const DEFAULT_HEALTH_CONFIG = {
+  checkIntervalMs: 30_000,
+  staleThresholdMs: 180_000,
+  checkTimeoutMs: 15_000,
+  maxDbConnectLatencyMs: readNumberEnv('HEALTH_DB_MAX_CONNECT_LATENCY_MS') ?? 1000
+};
+const SENSITIVE_PATTERNS = [{
+  pattern: /(postgres(?:ql)?|mysql|mongodb|redis|amqp):\/\/([^:]+):([^@]+)@([^:/]+)(:\d+)?\/([^\s?]+)/gi,
+  replacement: '$1://***:***@***$5/***'
+}, {
+  pattern: /(\w+):\/\/([^:]+):([^@]+)@([^\s/]+)/gi,
+  replacement: '$1://***:***@***'
+}, {
+  pattern: /(password|passwd|pwd|secret|token|api[_-]?key|auth[_-]?token)["\s]*[:=]["\s]*([^\s,}"]+)/gi,
+  replacement: '$1=***'
+}, {
+  pattern: /(database|table|schema|role|user|relation|column|index)\s*["']([^"']+)["']/gi,
+  replacement: '$1 "***"'
+}, {
+  pattern: /\b(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})(:\d+)?\b/g,
+  replacement: '***$2'
+}, {
+  pattern: /\b(host|hostname|server)["\s]*[:=]["\s]*([^\s,}"]+)/gi,
+  replacement: '$1=***'
+}];
+
+/**
+ * @param {string} text
+ * @returns {string}
+ */
+function maskSensitiveData(text) {
+  if (!text || typeof text !== 'string') return text;
+  let masked = text;
+  for (const {
+    pattern,
+    replacement
+  } of SENSITIVE_PATTERNS) {
+    masked = masked.replace(pattern, replacement);
+  }
+  return masked;
+}
+
+/**
+ * @typedef {{ env: string, url?: string } | { env: string, client?: any }} HealthResource
+ */
+class HealthCheckClient {
+  /**
+   * @param {Object} options
+   * @param {HealthResource[]} options.resources - Must include Redis resource with client
+   * @param {Object} [options.config]
+   * @param {string} [options.appName] - For cache key: healthcheck:${appName}
+   * @param {string} [options.cacheKey] - Redis key (overrides appName)
+   */
+  constructor(options = {}) {
+    this.healthConfig = {
+      ...DEFAULT_HEALTH_CONFIG,
+      ...options.config
+    };
+    this.appName = options.appName || process.env.BUILD_APP_NAME || 'unknown-app';
+    this.prefixLogs = `[${this.appName}] [HealthCheck]`;
+    this._refreshPromise = null;
+    /** @type {Map<string, { pool: any, type: string }>} */
+    this._databasePools = new Map();
+
+    /** @type {HealthResource[]} */
+    this._resources = options.resources || [];
+    const redisClient = this._getRedisClientForCache();
+    if (redisClient) {
+      this._redisClientType = getRedisClientType(redisClient);
+    }
+    this._cache = new HealthCheckCache({
+      redisClient: redisClient || null,
+      cacheKey: options.cacheKey,
+      appName: this.appName,
+      staleThresholdMs: this.healthConfig.staleThresholdMs
+    });
+  }
+  _getEnv(resource) {
+    return resource.env ?? resource.name;
+  }
+  _getRedisClientForCache() {
+    const redisResource = this._resources.find(r => 'client' in r && r.client);
+    return redisResource?.client || null;
+  }
+  _getPool(env, url) {
+    if (!this._databasePools.has(env)) {
+      const {
+        pool,
+        type
+      } = createDatabasePool(env, url, this.healthConfig.checkTimeoutMs);
+      this._databasePools.set(env, {
+        pool,
+        type
+      });
+    }
+    return this._databasePools.get(env);
+  }
+  async _checkDatabase(resource) {
+    const env = this._getEnv(resource);
+    const url = 'url' in resource ? resource.url : process.env[env];
+    if (!url) {
+      return {
+        status: 'error',
+        error: `Env ${env} not set`
+      };
+    }
+    try {
+      const {
+        pool,
+        type
+      } = this._getPool(env, url);
+      const timings = await runHealthCheck(pool, type);
+      const maxConnect = this.healthConfig.maxDbConnectLatencyMs;
+      if (typeof maxConnect === 'number' && Number.isFinite(maxConnect) && timings?.connectMs != null && timings.connectMs > maxConnect) {
+        return {
+          status: 'error',
+          error: `DB connect latency ${timings.connectMs}ms exceeds ${maxConnect}ms`,
+          connectMs: timings.connectMs
+        };
+      }
+      return {
+        status: 'ok',
+        connectMs: timings.connectMs
+      };
+    } catch (err) {
+      const timings = err?.healthCheckTimings;
+      return {
+        status: 'error',
+        error: maskSensitiveData(err.message),
+        ...(timings && typeof timings === 'object' ? {
+          connectMs: timings.connectMs
+        } : {})
+      };
+    }
+  }
+  async _checkRedis(resource) {
+    const {
+      client
+    } = resource;
+    if (!client) return {
+      status: 'ok'
+    };
+    try {
+      let pong;
+      if (this._redisClientType === REDIS_V3) {
+        pong = await new Promise((resolve, reject) => {
+          client.ping((err, result) => {
+            if (err) reject(err);else resolve(result);
+          });
+        });
+      } else if (this._redisClientType === REDIS_V4 || this._redisClientType === IOREDIS) {
+        pong = await client.ping();
+      } else {
+        return {
+          status: 'error',
+          error: 'Unknown Redis client type'
+        };
+      }
+      return pong === 'PONG' ? {
+        status: 'ok'
+      } : {
+        status: 'error',
+        error: `Unexpected: ${pong}`
+      };
+    } catch (err) {
+      return {
+        status: 'error',
+        error: maskSensitiveData(err.message)
+      };
+    }
+  }
+  async _performHealthCheckInternal() {
+    const resources = {};
+    for (const resource of this._resources) {
+      const env = this._getEnv(resource);
+      if ('client' in resource && resource.client) {
+        resources[env] = await this._checkRedis(resource);
+      } else {
+        resources[env] = await this._checkDatabase(resource);
+      }
+    }
+    const sortedResources = Object.keys(resources).sort().reduce((acc, key) => {
+      acc[key] = resources[key];
+      return acc;
+    }, {});
+    const hasError = Object.values(resources).some(r => r.status === 'error');
+    const lastCheckAt = Date.now();
+    return {
+      status: hasError ? 'error' : 'ok',
+      lastCheckAt,
+      resources: sortedResources,
+      isStale: false,
+      config: this.healthConfig
+    };
+  }
+  _formatResult(result, cached = false) {
+    const isStale = !result.lastCheckAt || Date.now() - result.lastCheckAt > this.healthConfig.staleThresholdMs;
+    return {
+      ...result,
+      isStale,
+      status: isStale ? 'stale' : result.status,
+      ...(isStale && {
+        error: 'Health check data is stale, health-check worker may not be running. Resource statuses are unknown.'
+      }),
+      ...(cached && {
+        cached: true
+      })
+    };
+  }
+  async performHealthCheck() {
+    if (this._refreshPromise) {
+      return this._refreshPromise;
+    }
+    this._refreshPromise = this._performHealthCheckInternal().then(result => {
+      this._refreshPromise = null;
+      return this._formatResult(result);
+    }).catch(err => {
+      this._refreshPromise = null;
+      throw err;
+    });
+    return this._refreshPromise;
+  }
+  async getCachedResult() {
+    try {
+      const cached = await this._cache.get();
+      if (cached) return this._formatResult(cached);
+      return null;
+    } catch (err) {
+      console.error(`${this.prefixLogs} Failed to read from cache:`, err);
+      return {
+        status: 'error',
+        lastCheckAt: null,
+        resources: {},
+        isStale: true,
+        error: 'Redis unavailable, unable to read health status of other resources',
+        config: this.healthConfig
+      };
+    }
+  }
+  async refreshCache() {
+    const result = await this._performHealthCheckInternal();
+    await this._cache.set(result);
+    return result;
+  }
+  clearCache() {
+    this._refreshPromise = null;
+  }
+  healthHandler() {
+    return async (req, res) => {
+      try {
+        const result = await this.getCachedResult();
+        if (!result) {
+          res.status(503).json({
+            status: 'error',
+            lastCheckAt: null,
+            resources: {},
+            isStale: true,
+            error: 'No health check data yet, health-check worker may not be running',
+            config: this.healthConfig
+          });
+          return;
+        }
+        const statusCode = result.status === 'ok' ? 200 : 503;
+        res.status(statusCode).json(result);
+      } catch (err) {
+        console.error(`${this.prefixLogs} Health check failed:`, err);
+        res.status(503).json({
+          status: 'error',
+          lastCheckAt: null,
+          resources: {},
+          isStale: true,
+          error: 'Redis unavailable, unable to read health status of other resources',
+          config: this.healthConfig
+        });
+      }
+    };
+  }
+  async cleanup() {
+    for (const [, {
+      pool
+    }] of this._databasePools) {
+      try {
+        await closePool(pool);
+      } catch (err) {
+        console.error(`${this.prefixLogs} Error closing database pool:`, err);
+      }
+    }
+    this._databasePools.clear();
+  }
+}
+module.exports = {
+  HealthCheckClient,
+  DEFAULT_HEALTH_CONFIG
+};
+//# sourceMappingURL=healthCheckClient.js.map