The load balancer should understand that the backend responds with errors, and after exceeding a threshold for a certain period, exclude it from balancing (Circuit Breaker).

To implement a load balancer with Circuit Breaker support in Go, you need to monitor the state of each backend and consider the number of errors over a certain period. When the error threshold is exceeded, the service is marked as "disconnected" and excluded from load balancing for a period.

Main steps:

1. Store an error counter and state (Closed, Open, Half-Open) for each backend.
2. Increment the counter on errors.
3. If the number of errors exceeds the threshold within a given interval, change the state to Open — the backend is excluded.
4. After some time, change to Half-Open — try sending requests.
5. If requests succeed, change to Closed, resetting counters.

Example of a simplified structure:

 type CircuitBreaker struct {
     failureCount int
     state        string // "Closed", "Open", "Half-Open"
     lastFailure  time.Time
     mutex        sync.Mutex
 }

 func (cb *CircuitBreaker) AllowRequest() bool {
     cb.mutex.Lock()
     defer cb.mutex.Unlock()
     if cb.state == "Open" && time.Since(cb.lastFailure) < cooldown {
         return false
     }
     if cb.state == "Open" {
         cb.state = "Half-Open"
     }
     return true
 }

 func (cb *CircuitBreaker) ReportResult(success bool) {
     cb.mutex.Lock()
     defer cb.mutex.Unlock()
     if success {
         cb.failureCount = 0
         cb.state = "Closed"
     } else {
         cb.failureCount++
         cb.lastFailure = time.Now()
         if cb.failureCount >= failureThreshold {
             cb.state = "Open"
         }
     }
 }

The load balancer checks AllowRequest() for each backend and excludes those with the "Open" state during request distribution.