ax(mining): rename cb receiver to circuitBreaker in CircuitBreaker methods

AX Principle 1: predictable names over short names. The receiver abbreviation
`cb` required mapping overhead — replaced with the full `circuitBreaker` name
across all eight methods in circuit_breaker.go.

Co-Authored-By: Charon <charon@lethean.io>

pkg/mining/circuit_breaker.go

@@ -77,29 +77,29 @@ func NewCircuitBreaker(name string, config CircuitBreakerConfig) *CircuitBreaker
 	}
 }
 
-// if cb.State() == CircuitOpen { return nil, ErrCircuitOpen }
-func (cb *CircuitBreaker) State() CircuitState {
-	cb.mutex.RLock()
-	defer cb.mutex.RUnlock()
-	return cb.state
+// if circuitBreaker.State() == CircuitOpen { return nil, ErrCircuitOpen }
+func (circuitBreaker *CircuitBreaker) State() CircuitState {
+	circuitBreaker.mutex.RLock()
+	defer circuitBreaker.mutex.RUnlock()
+	return circuitBreaker.state
 }
 
-// result, err := cb.Execute(func() (interface{}, error) { return fetchStats(ctx) })
-func (cb *CircuitBreaker) Execute(fn func() (interface{}, error)) (interface{}, error) {
+// result, err := circuitBreaker.Execute(func() (interface{}, error) { return fetchStats(ctx) })
+func (circuitBreaker *CircuitBreaker) Execute(fn func() (interface{}, error)) (interface{}, error) {
 	// Check if we should allow this request
-	if !cb.allowRequest() {
+	if !circuitBreaker.allowRequest() {
 		// Return cached result if available
-		cb.mutex.RLock()
-		if cb.cachedResult != nil && time.Since(cb.lastCacheTime) < cb.cacheDuration {
-			result := cb.cachedResult
-			cb.mutex.RUnlock()
+		circuitBreaker.mutex.RLock()
+		if circuitBreaker.cachedResult != nil && time.Since(circuitBreaker.lastCacheTime) < circuitBreaker.cacheDuration {
+			result := circuitBreaker.cachedResult
+			circuitBreaker.mutex.RUnlock()
 			logging.Debug("circuit breaker returning cached result", logging.Fields{
-				"name":  cb.name,
-				"state": cb.state.String(),
+				"name":  circuitBreaker.name,
+				"state": circuitBreaker.state.String(),
 			})
 			return result, nil
 		}
-		cb.mutex.RUnlock()
+		circuitBreaker.mutex.RUnlock()
 		return nil, ErrCircuitOpen
 	}
 
@@ -108,30 +108,30 @@ func (cb *CircuitBreaker) Execute(fn func() (interface{}, error)) (interface{},
 
 	// Record the result
 	if err != nil {
-		cb.recordFailure()
+		circuitBreaker.recordFailure()
 	} else {
-		cb.recordSuccess(result)
+		circuitBreaker.recordSuccess(result)
 	}
 
 	return result, err
 }
 
-// if cb.allowRequest() { /* execute the function */ }
-func (cb *CircuitBreaker) allowRequest() bool {
-	cb.mutex.Lock()
-	defer cb.mutex.Unlock()
+// if circuitBreaker.allowRequest() { /* execute the function */ }
+func (circuitBreaker *CircuitBreaker) allowRequest() bool {
+	circuitBreaker.mutex.Lock()
+	defer circuitBreaker.mutex.Unlock()
 
-	switch cb.state {
+	switch circuitBreaker.state {
 	case CircuitClosed:
 		return true
 
 	case CircuitOpen:
 		// Check if we should transition to half-open
-		if time.Since(cb.lastFailure) > cb.config.ResetTimeout {
-			cb.state = CircuitHalfOpen
-			cb.successes = 0
+		if time.Since(circuitBreaker.lastFailure) > circuitBreaker.config.ResetTimeout {
+			circuitBreaker.state = CircuitHalfOpen
+			circuitBreaker.successes = 0
 			logging.Info("circuit breaker transitioning to half-open", logging.Fields{
-				"name": cb.name,
+				"name": circuitBreaker.name,
 			})
 			return true
 		}
@@ -146,80 +146,80 @@ func (cb *CircuitBreaker) allowRequest() bool {
 	}
 }
 
-// cb.recordFailure() // increments failures; opens circuit after FailureThreshold is reached
-func (cb *CircuitBreaker) recordFailure() {
-	cb.mutex.Lock()
-	defer cb.mutex.Unlock()
+// circuitBreaker.recordFailure() // increments failures; opens circuit after FailureThreshold is reached
+func (circuitBreaker *CircuitBreaker) recordFailure() {
+	circuitBreaker.mutex.Lock()
+	defer circuitBreaker.mutex.Unlock()
 
-	cb.failures++
-	cb.lastFailure = time.Now()
+	circuitBreaker.failures++
+	circuitBreaker.lastFailure = time.Now()
 
-	switch cb.state {
+	switch circuitBreaker.state {
 	case CircuitClosed:
-		if cb.failures >= cb.config.FailureThreshold {
-			cb.state = CircuitOpen
+		if circuitBreaker.failures >= circuitBreaker.config.FailureThreshold {
+			circuitBreaker.state = CircuitOpen
 			logging.Warn("circuit breaker opened", logging.Fields{
-				"name":     cb.name,
-				"failures": cb.failures,
+				"name":     circuitBreaker.name,
+				"failures": circuitBreaker.failures,
 			})
 		}
 
 	case CircuitHalfOpen:
 		// Probe failed, back to open
-		cb.state = CircuitOpen
+		circuitBreaker.state = CircuitOpen
 		logging.Warn("circuit breaker probe failed, reopening", logging.Fields{
-			"name": cb.name,
+			"name": circuitBreaker.name,
 		})
 	}
 }
 
-// cb.recordSuccess(stats) // caches result, resets failures; in HalfOpen closes the circuit after SuccessThreshold
-func (cb *CircuitBreaker) recordSuccess(result interface{}) {
-	cb.mutex.Lock()
-	defer cb.mutex.Unlock()
+// circuitBreaker.recordSuccess(stats) // caches result, resets failures; in HalfOpen closes the circuit after SuccessThreshold
+func (circuitBreaker *CircuitBreaker) recordSuccess(result interface{}) {
+	circuitBreaker.mutex.Lock()
+	defer circuitBreaker.mutex.Unlock()
 
 	// Cache the successful result
-	cb.cachedResult = result
-	cb.lastCacheTime = time.Now()
-	cb.cachedErr = nil
+	circuitBreaker.cachedResult = result
+	circuitBreaker.lastCacheTime = time.Now()
+	circuitBreaker.cachedErr = nil
 
-	switch cb.state {
+	switch circuitBreaker.state {
 	case CircuitClosed:
 		// Reset failure count on success
-		cb.failures = 0
+		circuitBreaker.failures = 0
 
 	case CircuitHalfOpen:
-		cb.successes++
-		if cb.successes >= cb.config.SuccessThreshold {
-			cb.state = CircuitClosed
-			cb.failures = 0
+		circuitBreaker.successes++
+		if circuitBreaker.successes >= circuitBreaker.config.SuccessThreshold {
+			circuitBreaker.state = CircuitClosed
+			circuitBreaker.failures = 0
 			logging.Info("circuit breaker closed after successful probe", logging.Fields{
-				"name": cb.name,
+				"name": circuitBreaker.name,
 			})
 		}
 	}
 }
 
-// cb.Reset() // force closed state after maintenance window
-func (cb *CircuitBreaker) Reset() {
-	cb.mutex.Lock()
-	defer cb.mutex.Unlock()
+// circuitBreaker.Reset() // force closed state after maintenance window
+func (circuitBreaker *CircuitBreaker) Reset() {
+	circuitBreaker.mutex.Lock()
+	defer circuitBreaker.mutex.Unlock()
 
-	cb.state = CircuitClosed
-	cb.failures = 0
-	cb.successes = 0
+	circuitBreaker.state = CircuitClosed
+	circuitBreaker.failures = 0
+	circuitBreaker.successes = 0
 	logging.Debug("circuit breaker manually reset", logging.Fields{
-		"name": cb.name,
+		"name": circuitBreaker.name,
 	})
 }
 
-// if result, ok := cb.GetCached(); ok { return result, nil }
-func (cb *CircuitBreaker) GetCached() (interface{}, bool) {
-	cb.mutex.RLock()
-	defer cb.mutex.RUnlock()
+// if result, ok := circuitBreaker.GetCached(); ok { return result, nil }
+func (circuitBreaker *CircuitBreaker) GetCached() (interface{}, bool) {
+	circuitBreaker.mutex.RLock()
+	defer circuitBreaker.mutex.RUnlock()
 
-	if cb.cachedResult != nil && time.Since(cb.lastCacheTime) < cb.cacheDuration {
-		return cb.cachedResult, true
+	if circuitBreaker.cachedResult != nil && time.Since(circuitBreaker.lastCacheTime) < circuitBreaker.cacheDuration {
+		return circuitBreaker.cachedResult, true
 	}
 	return nil, false
 }