Priority Bidder Ejection

config/config.go

@@ -951,6 +951,8 @@ func SetupViper(v *viper.Viper, filename string, bidderInfos BidderInfos) {
 
 	v.SetDefault("event.timeout_ms", 1000)
 
+	v.SetDefault("user_sync.priority_groups", [][]string{})
+
 	v.SetDefault("accounts.filesystem.enabled", false)
 	v.SetDefault("accounts.filesystem.directorypath", "./stored_requests/data/by_id")
 	v.SetDefault("accounts.in_memory_cache.type", "none")

config/usersync.go

@@ -2,13 +2,13 @@ package config
 
 // UserSync specifies the static global user sync configuration.
 type UserSync struct {
-	Cooperative UserSyncCooperative `mapstructure:"coop_sync"`
-	ExternalURL string              `mapstructure:"external_url"`
-	RedirectURL string              `mapstructure:"redirect_url"`
+	Cooperative    UserSyncCooperative `mapstructure:"coop_sync"`
+	ExternalURL    string              `mapstructure:"external_url"`
+	RedirectURL    string              `mapstructure:"redirect_url"`
+	PriorityGroups [][]string          `mapstructure:"priority_groups"`
 }
 
 // UserSyncCooperative specifies the static global default cooperative cookie sync
 type UserSyncCooperative struct {
-	EnabledByDefault bool       `mapstructure:"default"`
-	PriorityGroups   [][]string `mapstructure:"priority_groups"`
+	EnabledByDefault bool `mapstructure:"default"`
 }

endpoints/cookie_sync.go

@@ -166,7 +166,7 @@ func (c *cookieSyncEndpoint) parseRequest(r *http.Request) (usersync.Request, pr
 		Bidders: request.Bidders,
 		Cooperative: usersync.Cooperative{
 			Enabled:        (request.CooperativeSync != nil && *request.CooperativeSync) || (request.CooperativeSync == nil && c.config.UserSync.Cooperative.EnabledByDefault),
-			PriorityGroups: c.config.UserSync.Cooperative.PriorityGroups,
+			PriorityGroups: c.config.UserSync.PriorityGroups,
 		},
 		Limit: request.Limit,
 		Privacy: usersyncPrivacy{

endpoints/cookie_sync_test.go

@@ -515,9 +515,9 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
+				PriorityGroups: [][]string{{"a", "b", "c"}},
 				Cooperative: config.UserSyncCooperative{
 					EnabledByDefault: false,
-					PriorityGroups:   [][]string{{"a", "b", "c"}},
 				},
 			},
 			expectedPrivacy: privacy.Policies{
@@ -562,9 +562,9 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
+				PriorityGroups: [][]string{{"a", "b", "c"}},
 				Cooperative: config.UserSyncCooperative{
 					EnabledByDefault: false,
-					PriorityGroups:   [][]string{{"a", "b", "c"}},
 				},
 			},
 			expectedPrivacy: privacy.Policies{
@@ -615,9 +615,9 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
+				PriorityGroups: [][]string{{"a", "b", "c"}},
 				Cooperative: config.UserSyncCooperative{
 					EnabledByDefault: true,
-					PriorityGroups:   [][]string{{"a", "b", "c"}},
 				},
 			},
 			expectedPrivacy: privacy.Policies{},
@@ -641,9 +641,9 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
+				PriorityGroups: [][]string{{"a", "b", "c"}},
 				Cooperative: config.UserSyncCooperative{
 					EnabledByDefault: false,
-					PriorityGroups:   [][]string{{"a", "b", "c"}},
 				},
 			},
 			expectedPrivacy: privacy.Policies{},
@@ -667,9 +667,9 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
+				PriorityGroups: [][]string{{"a", "b", "c"}},
 				Cooperative: config.UserSyncCooperative{
 					EnabledByDefault: true,
-					PriorityGroups:   [][]string{{"a", "b", "c"}},
 				},
 			},
 			expectedPrivacy: privacy.Policies{},
@@ -693,9 +693,9 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
+				PriorityGroups: [][]string{{"a", "b", "c"}},
 				Cooperative: config.UserSyncCooperative{
 					EnabledByDefault: false,
-					PriorityGroups:   [][]string{{"a", "b", "c"}},
 				},
 			},
 			expectedPrivacy: privacy.Policies{},
@@ -719,9 +719,9 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
+				PriorityGroups: [][]string{{"a", "b", "c"}},
 				Cooperative: config.UserSyncCooperative{
 					EnabledByDefault: true,
-					PriorityGroups:   [][]string{{"a", "b", "c"}},
 				},
 			},
 			expectedPrivacy: privacy.Policies{},
@@ -745,9 +745,9 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
+				PriorityGroups: [][]string{{"a", "b", "c"}},
 				Cooperative: config.UserSyncCooperative{
 					EnabledByDefault: false,
-					PriorityGroups:   [][]string{{"a", "b", "c"}},
 				},
 			},
 			expectedPrivacy: privacy.Policies{},
@@ -888,9 +888,8 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
-				Cooperative: config.UserSyncCooperative{
-					PriorityGroups: [][]string{{"a", "b", "c"}},
-				},
+				PriorityGroups: [][]string{{"a", "b", "c"}},
+				Cooperative:    config.UserSyncCooperative{},
 			},
 			expectedPrivacy: privacy.Policies{},
 			expectedRequest: usersync.Request{
@@ -918,9 +917,9 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
+				PriorityGroups: [][]string{{"a", "b", "c"}},
 				Cooperative: config.UserSyncCooperative{
 					EnabledByDefault: false,
-					PriorityGroups:   [][]string{{"a", "b", "c"}},
 				},
 			},
 			expectedPrivacy: privacy.Policies{},
@@ -949,9 +948,9 @@ func TestCookieSyncParseRequest(t *testing.T) {
 			givenGDPRConfig:  config.GDPR{Enabled: true, DefaultValue: "0"},
 			givenCCPAEnabled: true,
 			givenConfig: config.UserSync{
+				PriorityGroups: [][]string{{"a", "b", "c"}},
 				Cooperative: config.UserSyncCooperative{
 					EnabledByDefault: false,
-					PriorityGroups:   [][]string{{"a", "b", "c"}},
 				},
 			},
 			expectedPrivacy: privacy.Policies{},

endpoints/setuid.go

@@ -157,7 +157,7 @@ func NewSetUIDEndpoint(cfg *config.Configuration, syncersByBidder map[string]use
 		setSiteCookie := siteCookieCheck(r.UserAgent())
 
 		// Write Cookie
-		encodedCookie, err := cookie.PrepareCookieForWrite(&cfg.HostCookie, encoder)
+		encodedCookie, err := cookie.PrepareCookieForWrite(&cfg.HostCookie, encoder, &usersync.PriorityBidderEjector{PriorityGroups: cfg.UserSync.PriorityGroups, SyncerKey: syncer.Key(), OldestEjector: usersync.OldestEjector{}})
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			metricsEngine.RecordSetUid(metrics.SetUidBadRequest)

pbs/usersync.go

@@ -81,7 +81,7 @@ func (deps *UserSyncDeps) OptOut(w http.ResponseWriter, r *http.Request, _ httpr
 	pc.SetOptOut(optout != "")
 
 	// Write Cookie
-	encodedCookie, err := pc.PrepareCookieForWrite(deps.HostCookieConfig, encoder)
+	encodedCookie, err := pc.PrepareCookieForWrite(deps.HostCookieConfig, encoder, &usersync.OldestEjector{}) // TODO: Getting Non Priority Keys Here
 	if err != nil {
 		w.WriteHeader(http.StatusBadRequest)
 		return

usersync/cookie.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"errors"
 	"net/http"
-	"sort"
 	"time"
 
 	"github.com/prebid/prebid-server/config"
@@ -58,10 +57,7 @@ func ReadCookie(r *http.Request, decoder Decoder, host *config.HostCookie) *Cook
 }
 
 // PrepareCookieForWrite ejects UIDs as long as the cookie is too full
-func (cookie *Cookie) PrepareCookieForWrite(cfg *config.HostCookie, encoder Encoder) (string, error) {
-	uuidKeys := sortUIDs(cookie.uids)
-
-	i := 0
+func (cookie *Cookie) PrepareCookieForWrite(cfg *config.HostCookie, encoder Encoder, ejector Ejector) (string, error) {
 	for len(cookie.uids) > 0 {
 		encodedCookie, err := encoder.Encode(cookie)
 		if err != nil {
@@ -82,10 +78,11 @@ func (cookie *Cookie) PrepareCookieForWrite(cfg *config.HostCookie, encoder Enco
 			return encodedCookie, nil
 		}
 
-		uidToDelete := uuidKeys[i]
+		uidToDelete, err := ejector.Choose(cookie.uids)
+		if err != nil {
+			return encodedCookie, err
+		}
 		delete(cookie.uids, uidToDelete)
-
-		i++
 	}
 	return "", nil
 }
@@ -132,23 +129,6 @@ func (cookie *Cookie) Sync(key string, uid string) error {
 	return nil
 }
 
-// sortUIDs is used to get a list of uids sorted from oldest to newest
-// This list is used to eject oldest uids from the cookie
-// This will be incorporated with a more complex ejection framework in a future PR
-func sortUIDs(uids map[string]UIDEntry) []string {
-	if len(uids) > 0 {
-		uuidKeys := make([]string, 0, len(uids))
-		for key := range uids {
-			uuidKeys = append(uuidKeys, key)
-		}
-		sort.SliceStable(uuidKeys, func(i, j int) bool {
-			return uids[uuidKeys[i]].Expires.Before(uids[uuidKeys[j]].Expires)
-		})
-		return uuidKeys
-	}
-	return nil
-}
-
 // SyncHostCookie syncs the request cookie with the host cookie
 func SyncHostCookie(r *http.Request, requestCookie *Cookie, host *config.HostCookie) {
 	if uid, _, _ := requestCookie.GetUID(host.Family); uid == "" && host.CookieName != "" {

usersync/cookie_test.go

@@ -393,6 +393,19 @@ func TestPrepareCookieForWrite(t *testing.T) {
 		optOut: false,
 	}
 
+	ejector := &PriorityBidderEjector{
+		PriorityGroups: [][]string{
+			{"1"},
+			{"2", "3"},
+			{"4", "5", "6"},
+			{"7"},
+		},
+		SyncerKey: "1",
+		OldestEjector: OldestEjector{
+			nonPriorityKeys: []string{},
+		},
+	}
+
 	testCases := []struct {
 		name                     string
 		givenMaxCookieSize       int
@@ -447,7 +460,7 @@ func TestPrepareCookieForWrite(t *testing.T) {
 
 	for _, test := range testCases {
 		t.Run(test.name, func(t *testing.T) {
-			encodedCookie, err := cookieToSend.PrepareCookieForWrite(&config.HostCookie{MaxCookieSizeBytes: test.givenMaxCookieSize}, encoder)
+			encodedCookie, err := cookieToSend.PrepareCookieForWrite(&config.HostCookie{MaxCookieSizeBytes: test.givenMaxCookieSize}, encoder, ejector)
 			assert.NoError(t, err)
 			decodedCookie := decoder.Decode(encodedCookie)