Can be isolated in advance when initializing

src/brpc/circuit_breaker.cpp

@@ -64,6 +64,7 @@ CircuitBreaker::EmaErrorRecorder::EmaErrorRecorder(int window_size,
     , _max_error_percent(max_error_percent)
     , _smooth(std::pow(EPSILON, 1.0/window_size))
     , _sample_count(0)
+    , _error_count(0)
     , _ema_error_cost(0)
     , _ema_latency(0) {
 }
@@ -80,8 +81,15 @@ bool CircuitBreaker::EmaErrorRecorder::OnCallEnd(int error_code,
         healthy = UpdateErrorCost(latency, ema_latency);
     }
 
-    if (_sample_count.fetch_add(1, butil::memory_order_relaxed) < _window_size) {
-        return true;
+    // When the window is initializing, use error_rate to determine 
+    // if it needs to be isolated.
+    if (_sample_count.load(butil::memory_order_relaxed) < _window_size &&
+        _sample_count.fetch_add(1, butil::memory_order_relaxed) < _window_size) {
+        if (error_code != 0) {
+            const int32_t error_count =
+                _error_count.fetch_add(1, butil::memory_order_relaxed);
+            return error_count < _window_size * _max_error_percent / 100; 
+        }
     }
 
     return healthy;
@@ -89,6 +97,7 @@ bool CircuitBreaker::EmaErrorRecorder::OnCallEnd(int error_code,
 
 void CircuitBreaker::EmaErrorRecorder::Reset() {
     _sample_count.store(0, butil::memory_order_relaxed);
+    _error_count.store(0, butil::memory_order_relaxed);
     _ema_error_cost.store(0, butil::memory_order_relaxed);
     _ema_latency.store(0, butil::memory_order_relaxed);
 }

src/brpc/circuit_breaker.h

@@ -74,7 +74,8 @@ private:
         const int _max_error_percent;
         const double _smooth;
 
-        butil::atomic<int64_t> _sample_count;
+        butil::atomic<int32_t> _sample_count;
+        butil::atomic<int32_t> _error_count;
         butil::atomic<int64_t> _ema_error_cost;
         butil::atomic<int64_t> _ema_latency;
     };