Vtrack and event endpoints

adapters/info.go

@@ -201,10 +201,11 @@ const (
 )
 
 type BidderInfo struct {
-	Status       BidderStatus      `yaml:"status" json:"status"`
-	Maintainer   *MaintainerInfo   `yaml:"maintainer" json:"maintainer"`
-	Capabilities *CapabilitiesInfo `yaml:"capabilities" json:"capabilities"`
-	AliasOf      string            `json:"aliasOf,omitempty"`
+	Status                  BidderStatus      `yaml:"status" json:"status"`
+	Maintainer              *MaintainerInfo   `yaml:"maintainer" json:"maintainer"`
+	Capabilities            *CapabilitiesInfo `yaml:"capabilities" json:"capabilities"`
+	AliasOf                 string            `json:"aliasOf,omitempty"`
+	ModifyingVastXmlAllowed bool              `yaml:"modifyingVastXmlAllowed" json:"-" xml:"-"`
 }
 
 type MaintainerInfo struct {

analytics/config/config.go

@@ -69,3 +69,9 @@ func (ea enabledAnalytics) LogAmpObject(ao *analytics.AmpObject) {
 		module.LogAmpObject(ao)
 	}
 }
+
+func (ea enabledAnalytics) LogNotificationEventObject(ne *analytics.NotificationEvent) {
+	for _, module := range ea {
+		module.LogNotificationEventObject(ne)
+	}
+}

analytics/config/config_test.go

@@ -51,6 +51,11 @@ func TestSampleModule(t *testing.T) {
 	if count != 5 {
 		t.Errorf("PBSAnalyticsModule failed at LogVideoObject")
 	}
+
+	am.LogNotificationEventObject(&analytics.NotificationEvent{})
+	if count != 6 {
+		t.Errorf("PBSAnalyticsModule failed at LogNotificationEventObject")
+	}
 }
 
 type sampleModule struct {
@@ -67,6 +72,8 @@ func (m *sampleModule) LogSetUIDObject(so *analytics.SetUIDObject) { *m.count++
 
 func (m *sampleModule) LogAmpObject(ao *analytics.AmpObject) { *m.count++ }
 
+func (m *sampleModule) LogNotificationEventObject(ne *analytics.NotificationEvent) { *m.count++ }
+
 func initAnalytics(count *int) analytics.PBSAnalyticsModule {
 	modules := make(enabledAnalytics, 0)
 	modules = append(modules, &sampleModule{count})

analytics/core.go

@@ -5,6 +5,7 @@ import (
 	"github.com/prebid/prebid-server/config"
 	"github.com/prebid/prebid-server/openrtb_ext"
 	"github.com/prebid/prebid-server/usersync"
+	"time"
 )
 
 /*
@@ -21,6 +22,7 @@ type PBSAnalyticsModule interface {
 	LogCookieSyncObject(*CookieSyncObject)
 	LogSetUIDObject(*SetUIDObject)
 	LogAmpObject(*AmpObject)
+	LogNotificationEventObject(*NotificationEvent)
 }
 
 //Loggable object of a transaction at /openrtb2/auction endpoint
@@ -67,3 +69,12 @@ type CookieSyncObject struct {
 	Errors       []error
 	BidderStatus []*usersync.CookieSyncBidders
 }
+
+// NotificationEvent is a loggable object
+type NotificationEvent struct {
+	Type      string          `json:"type"`
+	Bidid     string          `json:"bidid"`
+	Account   *config.Account `json:"account"`
+	Bidder    string          `json:"bidder"`
+	Timestamp time.Time       `json:"timestamp"`
+}

analytics/filesystem/file_module.go

@@ -12,11 +12,12 @@ import (
 type RequestType string
 
 const (
-	COOKIE_SYNC RequestType = "/cookie_sync"
-	AUCTION     RequestType = "/openrtb2/auction"
-	VIDEO       RequestType = "/openrtb2/video"
-	SETUID      RequestType = "/set_uid"
-	AMP         RequestType = "/openrtb2/amp"
+	COOKIE_SYNC        RequestType = "/cookie_sync"
+	AUCTION            RequestType = "/openrtb2/auction"
+	VIDEO              RequestType = "/openrtb2/video"
+	SETUID             RequestType = "/set_uid"
+	AMP                RequestType = "/openrtb2/amp"
+	NOTIFICATION_EVENT RequestType = "/event"
 )
 
 //Module that can perform transactional logging
@@ -72,6 +73,18 @@ func (f *FileLogger) LogAmpObject(ao *analytics.AmpObject) {
 	f.Logger.Flush()
 }
 
+//Logs NotificationEvent to file
+func (f *FileLogger) LogNotificationEventObject(ne *analytics.NotificationEvent) {
+	if ne == nil {
+		return
+	}
+	//Code to parse the object and log in a way required
+	var b bytes.Buffer
+	b.WriteString(jsonifyNotificationEventObject(ne))
+	f.Logger.Debug(b.String())
+	f.Logger.Flush()
+}
+
 //Method to initialize the analytic module
 func NewFileLogger(filename string) (analytics.PBSAnalyticsModule, error) {
 	options := glog.LogOptions{
@@ -176,3 +189,20 @@ func jsonifyAmpObject(ao *analytics.AmpObject) string {
 		return fmt.Sprintf("Transactional Logs Error: Amp object badly formed %v", err)
 	}
 }
+
+func jsonifyNotificationEventObject(ne *analytics.NotificationEvent) string {
+	type alias analytics.NotificationEvent
+	b, err := json.Marshal(&struct {
+		Type RequestType `json:"type"`
+		*alias
+	}{
+		Type:  NOTIFICATION_EVENT,
+		alias: (*alias)(ne),
+	})
+
+	if err == nil {
+		return string(b)
+	} else {
+		return fmt.Sprintf("Transactional Logs Error: NotificationEvent object badly formed %v", err)
+	}
+}

analytics/pubstack/pubstack_module.go

@@ -125,6 +125,9 @@ func (p *PubstackModule) LogAuctionObject(ao *analytics.AuctionObject) {
 	p.eventChannels[auction].Push(payload)
 }
 
+func (p *PubstackModule) LogNotificationEventObject(ne *analytics.NotificationEvent) {
+}
+
 func (p *PubstackModule) LogVideoObject(vo *analytics.VideoObject) {
 	p.muxConfig.RLock()
 	defer p.muxConfig.RUnlock()

config/accounts.go

@@ -2,7 +2,9 @@ package config
 
 // Account represents a publisher account configuration
 type Account struct {
-	ID       string      `mapstructure:"id" json:"id"`
-	Disabled bool        `mapstructure:"disabled" json:"disabled"`
-	CacheTTL DefaultTTLs `mapstructure:"cache_ttl" json:"cache_ttl"`
+	ID               string      `mapstructure:"id" json:"id"`
+	Disabled         bool        `mapstructure:"disabled" json:"disabled"`
+	CacheTTL         DefaultTTLs `mapstructure:"cache_ttl" json:"cache_ttl"`
+	PriceGranularity string      `mapstructure:"price_granularity" json:"price_granularity"`
+	EventsEnabled    bool        `mapstructure:"events_enabled" json:"events_enabled"`
 }

config/config.go

@@ -41,6 +41,7 @@ type Configuration struct {
 	StoredRequests    StoredRequests  `mapstructure:"stored_requests"`
 	StoredRequestsAMP StoredRequests  `mapstructure:"stored_amp_req"`
 	CategoryMapping   StoredRequests  `mapstructure:"category_mapping"`
+	VTrack            VTrack          `mapstructure:"vtrack"`
 	Accounts          StoredRequests  `mapstructure:"accounts"`
 	// Note that StoredVideo refers to stored video requests, and has nothing to do with caching video creatives.
 	StoredVideo StoredRequests `mapstructure:"stored_video_req"`
@@ -314,6 +315,12 @@ type PubstackBuffer struct {
 	Timeout    string `mapstructure:"timeout"`
 }
 
+type VTrack struct {
+	TimeoutMS          int64 `mapstructure:"timeout_ms"`
+	AllowUnknownBidder bool  `mapstructure:"allow_unknown_bidder"`
+	Enabled            bool  `mapstructure:"enabled"`
+}
+
 type HostCookie struct {
 	Domain             string `mapstructure:"domain"`
 	Family             string `mapstructure:"family"`
@@ -874,6 +881,10 @@ func SetupViper(v *viper.Viper, filename string) {
 	v.SetDefault("stored_video_req.http_events.refresh_rate_seconds", 0)
 	v.SetDefault("stored_video_req.http_events.timeout_ms", 0)
 
+	v.SetDefault("vtrack.timeout_ms", 2000)
+	v.SetDefault("vtrack.allow_unknown_bidder", true)
+	v.SetDefault("vtrack.enabled", true)
+
 	v.SetDefault("accounts.filesystem.enabled", false)
 	v.SetDefault("accounts.filesystem.directorypath", "./stored_requests/data/by_id")
 	v.SetDefault("accounts.in_memory_cache.type", "none")

endpoints/events/accounts.go

@@ -0,0 +1,41 @@
+package events
+
+import (
+	"context"
+	"encoding/json"
+	jsonpatch "github.com/evanphx/json-patch"
+	"github.com/prebid/prebid-server/config"
+	"github.com/prebid/prebid-server/stored_requests"
+)
+
+/**
+ * Retrieves an account and merges it with AccountDefaults
+ */
+func GetAccount(ctx context.Context, cfg *config.Configuration, fetcher stored_requests.AccountFetcher, id string) (*config.Account, []error) {
+	// account defaults is our baseline
+	account := cfg.AccountDefaults
+	account.ID = id
+
+	// attempt to retrieve account details using an AccountFetcher
+	if accountJSON, errs := fetcher.FetchAccount(ctx, id); len(errs) > 0 {
+		// tolerate account not found/empty and use account defaults
+		// if that's not the case return the errors that should be handler by the callers
+		if !accountNotFound(errs) {
+			return nil, errs
+		}
+	} else {
+		// merge with account defaults
+		// id resolved to a valid account, merge with AccountDefaults for a complete config
+		completeJSON, err := jsonpatch.MergePatch(cfg.AccountDefaultsJSON(), accountJSON)
+		if err == nil {
+			err = json.Unmarshal(completeJSON, &account)
+		}
+		if err != nil {
+			errs = append(errs, err)
+			return nil, errs
+		}
+		account.ID = id
+	}
+
+	return &account, nil
+}

endpoints/events/accounts_test.go

@@ -0,0 +1,149 @@
+package events
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/prebid/prebid-server/config"
+	"github.com/prebid/prebid-server/stored_requests"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+// Mock AccountsFetcher
+type mockAccountsFetcher struct {
+	Fail          bool
+	Error         error
+	EventsEnabled bool
+	T             *testing.T
+}
+
+func (e *mockAccountsFetcher) FetchAccount(ctx context.Context, accountID string) (json.RawMessage, []error) {
+	if e.Fail {
+		return nil, []error{e.Error}
+	}
+
+	var acc = &config.Account{
+		ID:            accountID,
+		EventsEnabled: false,
+	}
+
+	if e.EventsEnabled {
+		acc.EventsEnabled = true
+	}
+
+	s, err := json.Marshal(acc)
+	if err != nil {
+		e.T.Fatal(err)
+	}
+
+	return s, []error{}
+}
+
+func TestShouldReturnDefaultAccountWithSpecifiedIdWhenAccountNotFound(t *testing.T) {
+	// prepare
+	ctx := context.Background()
+
+	cfg := &config.Configuration{
+		AccountDefaults: config.Account{
+			EventsEnabled: true,
+		},
+	}
+	cfg.MarshalAccountDefaults()
+
+	af := mockAccountsFetcher{
+		Fail:  true,
+		Error: stored_requests.NotFoundError{},
+		T:     t,
+	}
+
+	acc, errs := GetAccount(ctx, cfg, &af, "test")
+
+	assert.Equal(t, 0, len(errs), "Expected 0 errors when account not found")
+	assert.EqualValues(t, config.Account{
+		EventsEnabled: true,
+		ID:            "test",
+	}, *acc)
+
+}
+
+func TestShouldReturnNilAccountWhenFetcherFailsAttemptingToGetAccount(t *testing.T) {
+	// prepare
+	ctx := context.Background()
+
+	cfg := &config.Configuration{
+		AccountDefaults: config.Account{
+			EventsEnabled: true,
+		},
+	}
+	cfg.MarshalAccountDefaults()
+
+	af := mockAccountsFetcher{
+		Fail:  true,
+		Error: fmt.Errorf("test error"),
+		T:     t,
+	}
+
+	acc, errs := GetAccount(ctx, cfg, &af, "test")
+
+	assert.Equal(t, 1, len(errs), "Expected 1 errors")
+	assert.Nil(t, acc)
+	assert.Equal(t, "test error", errs[0].Error())
+
+}
+
+func TestShouldReturnAccountMergedWithAccountsDefaults(t *testing.T) {
+	// prepare
+	ctx := context.Background()
+
+	cfg := &config.Configuration{
+		AccountDefaults: config.Account{
+			EventsEnabled: false,
+		},
+	}
+	cfg.MarshalAccountDefaults()
+
+	af := mockAccountsFetcher{
+		Fail:          false,
+		EventsEnabled: true,
+		T:             t,
+	}
+
+	expectedAccount := config.Account{
+		EventsEnabled: true,
+		ID:            "test",
+	}
+
+	acc, errs := GetAccount(ctx, cfg, &af, "test")
+
+	assert.Equal(t, 0, len(errs), "Expected 0 errors")
+	assert.EqualValues(t, expectedAccount, *acc)
+
+}
+
+func TestShouldReturnAccountMergedWithEmptyAccountsDefaults(t *testing.T) {
+	// prepare
+	ctx := context.Background()
+
+	cfg := &config.Configuration{
+		AccountDefaults: config.Account{},
+	}
+	cfg.MarshalAccountDefaults()
+
+	af := mockAccountsFetcher{
+		Fail:          false,
+		EventsEnabled: true,
+		T:             t,
+	}
+
+	expectedAccount := config.Account{
+		EventsEnabled: true,
+		ID:            "test",
+	}
+
+	acc, errs := GetAccount(ctx, cfg, &af, "test")
+
+	assert.Equal(t, 0, len(errs), "Expected 0 errors")
+	assert.EqualValues(t, expectedAccount, *acc)
+
+}