Rules Engine Module: Configurable cache update frequency (#4423)

VeronikaSolovei9 · VeronikaSolovei9 · web-flow · commit e4d9ac4ac1df · 2025-08-25T15:58:20.000-04:00
Co-authored-by: VeronikaSolovei9 &lt;vsolovei@microsoft.com&gt;
diff --git a/modules/prebid/rulesengine/cache.go b/modules/prebid/rulesengine/cache.go
@@ -3,6 +3,9 @@ package rulesengine
 import (
 	"sync"
 	"sync/atomic"
+	"time"
+
+	"github.com/prebid/prebid-server/v3/util/timeutil"
 )
 
 type accountID = string
@@ -11,20 +14,34 @@ type cacher interface {
 	Get(string) *cacheEntry
 	Set(string, *cacheEntry)
 	Delete(id accountID)
+	Expired(time.Time) bool
 }
 
 type cache struct {
 	sync.Mutex
-	m atomic.Value
+	m                atomic.Value
+	refreshFrequency time.Duration
+	t                timeutil.Time
 }
 
-func NewCache() *cache {
+func NewCache(refreshRateSeconds int) *cache {
 	var atomicMap atomic.Value
 	atomicMap.Store(make(map[accountID]*cacheEntry))
 
 	return &cache{
-		m: atomicMap,
+		m:                atomicMap,
+		refreshFrequency: time.Duration(refreshRateSeconds) * time.Second,
+		t:                &timeutil.RealTime{},
+	}
+}
+
+func (c *cache) Expired(coTimestamp time.Time) bool {
+	if c.refreshFrequency <= 0 {
+		return false
 	}
+	currentTime := c.t.Now()
+	delta := currentTime.Sub(coTimestamp)
+	return delta.Seconds() > c.refreshFrequency.Seconds()
 }
 
 // Get has been implemented to read from the cache without further synchronization
diff --git a/modules/prebid/rulesengine/cache_test.go b/modules/prebid/rulesengine/cache_test.go
@@ -2,6 +2,7 @@ package rulesengine
 
 import (
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -12,7 +13,7 @@ func TestGet(t *testing.T) {
 			hashedConfig: "hash1",
 		},
 	}
-	cache := NewCache()
+	cache := NewCache(0)
 	cache.m.Store(innerStorage)
 
 	testCases := []struct {
@@ -47,7 +48,7 @@ func TestSet(t *testing.T) {
 			hashedConfig: "hash1",
 		},
 	}
-	cache := NewCache()
+	cache := NewCache(0)
 	cache.m.Store(innerStorage)
 
 	testCases := []struct {
@@ -161,7 +162,7 @@ func TestDelete(t *testing.T) {
 		},
 	}
 
-	cache := NewCache()
+	cache := NewCache(0)
 	cache.m.Store(originalInnerStorage)
 
 	for _, tc := range testCases {
@@ -174,3 +175,46 @@ func TestDelete(t *testing.T) {
 		})
 	}
 }
+
+func TestExpired(t *testing.T) {
+	testCases := []struct {
+		name               string
+		inTimestamp        time.Time
+		refreshRateSeconds int
+		expectedResult     bool
+	}{
+		{
+			name:               "expired",
+			inTimestamp:        mockTimeUtil{}.Now().Add(-6 * time.Second),
+			refreshRateSeconds: 5,
+			expectedResult:     true,
+		},
+		{
+			name:               "not_expired",
+			inTimestamp:        mockTimeUtil{}.Now().Add(-4 * time.Second),
+			refreshRateSeconds: 5,
+			expectedResult:     false,
+		},
+		{
+			name:               "no_refresh_rate",
+			inTimestamp:        mockTimeUtil{}.Now().Add(-10 * time.Second),
+			refreshRateSeconds: 0,
+			expectedResult:     false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			c := NewCache(tc.refreshRateSeconds)
+			c.t = mockTimeUtil{}
+			res := c.Expired(tc.inTimestamp)
+			assert.Equal(t, tc.expectedResult, res)
+		})
+	}
+}
+
+type mockTimeUtil struct{}
+
+func (mt mockTimeUtil) Now() time.Time {
+	return time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
+}
diff --git a/modules/prebid/rulesengine/module.go b/modules/prebid/rulesengine/module.go
@@ -5,20 +5,18 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
-	"time"
+
+	"github.com/buger/jsonparser"
 
 	hs "github.com/prebid/prebid-server/v3/hooks/hookstage"
 	"github.com/prebid/prebid-server/v3/modules/moduledeps"
 	"github.com/prebid/prebid-server/v3/modules/prebid/rulesengine/config"
-	"github.com/prebid/prebid-server/v3/util/timeutil"
 )
 
-const fiveMinutes = time.Duration(300) * time.Second
-
 // Builder configures the rules engine module initiating an in-memory cache and kicking
 // off a go routine that builds tree structures that represent rule sets optimized for finding
 // a rule to applies for a given request.
-func Builder(_ json.RawMessage, _ moduledeps.ModuleDeps) (interface{}, error) {
+func Builder(cfg json.RawMessage, _ moduledeps.ModuleDeps) (interface{}, error) {
 	schemaValidator, err := config.CreateSchemaValidator(config.RulesEngineSchemaFilePath)
 	if err != nil {
 		return nil, err
@@ -30,7 +28,13 @@ func Builder(_ json.RawMessage, _ moduledeps.ModuleDeps) (interface{}, error) {
 		schemaValidator: schemaValidator,
 		monitor:         &treeManagerLogger{},
 	}
-	c := NewCache()
+
+	refreshRate, err := getRefreshRate(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	c := NewCache(refreshRate)
 
 	go tm.Run(c)
 
@@ -77,7 +81,7 @@ func (m Module) HandleProcessedAuctionHook(
 		}, nil
 	}
 	// cache hit
-	if rebuildTrees(co, &miCtx.AccountConfig) {
+	if rebuildTrees(co, &miCtx.AccountConfig, m.Cache) {
 		bi := buildInstruction{
 			accountID: miCtx.AccountID,
 			config:    &miCtx.AccountConfig,
@@ -103,25 +107,14 @@ func (m Module) Shutdown() {
 	<-m.TreeManager.done
 }
 
-// rebuildTrees returns true if the trees for this account need to be rebuilt; false otherwise
-func rebuildTrees(co *cacheEntry, jsonConfig *json.RawMessage) bool {
-	if !expired(&timeutil.RealTime{}, co.timestamp) {
+// rebuildTrees returns true if the trees need to be rebuilt; false otherwise
+func rebuildTrees(co *cacheEntry, jsonConfig *json.RawMessage, cacher cacher) bool {
+	if !cacher.Expired(co.timestamp) {
 		return false
 	}
 	return configChanged(co.hashedConfig, jsonConfig)
 }
 
-// expired returns true if the refresh time has expired; false otherwise
-func expired(t timeutil.Time, ts time.Time) bool {
-	currentTime := t.Now().UTC()
-
-	delta := currentTime.Sub(ts.UTC())
-	if delta.Seconds() > fiveMinutes.Seconds() {
-		return true
-	}
-	return false
-}
-
 // configChanged hashes the raw JSON config comparing it with the old hash returning
 // true with the new hash if the hashes are different and false otherwise
 func configChanged(oldHash hash, data *json.RawMessage) bool {
@@ -136,3 +129,15 @@ func configChanged(oldHash hash, data *json.RawMessage) bool {
 	}
 	return false
 }
+
+func getRefreshRate(jsonCfg json.RawMessage) (int, error) {
+	updateFrequency, err := jsonparser.GetInt(jsonCfg, "refreshrateseconds")
+
+	if err == jsonparser.KeyPathNotFoundError {
+		return 0, nil
+	}
+	if err != nil {
+		return 0, err
+	}
+	return int(updateFrequency), nil
+}
diff --git a/modules/prebid/rulesengine/module_test.go b/modules/prebid/rulesengine/module_test.go
@@ -5,45 +5,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/prebid/prebid-server/v3/util/timeutil"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestExpired(t *testing.T) {
-	testCases := []struct {
-		name           string
-		inTime         timeutil.Time
-		inTimestamp    time.Time
-		expectedResult bool
-	}{
-		{
-			name:           "expired",
-			inTime:         mockTimeUtil{},
-			inTimestamp:    mockTimeUtil{}.Now().Add(-time.Hour),
-			expectedResult: true,
-		},
-		{
-			name:           "not_expired",
-			inTime:         mockTimeUtil{},
-			inTimestamp:    mockTimeUtil{}.Now().Add(time.Hour),
-			expectedResult: false,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			res := expired(tc.inTime, tc.inTimestamp)
-			assert.Equal(t, tc.expectedResult, res)
-		})
-	}
-}
-
-type mockTimeUtil struct{}
-
-func (mt mockTimeUtil) Now() time.Time {
-	return time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
-}
-
 var sampleJsonConfig json.RawMessage = json.RawMessage(`{"enabled": true, "ruleSets": []}`)
 
 func TestConfigChanged(t *testing.T) {
@@ -84,42 +48,117 @@ func TestConfigChanged(t *testing.T) {
 
 func TestRebuildTrees(t *testing.T) {
 	testCases := []struct {
-		name           string
-		inCacheEntry   *cacheEntry
-		inJsonConfig   *json.RawMessage
-		expectedResult bool
+		name               string
+		inCacheEntry       *cacheEntry
+		inJsonConfig       *json.RawMessage
+		refreshRateSeconds int
+		expectedResult     bool
 	}{
 		{
 			name: "non_expired_cache_entry_so_no_rebuild",
 			inCacheEntry: &cacheEntry{
-				timestamp: time.Date(2050, 1, 1, 0, 0, 0, 0, time.UTC),
+				timestamp: time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC),
 			},
-			expectedResult: false,
+			inJsonConfig:       &sampleJsonConfig,
+			refreshRateSeconds: 10,
+			expectedResult:     false,
 		},
 		{
-			name: "expired_entry_but_same_config_so_no_rebuild",
+			name: "expired_entry_but_same_config_and_default_no_update_so_no_rebuild",
 			inCacheEntry: &cacheEntry{
 				timestamp:    time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC),
 				hashedConfig: "e21c19982a618f9dd3286fc2eb08dad62a1e9ee81d51ffa94b267ab2e3813964",
 			},
-			inJsonConfig:   &sampleJsonConfig,
-			expectedResult: false,
+			inJsonConfig:       &sampleJsonConfig,
+			refreshRateSeconds: 1,
+			expectedResult:     false,
 		},
 		{
-			name: "expired_entry_and_different_config_so_rebuild",
+			name: "expired_entry_but_same_config_and_zero_minutes_update_so_no_rebuild",
 			inCacheEntry: &cacheEntry{
 				timestamp:    time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC),
+				hashedConfig: "e21c19982a618f9dd3286fc2eb08dad62a1e9ee81d51ffa94b267ab2e3813964",
+			},
+			inJsonConfig:       &sampleJsonConfig,
+			refreshRateSeconds: 0,
+			expectedResult:     false,
+		},
+		{
+			name: "expired_entry_and_different_config_so_rebuild",
+			inCacheEntry: &cacheEntry{
+				timestamp:    time.Date(1999, 1, 1, 0, 0, 0, 0, time.UTC),
 				hashedConfig: "oldHash",
 			},
-			inJsonConfig:   &sampleJsonConfig,
-			expectedResult: true,
+			inJsonConfig:       &sampleJsonConfig,
+			refreshRateSeconds: 1,
+			expectedResult:     true,
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			res := rebuildTrees(tc.inCacheEntry, tc.inJsonConfig)
+			refreshFreq := time.Duration(tc.refreshRateSeconds) * time.Second
+			var c cacher = &cache{
+				refreshFrequency: refreshFreq,
+				t:                mockTimeUtil{},
+			}
+			res := rebuildTrees(tc.inCacheEntry, tc.inJsonConfig, c)
 			assert.Equal(t, tc.expectedResult, res)
 		})
 	}
 }
+
+func TestGetRefreshRate(t *testing.T) {
+
+	testCases := []struct {
+		name                string
+		inData              json.RawMessage
+		expectedRefreshRate int
+		expectError         bool
+	}{
+		{
+			name:                "nil_data",
+			inData:              nil,
+			expectedRefreshRate: 0,
+		},
+		{
+			name:                "valid_config",
+			inData:              json.RawMessage(`{"enabled": true, "refreshrateseconds": 10}`),
+			expectedRefreshRate: 10,
+		},
+		{
+			name:                "valid_config_negative_refresh_rate",
+			inData:              json.RawMessage(`{"enabled": true, "refreshrateseconds": -10}`),
+			expectedRefreshRate: -10,
+		},
+		{
+			name:                "valid_config_no_refresh_rate",
+			inData:              json.RawMessage(`{"enabled": true}`),
+			expectedRefreshRate: 0,
+		},
+		{
+			name:                "invalid_config",
+			inData:              json.RawMessage(`{"enabled": true, "refreshrateseconds": "test"}`),
+			expectedRefreshRate: 0,
+			expectError:         true,
+		},
+		{
+			name:                "path_not_foud",
+			inData:              json.RawMessage(`{"enabled": true, "test": 10}`),
+			expectedRefreshRate: 0,
+			expectError:         false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			res, err := getRefreshRate(tc.inData)
+			if tc.expectError {
+				assert.Error(t, err, "Expected an error but got none")
+			} else {
+				assert.NoError(t, err, "Expected no error but got one")
+			}
+			assert.Equal(t, tc.expectedRefreshRate, res)
+		})
+	}
+}
diff --git a/modules/prebid/rulesengine/tree_manager.go b/modules/prebid/rulesengine/tree_manager.go
diff --git a/modules/prebid/rulesengine/tree_manager_test.go b/modules/prebid/rulesengine/tree_manager_test.go
