Add whitelist of events not to rate limit

Author: CameronRP

eventstore/eventstore.go

@@ -116,18 +116,35 @@ type EventDescription struct {
 	Details map[string]interface{} `json:"details"`
 }
 
+var whitelist = map[string]struct{}{
+	"UnrecoverableDataCorruption":    {},
+	"CorruptFile":                    {},
+	"ErasePartialOrCorruptRecording": {},
+	"OffloadedRecording":             {},
+	"SavedNewConfig":                 {},
+	"FileOffloadInterruptedByUser":   {},
+	"Rp2040GotNewConfig":             {},
+}
+
 // shouldBeRateLimited checks if that type of event is being made too often.
 // Each time an event is made, if an event of that same type was made in the last 3 minutes
 // a counter will be incremented. Otherwise the counter will be reset to 0.
 // If the counter is 5 or more the events will be rate limited.
 // When the counter reaches 5, an rate_limit event will be made
+// There is a whitelist of events that are not rate limited, these events are made when offloading
+// recordings so it is expected that there will be a lot of these events in a short amount of time.
 func (s *EventStore) shouldBeRateLimited(event *Event) bool {
 	s.mux.Lock()
 	defer s.mux.Unlock()
 
 	eventType := event.Description.Type
 	eventTime := event.Timestamp
 
+	// Checking if the event type is in the whitelist
+	if _, ok := whitelist[eventType]; ok {
+		return false
+	}
+
 	rl, ok := s.rateLimits[eventType]
 
 	// Checking if the event type is in the rate limit map

eventstore/eventstore_test.go

@@ -275,6 +275,64 @@ func (s *Suite) TestRateLimitThenNoRateLimit() {
 	}
 }
 
+func (s *Suite) TestRateLimitWhiteList() {
+	getNodegroupFunc = func() (string, error) {
+		return "the_nodegroup", nil
+	}
+
+	// Intervals between events.
+	durations := []time.Duration{
+		time.Minute,
+		time.Minute,
+		time.Minute,
+		time.Minute,
+		time.Minute,
+		time.Minute,
+		time.Minute,
+		time.Minute,
+		time.Minute,
+	}
+
+	// Make event times
+	eventTime := time.Now()
+	times := []time.Time{eventTime}
+	for _, d := range durations {
+		eventTime = eventTime.Add(d)
+		times = append(times, eventTime)
+	}
+
+	// Make events
+	description := EventDescription{Details: map[string]interface{}{"file": "abc"}, Type: "CorruptFile"}
+	for _, t := range times {
+		event := Event{
+			Timestamp:   t,
+			Description: description,
+		}
+		s.NoError(s.store.Add(&event))
+	}
+
+	// Test GetKeys
+	keys, err := s.store.GetKeys()
+	s.NoError(err, "error returned when getting all keys")
+	// Check 10 events + 1 rate limit event
+	s.Equal(len(durations)+1, len(keys), "error with number of keys returned")
+
+	// Check that there was a rate limit event
+	rateLimitEvent := false
+	for _, key := range keys {
+		eventBytes, err := s.store.Get(key)
+		s.NoError(err)
+		event := &Event{}
+		s.NoError(json.Unmarshal(eventBytes, event))
+		if event.Description.Type == "rateLimit" {
+			rateLimitEvent = true
+		}
+	}
+	if rateLimitEvent {
+		s.Fail("Rate limit event found")
+	}
+}
+
 func TestRun(t *testing.T) {
 	suite.Run(t, new(Suite))
 }