Service Discovery & Health Checks

# Python Service Registration & Background Heartbeat Loop
import asyncio
import httpx

class ConsulClient:
    def __init__(self, service_name: str, ip: str, port: int, consul_url: str):
        self.service_name = service_name
        self.instance_id = f"{service_name}-{ip}:{port}"
        self.ip = ip
        self.port = port
        self.consul_url = consul_url
        self.is_running = True

    async def register(self):
        payload = {
            "ID": self.instance_id,
            "Name": self.service_name,
            "Address": self.ip,
            "Port": self.port,
            "Check": {"TTL": "30s", "DeregisterCriticalServiceAfter": "90s"}
        }
        async with httpx.AsyncClient() as client:
            await client.put(f"{self.consul_url}/v1/agent/service/register", json=payload)
        asyncio.create_task(self.start_heartbeat())

    async def start_heartbeat(self):
        async with httpx.AsyncClient() as client:
            while self.is_running:
                await client.put(f"{self.consul_url}/v1/agent/check/pass/service:{self.instance_id}")
                await asyncio.sleep(10)  # Heartbeat every 10 seconds

// C++20 Discovery Client with Background Thread
#include <thread>
#include <atomic>

class DiscoveryClient {
    std::string serviceId;
    std::atomic<bool> running{true};
    std::thread heartbeatThread;
public:
    DiscoveryClient(const std::string& id) : serviceId(id) {
        registerService();
        heartbeatThread = std::thread([this]() {
            while (running) {
                sendHeartbeat(serviceId);
                std::this_thread::sleep_for(std::chrono::seconds(10));
            }
        });
    }
    ~DiscoveryClient() {
        running = false;
        if (heartbeatThread.joinable()) heartbeatThread.join();
        deregisterService(serviceId);
    }
};

// Java Spring Cloud Eureka Client
@SpringBootApplication
@EnableDiscoveryClient
public class PaymentServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(PaymentServiceApplication.class, args);
    }

    // Automatically registers with Eureka and sends heartbeats every 30s
    @Bean
    @LoadBalanced
    public WebClient.Builder loadBalancedWebClientBuilder() {
        return WebClient.builder();
    }
}

// Go Consul Registration & Heartbeat Goroutine
package main

import (
    "github.com/hashicorp/consul/api"
    "time"
)

func RegisterAndHeartbeat(client *api.Client, id, name, ip string, port int) {
    reg := &api.AgentServiceRegistration{
        ID:      id,
        Name:    name,
        Address: ip,
        Port:    port,
        Check: &api.AgentServiceCheck{
            TTL:                            "30s",
            DeregisterCriticalServiceAfter: "90s",
        },
    }
    _ = client.Agent().ServiceRegister(reg)

    go func() {
        for {
            _ = client.Agent().PassTTL("service:"+id, "healthy")
            time.Sleep(10 * time.Second)
        }
    }()
}

// TypeScript Dynamic Service Registry Resolver
export class ServiceResolver {
  private cache = new Map<string, string[]>();
  private index = 0;

  async resolve(serviceName: string): Promise<string> {
    let instances = this.cache.get(serviceName) || [];
    if (instances.length === 0) {
      instances = await this.fetchFromConsul(serviceName);
      this.cache.set(serviceName, instances);
    }
    // Client-side Round Robin
    const selected = instances[this.index % instances.length];
    this.index++;
    return selected;
  }
}