address comments

Author: Mat001

pkg/event/dispatcher.go

@@ -120,9 +120,10 @@ func (ed *QueueEventDispatcher) waitForDispatchingEventsOnClose(timeout time.Dur
 	}
 }
 
-// getRetryInterval calculates exponential backoff interval starting at 200ms, doubling each retry, capped at 1s
+// getRetryInterval calculates exponential backoff interval.
+// Uses bit-shift (1<<retryCount) to compute 2^retryCount for doubling: 200ms, 400ms, 800ms, ... capped at 1s.
 func getRetryInterval(retryCount int) time.Duration {
-	interval := initialRetryInterval * time.Duration(1<<retryCount) // 200ms, 400ms, 800ms, ...
+	interval := initialRetryInterval * time.Duration(1<<retryCount)
 	return min(interval, maxRetryInterval)
 }
 

pkg/odp/event/event_manager.go

@@ -41,6 +41,13 @@ const maxRetries = 3
 const initialRetryInterval = 200 * time.Millisecond
 const maxRetryInterval = 1 * time.Second
 
+// getRetryInterval calculates exponential backoff interval.
+// Uses bit-shift (1<<retryCount) to compute 2^retryCount for doubling: 200ms, 400ms, 800ms, ... capped at 1s.
+func getRetryInterval(retryCount int) time.Duration {
+	interval := initialRetryInterval * time.Duration(1<<retryCount)
+	return min(interval, maxRetryInterval)
+}
+
 // Manager represents the event manager.
 type Manager interface {
 	// odpConfig is required here since it can be updated anytime and ticker needs to be aware of latest changes
@@ -306,13 +313,9 @@ func (bm *BatchEventManager) FlushEvents(apiKey, apiHost string) {
 					break
 				}
 				retryCount++
-				// Exponential backoff before next retry: 200ms, 400ms, 800ms, ... capped at 1s
+				// Exponential backoff before next retry
 				if retryCount < maxRetries {
-					delay := initialRetryInterval * time.Duration(1<<(retryCount-1))
-					if delay > maxRetryInterval {
-						delay = maxRetryInterval
-					}
-					time.Sleep(delay)
+					time.Sleep(getRetryInterval(retryCount - 1))
 				}
 			}
 		}

pkg/odp/event/event_manager_test.go

@@ -607,3 +607,39 @@ func (m *MockEventAPIManager) SendOdpEvents(apiKey, apiHost string, events []Eve
 func newExecutionContext() *pkgUtils.ExecGroup {
 	return pkgUtils.NewExecGroup(context.Background(), logging.GetLogger("", "NewExecGroup"))
 }
+
+func TestGetRetryInterval(t *testing.T) {
+	tests := []struct {
+		name       string
+		retryCount int
+		expected   time.Duration
+	}{
+		{"first retry", 0, 200 * time.Millisecond},
+		{"second retry", 1, 400 * time.Millisecond},
+		{"third retry", 2, 800 * time.Millisecond},
+		{"fourth retry capped at max", 3, 1 * time.Second},
+		{"fifth retry capped at max", 4, 1 * time.Second},
+		{"high retry count capped at max", 10, 1 * time.Second},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := getRetryInterval(tt.retryCount)
+			if result != tt.expected {
+				t.Errorf("getRetryInterval(%d) = %v, want %v", tt.retryCount, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestGetRetryInterval_ExponentialGrowth(t *testing.T) {
+	// Verify exponential growth pattern: each interval should be double the previous
+	prev := getRetryInterval(0)
+	for i := 1; i <= 2; i++ {
+		curr := getRetryInterval(i)
+		if curr != prev*2 {
+			t.Errorf("retry %d should be double retry %d: got %v, want %v", i, i-1, curr, prev*2)
+		}
+		prev = curr
+	}
+}

pkg/utils/requester_test.go

@@ -281,7 +281,7 @@ func TestGetRetry(t *testing.T) {
 
 	// With exponential backoff: 200ms + 400ms + 800ms + 1000ms = 2400ms for 4 delays (5 attempts)
 	// Allow some tolerance for test execution overhead
-	assert.True(t, elapsed >= 2*time.Second && elapsed <= 10*time.Second, "took %s", elapsed)
+	assert.True(t, elapsed >= 2*time.Second && elapsed <= 4*time.Second, "took %s", elapsed)
 
 	httpreq = NewHTTPRequester(logging.GetLogger("", ""), Retries(3))
 	called = 0