@brimble/consul 1.0.0 → 1.0.2

package/lib/resolver/dns.js

@@ -0,0 +1,182 @@
+"use strict";
+
+const { log } = require("@brimble/utils");
+const { query } = require("dns-query");
+const {
+  roundRobinSrvSelection,
+  weightedSrvRecordSelection,
+} = require("./algorithms");
+const { SelectionAlgorithm } = require("./types");
+
+class DNSManager {
+  constructor(
+    redis,
+    cachePrefix,
+    cacheTTL,
+    cacheEnabled,
+    debug,
+    dnsEndpoints,
+    dnsTimeout,
+    dnsRetries,
+  ) {
+    this.redis = redis;
+    this.cachePrefix = cachePrefix;
+    this.cacheTTL = cacheTTL;
+    this.cacheEnabled = cacheEnabled;
+    this.debug = debug;
+    this.dnsEndpoints = dnsEndpoints;
+    this.dnsTimeout = dnsTimeout;
+    this.dnsRetries = dnsRetries;
+  }
+
+  getDNSCacheKey(service) {
+    return `${this.cachePrefix}:dns:${service}`;
+  }
+
+  async resolveDNS(service) {
+    const cacheKey = this.getDNSCacheKey(service);
+
+    if (this.cacheEnabled) {
+      try {
+        const cachedData = await Promise.race([
+          this.redis?.get(cacheKey),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error("Redis get timeout")), 200),
+          ),
+        ]);
+        if (cachedData) {
+          if (this.debug) {
+            log.debug(`DNS cache hit for ${service}`);
+          }
+          return JSON.parse(cachedData);
+        }
+      } catch (e) {
+        if (this.debug) log.error("Redis get error or timeout:", e);
+      }
+    }
+
+    try {
+      const result = await query(
+        {
+          question: {
+            type: "SRV",
+            name: service,
+          },
+        },
+        {
+          endpoints: this.dnsEndpoints,
+          timeout: this.dnsTimeout ?? 1500,
+          retries: this.dnsRetries ?? 2,
+        },
+      );
+
+      if (this.debug) {
+        log.debug("DNS QUERY RESULT", result);
+      }
+
+      if (!result.answers || result.answers.length === 0) {
+        if (this.debug) {
+          log.debug(`No SRV records found for ${service}`);
+        }
+        return [];
+      }
+
+      const additionalsByName = {};
+      if (result.additionals) {
+        for (const additional of result.additionals) {
+          if (additional.type === "A") {
+            additionalsByName[additional.name] = additional;
+          }
+        }
+      }
+      const records = result.answers
+        .map((answer) => {
+          const target = answer.data.target;
+          const aRecord = additionalsByName[target];
+          return {
+            name: target,
+            ip: aRecord?.data || "",
+            port: answer.data.port,
+            priority: answer.data.priority,
+            weight: answer.data.weight,
+          };
+        })
+        .filter((record) => record.ip);
+
+      if (this.cacheEnabled) {
+        try {
+          await Promise.race([
+            this.redis?.set(
+              cacheKey,
+              JSON.stringify(records),
+              "EX",
+              this.cacheTTL,
+            ),
+            new Promise((_, reject) =>
+              setTimeout(() => reject(new Error("Redis set timeout")), 200),
+            ),
+          ]);
+        } catch (e) {
+          if (this.debug) log.error("Redis set error or timeout:", e);
+        }
+      }
+
+      return records;
+    } catch (error) {
+      if (this.debug) {
+        log.error("DNS resolution error:", error);
+      }
+      return [];
+    }
+  }
+
+  sortByPriority(records) {
+    return [...records].sort((a, b) => (a.priority || 0) - (b.priority || 0));
+  }
+
+  selectFromSrvRecords(records, algorithm, currentIndex) {
+    if (!records || records.length === 0) {
+      return { selected: null, nextIndex: currentIndex };
+    }
+
+    switch (algorithm) {
+      case SelectionAlgorithm.RoundRobin: {
+        const rrResult = roundRobinSrvSelection(records, currentIndex);
+        if (!rrResult) {
+          return { selected: null, nextIndex: currentIndex };
+        }
+        return {
+          selected: rrResult.selected,
+          nextIndex: rrResult.nextIndex,
+        };
+      }
+
+      case SelectionAlgorithm.WeightedRoundRobin: {
+        const wrResult = weightedSrvRecordSelection(records, currentIndex);
+        if (!wrResult) {
+          return { selected: null, nextIndex: currentIndex };
+        }
+        return {
+          selected: wrResult.selected,
+          nextIndex: wrResult.nextIndex,
+        };
+      }
+
+      case SelectionAlgorithm.LeastConnection: {
+        const lcResult = roundRobinSrvSelection(records, currentIndex);
+        if (!lcResult) {
+          return { selected: null, nextIndex: currentIndex };
+        }
+        return {
+          selected: lcResult.selected,
+          nextIndex: lcResult.nextIndex,
+        };
+      }
+
+      default:
+        return { selected: records[0], nextIndex: currentIndex };
+    }
+  }
+}
+
+exports.DNSManager = DNSManager;

package/lib/resolver/health.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const { log } = require("@brimble/utils");
+
+class HealthCheckManager {
+  constructor(consul, redis, cachePrefix, cacheTTL, cacheEnabled, debug) {
+    this.consul = consul;
+    this.redis = redis;
+    this.cachePrefix = cachePrefix;
+    this.cacheTTL = cacheTTL;
+    this.cacheEnabled = cacheEnabled;
+    this.debug = debug;
+  }
+
+  getHealthCacheKey(service) {
+    return `${this.cachePrefix}:health:${service}`;
+  }
+
+  async getHealthChecks(service) {
+    const cacheKey = this.getHealthCacheKey(service);
+
+    if (this.cacheEnabled) {
+      const cachedHealth = await this.redis?.get(cacheKey);
+      if (cachedHealth) {
+        return JSON.parse(cachedHealth);
+      }
+    }
+
+    try {
+      const healthChecks = await this.consul.health.service(service);
+
+      if (this.cacheEnabled) {
+        await this.redis?.set(
+          cacheKey,
+          JSON.stringify(healthChecks),
+          "EX",
+          this.cacheTTL,
+        );
+      }
+
+      return healthChecks;
+    } catch (error) {
+      if (this.debug) {
+        log.error(`Error fetching health checks for ${service}:`, error);
+      }
+      return [];
+    }
+  }
+}
+
+exports.HealthCheckManager = HealthCheckManager;

package/lib/resolver/metrics.js

@@ -0,0 +1,199 @@
+"use strict";
+
+const { log } = require("@brimble/utils");
+
+class MetricsManager {
+  constructor(redis, cachePrefix, metrics, cacheEnabled, debug) {
+    this.redis = redis;
+    this.cachePrefix = cachePrefix;
+    this.metrics = metrics;
+    this.cacheEnabled = cacheEnabled;
+    this.debug = debug;
+  }
+
+  getConnectionKey(serviceId) {
+    return `${this.cachePrefix}:connections:${serviceId}`;
+  }
+
+  async getServicesMetrics(services) {
+    const metricsMap = new Map();
+    const pipeline = this.redis?.pipeline();
+
+    if (this.cacheEnabled) {
+      services.forEach((service) => {
+        pipeline?.get(service.Service.ID);
+        pipeline?.get(this.getConnectionKey(service.Service.ID));
+      });
+    }
+
+    try {
+      const results = await pipeline?.exec();
+      if (!results) {
+        services.forEach((service) => {
+          metricsMap.set(service.Service.ID, { ...this.metrics });
+        });
+        return metricsMap;
+      }
+
+      services.forEach((service, index) => {
+        const serviceId = service.Service.ID;
+        const metricsResult = results[index * 2];
+        const connectionsResult = results[index * 2 + 1];
+
+        let metrics;
+
+        try {
+          if (metricsResult?.[1]) {
+            metrics = JSON.parse(metricsResult[1]);
+          } else {
+            metrics = { ...this.metrics };
+          }
+
+          if (connectionsResult?.[1]) {
+            const connData = JSON.parse(connectionsResult[1]);
+            metrics.activeConnections = connData.activeConnections || 0;
+          }
+
+          metricsMap.set(serviceId, metrics);
+        } catch (error) {
+          if (this.debug) {
+            log.error(
+              `Error processing metrics for service ${serviceId}:`,
+              error,
+            );
+          }
+          metricsMap.set(serviceId, { ...this.metrics });
+        }
+      });
+    } catch (error) {
+      if (this.debug) {
+        log.error("Error executing Redis pipeline:", error);
+      }
+      services.forEach((service) => {
+        metricsMap.set(service.Service.ID, { ...this.metrics });
+      });
+    }
+
+    return metricsMap;
+  }
+
+  async incrementConnections(serviceId) {
+    try {
+      const connectionKey = this.getConnectionKey(serviceId);
+      const existingMetrics = await this.redis?.get(connectionKey);
+      let metrics;
+
+      if (existingMetrics) {
+        metrics = JSON.parse(existingMetrics);
+        metrics.activeConnections = (metrics.activeConnections || 0) + 1;
+      } else {
+        metrics = {
+          ...this.metrics,
+          activeConnections: 1,
+        };
+      }
+
+      if (this.cacheEnabled) {
+        await this.redis?.set(
+          connectionKey,
+          JSON.stringify(metrics),
+          "EX",
+          24 * 60 * 60,
+        );
+      }
+    } catch (error) {
+      if (this.debug) {
+        log.error(
+          `Failed to increment connections for service ${serviceId}:`,
+          error,
+        );
+      }
+    }
+  }
+
+  async decrementConnections(serviceId) {
+    try {
+      const connectionKey = this.getConnectionKey(serviceId);
+      const existingMetrics = await this.redis?.get(connectionKey);
+      let metrics;
+
+      if (existingMetrics) {
+        metrics = JSON.parse(existingMetrics);
+        metrics.activeConnections = Math.max(
+          0,
+          (metrics.activeConnections || 1) - 1,
+        );
+      } else {
+        metrics = {
+          ...this.metrics,
+          activeConnections: 0,
+        };
+      }
+
+      if (this.cacheEnabled) {
+        await this.redis?.set(
+          connectionKey,
+          JSON.stringify(metrics),
+          "EX",
+          24 * 60 * 60,
+        );
+      }
+    } catch (error) {
+      if (this.debug) {
+        log.error(
+          `Failed to decrement connections for service ${serviceId}:`,
+          error,
+        );
+      }
+    }
+  }
+
+  async updateSelectionMetrics(serviceId) {
+    try {
+      const connectionKey = this.getConnectionKey(serviceId);
+      const existingMetrics = await this.redis?.get(connectionKey);
+      let metrics;
+
+      if (existingMetrics) {
+        metrics = JSON.parse(existingMetrics);
+      } else {
+        metrics = { ...this.metrics };
+      }
+
+      metrics.lastSelectedTime = Date.now();
+
+      if (this.cacheEnabled) {
+        await this.redis?.set(
+          connectionKey,
+          JSON.stringify(metrics),
+          "EX",
+          24 * 60 * 60,
+        );
+      }
+    } catch (error) {
+      if (this.debug) {
+        log.error(
+          `Failed to update selection metrics for service ${serviceId}:`,
+          error,
+        );
+      }
+    }
+  }
+
+  async getSelectionMetrics(serviceId) {
+    try {
+      if (!this.cacheEnabled) {
+        return null;
+      }
+      const metrics = await this.redis?.get(this.getConnectionKey(serviceId));
+      return metrics ? JSON.parse(metrics) : null;
+    } catch (error) {
+      if (this.debug) {
+        log.error("Error getting service metrics:", error);
+      }
+      return null;
+    }
+  }
+}
+
+exports.MetricsManager = MetricsManager;

package/lib/resolver/scoring.js

@@ -0,0 +1,95 @@
+"use strict";
+
+const { DEFAULT_WEIGHTS } = require("./types");
+
+function calculateHealthScore(service) {
+  const checks = service.Checks;
+  const totalChecks = checks.length;
+  if (totalChecks === 0) return 0;
+
+  const passingChecks = checks.filter(
+    (check) => check.Status === "passing",
+  ).length;
+  return passingChecks / totalChecks;
+}
+
+function normalizeScore(value, max, inverse = false) {
+  const normalized = Math.max(0, Math.min(1, value / max));
+  return inverse ? 1 - normalized : normalized;
+}
+
+function calculateResourceScore(metrics) {
+  const cpuScore = normalizeScore(metrics.cpuUsage, 100, true);
+  const memoryScore = normalizeScore(metrics.memoryUsage, 100, true);
+  return (cpuScore + memoryScore) / 2;
+}
+
+function calculateDistributionScore(lastSelectedTime) {
+  if (!lastSelectedTime) return 1;
+
+  const timeSinceLastSelection = Date.now() - lastSelectedTime;
+
+  return Math.min(timeSinceLastSelection / (5 * 60 * 1000), 1);
+}
+
+function rankServices(services, metrics, weights = DEFAULT_WEIGHTS) {
+  return services
+    .map((service) => {
+      const serviceId = service.Service.ID;
+
+      const serviceMetrics = metrics.get(serviceId);
+
+      if (!serviceMetrics) {
+        throw new Error(`No metrics found for service ${serviceId}`);
+      }
+
+      const healthScore = calculateHealthScore(service);
+      const responseTimeScore = normalizeScore(
+        serviceMetrics.responseTime,
+        500,
+        true,
+      );
+      const errorRateScore = normalizeScore(
+        serviceMetrics.errorRate,
+        100,
+        true,
+      );
+      const resourceScore = calculateResourceScore(serviceMetrics);
+      const connectionScore = normalizeScore(
+        serviceMetrics.activeConnections,
+        1000,
+        true,
+      );
+      const distributionScore = calculateDistributionScore(
+        serviceMetrics.lastSelectedTime,
+      );
+
+      const totalScore =
+        healthScore * weights.health +
+        responseTimeScore * weights.responseTime +
+        errorRateScore * weights.errorRate +
+        resourceScore * weights.resources +
+        connectionScore * weights.connections +
+        distributionScore * weights.distribution;
+
+      return {
+        score: totalScore,
+        id: serviceId,
+        service,
+      };
+    })
+    .sort((a, b) => b.score - a.score);
+}
+
+function combineHealthAndDNSWeights(service, dnsWeight, maxDNSWeight) {
+  const healthScore = calculateHealthScore(service);
+  const normalizedDNSWeight = dnsWeight / maxDNSWeight;
+  return healthScore * 0.7 + normalizedDNSWeight * 0.3;
+}
+
+exports.calculateHealthScore = calculateHealthScore;
+exports.calculateResourceScore = calculateResourceScore;
+exports.calculateDistributionScore = calculateDistributionScore;
+exports.normalizeScore = normalizeScore;
+exports.rankServices = rankServices;
+exports.combineHealthAndDNSWeights = combineHealthAndDNSWeights;

package/lib/resolver/types.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const DEFAULT_WEIGHTS = {
+  health: 0.25,
+  responseTime: 0.2,
+  errorRate: 0.2,
+  resources: 0.15,
+  connections: 0.1,
+  distribution: 0.1,
+};
+
+const DEFAULT_METRICS = {
+  responseTime: 100,
+  errorRate: 0,
+  cpuUsage: 50,
+  memoryUsage: 50,
+  activeConnections: 0,
+};
+
+const SelectionAlgorithm = {
+  RoundRobin: "round-robin",
+  LeastConnection: "least-connection",
+  WeightedRoundRobin: "weighted-round-robin",
+};
+
+exports.DEFAULT_WEIGHTS = DEFAULT_WEIGHTS;
+exports.DEFAULT_METRICS = DEFAULT_METRICS;
+exports.SelectionAlgorithm = SelectionAlgorithm;

package/lib/resolver.d.ts

@@ -0,0 +1,76 @@
+import { Agent as httpAgent } from "http";
+import { Agent as httpsAgent } from "https";
+import { Redis as IORedis } from "ioredis";
+import { Consul } from "./consul";
+
+export interface ConsulResolverConfig {
+  redis?: IORedis;
+  cacheEnabled: boolean;
+  cachePrefix: string;
+  debug?: boolean;
+  weights?: {
+    health: number;
+    responseTime: number;
+    errorRate: number;
+    resources: number;
+    connections: number;
+    distribution: number;
+  };
+  metrics?: {
+    responseTime: number;
+    errorRate: number;
+    cpuUsage: number;
+    memoryUsage: number;
+    activeConnections: number;
+  };
+  cacheTTL?: number;
+  dnsEndpoints?: string[];
+  dnsTimeout?: number;
+  dnsRetries?: number;
+}
+
+export interface ServiceInfo {
+  ip: string;
+  port: number;
+}
+
+export interface OptimalServiceResult {
+  selected: ServiceInfo | null;
+  services: ServiceInfo[];
+}
+
+export interface ServiceMetrics {
+  responseTime: number;
+  errorRate: number;
+  cpuUsage: number;
+  memoryUsage: number;
+  activeConnections: number;
+  lastSelectedTime?: number;
+}
+
+export enum SelectionAlgorithm {
+  RoundRobin = "round-robin",
+  LeastConnection = "least-connection",
+  WeightedRoundRobin = "weighted-round-robin",
+}
+
+declare class Resolver {
+  constructor(consul: Consul, config: ConsulResolverConfig);
+
+  consul: Consul;
+
+  selectOptimalService(
+    service: string,
+    algorithm?: SelectionAlgorithm,
+  ): Promise<OptimalServiceResult>;
+
+  incrementConnections(serviceId: string): Promise<void>;
+
+  decrementConnections(serviceId: string): Promise<void>;
+
+  getSelectionMetrics(serviceId: string): Promise<ServiceMetrics | null>;
+
+  refresh(): Promise<void>;
+}
+
+export { Resolver };