@brimble/consul 0.0.1

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 };

package/lib/resolver.js

@@ -0,0 +1,290 @@
+"use strict";
+
+const { log } = require("@brimble/utils");
+const {
+  leastConnectionSelection,
+  roundRobinSelection,
+  weightedRandomSelection,
+} = require("./resolver/algorithms");
+const { DNSManager } = require("./resolver/dns");
+const { HealthCheckManager } = require("./resolver/health");
+const { MetricsManager } = require("./resolver/metrics");
+const {
+  combineHealthAndDNSWeights,
+  rankServices,
+} = require("./resolver/scoring");
+const {
+  DEFAULT_METRICS,
+  DEFAULT_WEIGHTS,
+  SelectionAlgorithm,
+} = require("./resolver/types");
+
+class Resolver {
+  constructor(consul, config) {
+    this.consul = consul;
+    this.currentIndex = 0;
+    this.debug = config.debug || false;
+    this.cachePrefix = config.cachePrefix;
+    this.cacheEnabled = config.cacheEnabled;
+    this.weights = config.weights || DEFAULT_WEIGHTS;
+    this.metrics = config.metrics || DEFAULT_METRICS;
+    this.redis = config.redis;
+
+    this.cacheTTL = Math.floor((config.cacheTTL || 60 * 1000) / 1000);
+
+    if (this.cacheEnabled && config.redis) {
+      this.redis = config.redis;
+      this.cacheEnabled = true;
+    }
+
+    this.metricsManager = new MetricsManager(
+      this.redis,
+      this.cachePrefix,
+      this.metrics,
+      this.cacheEnabled,
+      this.debug,
+    );
+
+    this.dnsManager = new DNSManager(
+      this.redis,
+      this.cachePrefix,
+      this.cacheTTL,
+      this.cacheEnabled,
+      this.debug,
+      config.dnsEndpoints,
+      config.dnsTimeout,
+      config.dnsRetries,
+    );
+
+    this.healthCheckManager = new HealthCheckManager(
+      this.consul,
+      this.redis,
+      this.cachePrefix,
+      this.cacheTTL,
+      this.cacheEnabled,
+      this.debug,
+    );
+  }
+
+  /**
+   * Select the optimal service based on the specified algorithm
+   */
+  async selectOptimalService(
+    service,
+    algorithm = SelectionAlgorithm.RoundRobin,
+  ) {
+    try {
+      const [healthChecks, dnsRecords] = await Promise.all([
+        this.healthCheckManager.getHealthChecks(service),
+        this.dnsManager.resolveDNS(service),
+      ]);
+
+      if (
+        (!healthChecks || healthChecks.length === 0) &&
+        dnsRecords.length === 0
+      ) {
+        return { selected: null, services: [] };
+      }
+
+      const sortedByPriority = this.dnsManager.sortByPriority(dnsRecords);
+
+      const lowestPriorityValue = sortedByPriority[0]?.priority;
+      const highestPriorityRecords = sortedByPriority.filter(
+        (record) => record.priority === lowestPriorityValue,
+      );
+
+      if (!healthChecks || healthChecks.length === 0) {
+        const { selected, nextIndex } = this.dnsManager.selectFromSrvRecords(
+          highestPriorityRecords,
+          algorithm,
+          this.currentIndex,
+        );
+        this.currentIndex = nextIndex;
+
+        if (!selected) {
+          return { selected: null, services: [] };
+        }
+
+        await this.metricsManager.updateSelectionMetrics(selected.name);
+
+        return {
+          selected: {
+            ip: selected.ip,
+            port: selected.port,
+          },
+          services: sortedByPriority.map((record) => ({
+            ip: record.ip,
+            port: record.port,
+          })),
+        };
+      }
+
+      const dnsWeights = new Map(
+        dnsRecords.map((record) => [
+          record.ip,
+          {
+            weight: record.weight,
+            port: record.port,
+            priority: record.priority,
+          },
+        ]),
+      );
+
+      const matchedHealthChecks = healthChecks.filter((check) =>
+        dnsWeights.has(check.Service.Address),
+      );
+
+      if (matchedHealthChecks.length === 0) {
+        if (this.debug) {
+          log.debug(
+            "No matching services found between DNS and Consul health checks",
+          );
+        }
+        const { selected, nextIndex } = this.dnsManager.selectFromSrvRecords(
+          highestPriorityRecords,
+          algorithm,
+          this.currentIndex,
+        );
+        this.currentIndex = nextIndex;
+
+        if (!selected) {
+          return { selected: null, services: [] };
+        }
+
+        await this.metricsManager.updateSelectionMetrics(selected.name);
+
+        return {
+          selected: {
+            ip: selected.ip,
+            port: selected.port,
+          },
+          services: sortedByPriority.map((record) => ({
+            ip: record.ip,
+            port: record.port,
+          })),
+        };
+      }
+
+      const highPriorityIPs = new Set(
+        highestPriorityRecords.map((record) => record.ip),
+      );
+      const highPriorityHealthChecks = matchedHealthChecks.filter((check) =>
+        highPriorityIPs.has(check.Service.Address),
+      );
+
+      const targetHealthChecks =
+        highPriorityHealthChecks.length > 0
+          ? highPriorityHealthChecks
+          : matchedHealthChecks;
+
+      const maxDNSWeight = Math.max(...dnsRecords.map((r) => r.weight || 1));
+
+      const enhancedHealthChecks = targetHealthChecks.map((check) => ({
+        ...check,
+        dnsWeight: combineHealthAndDNSWeights(
+          check,
+          dnsWeights.get(check.Service.Address)?.weight || 0,
+          maxDNSWeight,
+        ),
+      }));
+
+      const metrics =
+        await this.metricsManager.getServicesMetrics(targetHealthChecks);
+      let selectedService;
+
+      switch (algorithm) {
+        case SelectionAlgorithm.RoundRobin: {
+          const rrResult = roundRobinSelection(
+            enhancedHealthChecks,
+            this.currentIndex,
+          );
+          this.currentIndex = rrResult.nextIndex;
+          selectedService = { id: rrResult.id, service: rrResult.service };
+          break;
+        }
+        case SelectionAlgorithm.LeastConnection:
+          selectedService = leastConnectionSelection(
+            enhancedHealthChecks,
+            metrics,
+            this.metrics,
+          );
+          break;
+        case SelectionAlgorithm.WeightedRoundRobin: {
+          const rankedServices = rankServices(
+            enhancedHealthChecks,
+            metrics,
+            this.weights,
+          );
+          rankedServices.forEach((ranked) => {
+            const dnsInfo = dnsWeights.get(ranked.service.Service.Address);
+            if (dnsInfo) {
+              ranked.score *= 1 + dnsInfo.weight / maxDNSWeight;
+            }
+          });
+          selectedService = weightedRandomSelection(rankedServices);
+          break;
+        }
+      }
+
+      await this.metricsManager.updateSelectionMetrics(selectedService.id);
+
+      const selectedDNSInfo = dnsWeights.get(
+        selectedService.service.Service.Address,
+      );
+
+      return {
+        selected: {
+          ip: selectedService.service.Service.Address,
+          port: selectedDNSInfo?.port || selectedService.service.Service.Port,
+        },
+        services: matchedHealthChecks.map((check) => {
+          const dnsInfo = dnsWeights.get(check.Service.Address);
+          return {
+            ip: check.Service.Address,
+            port: dnsInfo?.port || check.Service.Port,
+          };
+        }),
+      };
+    } catch (error) {
+      if (this.debug) {
+        log.error("Error selecting optimal service:", error);
+      }
+      return { selected: null, services: [] };
+    }
+  }
+
+  async incrementConnections(serviceId) {
+    return this.metricsManager.incrementConnections(serviceId);
+  }
+
+  async decrementConnections(serviceId) {
+    return this.metricsManager.decrementConnections(serviceId);
+  }
+
+  async getSelectionMetrics(serviceId) {
+    return this.metricsManager.getSelectionMetrics(serviceId);
+  }
+
+  async refresh() {
+    try {
+      if (!this.cacheEnabled) {
+        if (this.debug) {
+          log.debug("Cache is disabled, no need to refresh");
+        }
+        return;
+      }
+      const pattern = `${this.cachePrefix}:*`;
+      const keys = await this.redis?.keys(pattern);
+
+      if (keys && keys.length > 0) {
+        await this.redis?.del(...keys);
+      }
+    } catch (error) {
+      console.log("Error refreshing Redis caches:", error);
+      throw new Error(`Failed to refresh caches: ${error.message}`);
+    }
+  }
+}
+
+exports.Resolver = Resolver;
+exports.SelectionAlgorithm = SelectionAlgorithm;