feat: added a consecutive error circuit breaker

Makefile

@@ -0,0 +1,4 @@
+test:
+	go test -race
+	go test -coverprofile=coverage.out
+	go tool cover -html=coverage.out -o coverage.html

README.md

@@ -56,7 +56,28 @@ if err != nil {
 circuitOptions := tripper.CircuitOptions{
     Name:              "example-circuit",
     Threshold:         10,
-    ThresholdType:     tripper.ThresholdCount,
+    ThresholdType:     tripper.ThresholdPercentage,
+    MinimumCount:      100,
+    IntervalInSeconds: 60,
+    OnCircuitOpen:     onCircuitOpenCallback,
+    OnCircuitClosed:   onCircuitClosedCallback,
+}
+
+circuit, err := tripper.ConfigureCircuit(circuitOptions)
+if err != nil {
+    fmt.Println("Failed to add circuit:", err)
+    return
+}
+```
+
+#### Circuit With Consecutive Errors
+```go
+//Adding a circuit that will trip the circuit if 10 consecutive erros occur in 1 minute
+//for a minimum of 100 count
+circuitOptions := tripper.CircuitOptions{
+    Name:              "example-circuit",
+    Threshold:         10,
+    ThresholdType:     tripper.ThresholdConsecutive,
     MinimumCount:      100,
     IntervalInSeconds: 60,
     OnCircuitOpen:     onCircuitOpenCallback,
@@ -69,6 +90,7 @@ if err != nil {
     return
 }
 ```
+
 #### Circuit with Callbacks
 ```go
 func onCircuitOpenCallback(x tripper.CallbackEvent){
@@ -105,7 +127,7 @@ if err != nil {
 |---------------------|--------------------------------------------------------------|----------|------------|
 | `Name`              | The name of the circuit.                                     | Required | `string`   |
 | `Threshold`         | The threshold value for the circuit.                          | Required | `float32` |
-| `ThresholdType`     | The type of threshold (`ThresholdCount` or `ThresholdPercentage`). | Required | `string`  |
+| `ThresholdType`     | The type of threshold (`ThresholdCount` or `ThresholdPercentage`or `ThresholdConsecutive`). | Required | `string`  |
 | `MinimumCount`      | The minimum number of events required for monitoring.         | Required | `int64`   |
 | `IntervalInSeconds` | The time interval for monitoring in seconds.                  | Required | `int`     |
 | `OnCircuitOpen`     | Callback function called when the circuit opens.              | Optional | `func()`  |

tripper.go

@@ -9,11 +9,12 @@ import (
 // threshold type can be only COUNT or PERCENTAGE
 // ThresholdCount represents a threshold type based on count.
 const (
-	ThresholdCount      = "COUNT"
-	ThresholdPercentage = "PERCENTAGE"
+	ThresholdCount       = "COUNT"
+	ThresholdPercentage  = "PERCENTAGE"
+	ThresholdConsecutive = "CONSECUTIVE"
 )
 
-var thresholdTypes = []string{ThresholdCount, ThresholdPercentage}
+var thresholdTypes = []string{ThresholdCount, ThresholdPercentage, ThresholdConsecutive}
 
 // Circuit represents a monitoring entity that tracks the status of a circuit.
 type Circuit interface {
@@ -47,6 +48,7 @@ type CircuitImplementation struct {
 	CircuitOpen        bool  // Indicates whether the circuit is open or closed
 	LastCapturedAt     int64 // Timestamp of the last captured event
 	CircuitOpenedSince int64 // Timestamp when the circuit was opened
+	ConsecutiveCounter int64
 	Ticker             *time.Ticker
 	Mutex              sync.Mutex
 	XMutex             sync.Mutex
@@ -105,7 +107,8 @@ func ConfigureCircuit(monitorOptions CircuitOptions) (Circuit, error) {
 	}
 
 	newMonitor := &CircuitImplementation{
-		Options: monitorOptions,
+		Options:            monitorOptions,
+		ConsecutiveCounter: 0,
 	}
 	newMonitor.Ticker = time.NewTicker(time.Duration(monitorOptions.IntervalInSeconds) * time.Second)
 	go func() {
@@ -115,6 +118,7 @@ func ConfigureCircuit(monitorOptions CircuitOptions) (Circuit, error) {
 			newMonitor.SuccessCount = 0
 			newMonitor.FailureCount = 0
 			newMonitor.CircuitOpenedSince = 0
+			newMonitor.ConsecutiveCounter = 0
 			newMonitor.CircuitOpen = false
 			if newMonitor.Options.OnCircuitClosed != nil {
 				newMonitor.Options.OnCircuitClosed(CallbackEvent{
@@ -137,8 +141,10 @@ func (m *CircuitImplementation) UpdateStatus(success bool) {
 
 	m.LastCapturedAt = getTimestamp()
 	if success {
+		m.ConsecutiveCounter = 0
 		m.SuccessCount++
 	} else {
+		m.ConsecutiveCounter++
 		m.FailureCount++
 	}
 	if m.SuccessCount+m.FailureCount < m.Options.MinimumCount {
@@ -155,7 +161,7 @@ func (m *CircuitImplementation) UpdateStatus(success bool) {
 			m.CircuitOpen = false
 			m.CircuitOpenedSince = 0
 		}
-	} else {
+	} else if m.Options.ThresholdType == ThresholdPercentage {
 		// if the threshold type is percentage, check if the percentage of failures is greater than the threshold
 		totalRequests := m.FailureCount + m.SuccessCount
 		failurePercentage := (m.FailureCount * 100) / totalRequests
@@ -167,6 +173,15 @@ func (m *CircuitImplementation) UpdateStatus(success bool) {
 			m.CircuitOpenedSince = 0
 
 		}
+	} else if m.Options.ThresholdType == ThresholdConsecutive {
+		if m.ConsecutiveCounter >= int64(m.Options.Threshold) {
+			m.CircuitOpen = true
+			m.CircuitOpenedSince = m.LastCapturedAt
+		} else {
+			m.CircuitOpen = false
+			m.CircuitOpenedSince = 0
+		}
+
 	}
 	if currentStateOfCircuit != m.CircuitOpen && m.CircuitOpen {
 

tripper_test.go

@@ -121,7 +121,7 @@ func TestUpdateStatus(t *testing.T) {
 	assert.False(t, m.Data().IsCircuitOpen)
 
 	// Test case 4: Update status with success=false and minimum count not reached
-	// Expected output: Failure count incremented, circuit not opened
+	// Expected output: Failure count incremented, circuit opened
 	m.UpdateStatus(false)
 	assert.Equal(t, int64(2), m.Data().SuccessCount)
 	assert.Equal(t, int64(2), m.Data().FailureCount)
@@ -365,3 +365,31 @@ func TestIsCircuitOpen(t *testing.T) {
 	m.UpdateStatus(true)
 	assert.False(t, m.IsCircuitOpen())
 }
+func TestUpdateStatusConsecutive(t *testing.T) {
+	monitorOptions := CircuitOptions{
+		Name:              "TEST_ThresholdConsecutive",
+		Threshold:         5,
+		MinimumCount:      2,
+		IntervalInSeconds: 120,
+		ThresholdType:     ThresholdConsecutive,
+	}
+	m, err := ConfigureCircuit(monitorOptions)
+	assert.NoError(t, err)
+	m.UpdateStatus(false)
+	m.UpdateStatus(false)
+	m.UpdateStatus(false)
+	m.UpdateStatus(false)
+	m.UpdateStatus(false)
+	assert.True(t, m.IsCircuitOpen())
+	m.UpdateStatus(false)
+	m.UpdateStatus(false)
+	m.UpdateStatus(true)
+	assert.False(t, m.IsCircuitOpen())
+	m.UpdateStatus(false)
+	m.UpdateStatus(false)
+	m.UpdateStatus(false)
+	m.UpdateStatus(false)
+	m.UpdateStatus(false)
+	assert.True(t, m.IsCircuitOpen())
+
+}