Circuit Breaker for Resilient External API Calls

package main

import (	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/afex/hystrix-go/hystrix")

// ExternalAPIClient represents a client for calling an external API
type ExternalAPIClient struct {
	baseURL    string
	timeout    time.Duration
	circuitName string // Unique name for the circuit breaker
}

// NewExternalAPIClient creates a new client with circuit breaker configuration
func NewExternalAPIClient(baseURL string, timeout time.Duration, circuitName string) *ExternalAPIClient {
	// Configure circuit breaker settings
	hystrix.ConfigureCommand(circuitName, hystrix.CommandConfig{
		Timeout:                int(timeout.Milliseconds()), // Request timeout
		MaxConcurrentRequests:  100,                         // Max concurrent calls
		RequestVolumeThreshold: 20,                          // Min requests to trigger circuit check
		SleepWindow:            5000,                        // Time to wait before trying again after open
		ErrorPercentThreshold:  50,                          // Error % to trigger circuit open
	})

	return &ExternalAPIClient{
		baseURL:    baseURL,
		timeout:    timeout,
		circuitName: circuitName,
	}
}

// APIResponse represents a sample response from the external API
type APIResponse struct {
	Data string `json:"data"`
	Status string `json:"status"`
}

// CallAPI makes a resilient API call using the circuit breaker
func (c *ExternalAPIClient) CallAPI(endpoint string) (*APIResponse, error) {
	var response *APIResponse

	// Wrap API call with circuit breaker
	err := hystrix.Do(c.circuitName, func() error {
		// Create HTTP request with timeout
		ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
		defer cancel()

		req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+endpoint, nil)
		if err != nil {
			return fmt.Errorf("failed to create request: %v", err)
		}

		// Send request
		client := &http.Client{}
		resp, err := client.Do(req)
		if err != nil {
			return fmt.Errorf("request failed: %v", err)
		}
		defer resp.Body.Close()

		// Check status code
		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
			return fmt.Errorf("api returned non-200 status: %d", resp.StatusCode)
		}

		// Parse response
		if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
			return fmt.Errorf("failed to parse response: %v", err)
		}

		return nil
	}, func(err error) error {
		// Fallback function: execute when circuit is open or request fails
		log.Printf("Circuit breaker fallback triggered: %v", err)
		// Return a default response or custom error
		response = &APIResponse{
			Data: "fallback data - service unavailable",
			Status: "fallback",
		}
		return nil // Return nil to indicate fallback succeeded
	})

	if err != nil {
		return nil, fmt.Errorf("circuit breaker error: %v", err)
	}

	return response, nil
}

// Example Usage
func main() {
	// Create client for external API (e.g., a weather service)
	client := NewExternalAPIClient(
		"https://api.example.com",
		3*time.Second,
		"weather-api-circuit",
	)

	// Simulate repeated API calls to demonstrate circuit breaker behavior
	for i := 0; i < 50; i++ {
		resp, err := client.CallAPI("/weather?city=London")
		if err != nil {
			log.Printf("Call %d failed: %v", i+1, err)
		} else {
			log.Printf("Call %d succeeded: %+v", i+1, resp)
		}
		time.Sleep(500 * time.Millisecond)
	}
}