usersync

package
v2.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 8, 2024 License: Apache-2.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrSyncerEndpointRequired = errors.New("at least one endpoint (iframe and/or redirect) is required")
	ErrSyncerKeyRequired      = errors.New("key is required")
)

Functions

func BuildSyncers 

func BuildSyncers(hostConfig *config.Configuration, bidderInfos config.BidderInfos) (map[string]Syncer, []error)

func SyncHostCookie 

func SyncHostCookie(r *http.Request, requestCookie *Cookie, host *config.HostCookie)

SyncHostCookie syncs the request cookie with the host cookie

func WriteCookie 

func WriteCookie(w http.ResponseWriter, encodedCookie string, cfg *config.HostCookie, setSiteCookie bool)

WriteCookie sets the prepared cookie onto the header

Types

type Base64Decoder 

type Base64Decoder struct{}

func (Base64Decoder) Decode 

func (d Base64Decoder) Decode(encodedValue string) *Cookie

type Base64Encoder 

type Base64Encoder struct{}

func (Base64Encoder) Encode 

func (e Base64Encoder) Encode(c *Cookie) (string, error)

type BidderEvaluation 

type BidderEvaluation struct {
	Bidder    string
	SyncerKey string
	Status    Status
}

BidderEvaluation specifies which bidders were considered to be synced.

type BidderFilter 

type BidderFilter interface {
	// Allowed returns true if the filter determines the bidder has permission and false if either
	// the bidder does not have permission or if the filter has an invalid mode.
	Allowed(bidder string) bool
}

BidderFilter determines if a bidder has permission to perform a user sync activity.

func NewSpecificBidderFilter 

func NewSpecificBidderFilter(bidders []string, mode BidderFilterMode) BidderFilter

NewSpecificBidderFilter returns a new instance of the NewSpecificBidderFilter filter.

func NewUniformBidderFilter 

func NewUniformBidderFilter(mode BidderFilterMode) BidderFilter

NewUniformBidderFilter returns a new instance of the UniformBidderFilter filter.

type BidderFilterMode 

type BidderFilterMode int

BidderFilterMode represents the inclusion mode of a BidderFilter. 

const (
	BidderFilterModeInclude BidderFilterMode = iota
	BidderFilterModeExclude
)

type Chooser 

type Chooser interface {
	// Choose considers bidders to sync, filters the bidders, and returns the result of the
	// user sync selection.
	Choose(request Request, cookie *Cookie) Result
}

Chooser determines which syncers are eligible for a given request.

func NewChooser 

func NewChooser(bidderSyncerLookup map[string]Syncer, biddersKnown map[string]struct{}, bidderInfo map[string]config.BidderInfo) Chooser

NewChooser returns a new instance of the standard chooser implementation. 

type Cookie struct {
	// contains filtered or unexported fields
}

Cookie is the cookie used in Prebid Server.

To get an instance of this from a request, use ReadCookie. To write an instance onto a response, use WriteCookie.

func NewCookie 

func NewCookie() *Cookie

NewCookie returns a new empty cookie.

func ReadCookie 

func ReadCookie(r *http.Request, decoder Decoder, host *config.HostCookie) *Cookie

ReadCookie reads the cookie from the request

func (*Cookie) AllowSyncs 

func (cookie *Cookie) AllowSyncs() bool

AllowSyncs is true if the user lets bidders sync cookies, and false otherwise.

func (*Cookie) GetUID 

func (cookie *Cookie) GetUID(key string) (uid string, isUIDFound bool, isUIDActive bool)

GetUID Gets this user's ID for the given syncer key.

func (*Cookie) GetUIDs 

func (cookie *Cookie) GetUIDs() map[string]string

GetUIDs returns this user's ID for all the bidders

func (*Cookie) HasAnyLiveSyncs 

func (cookie *Cookie) HasAnyLiveSyncs() bool

HasAnyLiveSyncs returns true if this cookie has at least one active sync.

func (*Cookie) HasLiveSync 

func (cookie *Cookie) HasLiveSync(key string) bool

HasLiveSync returns true if we have an active UID for the given syncer key, and false otherwise.

func (*Cookie) MarshalJSON 

func (cookie *Cookie) MarshalJSON() ([]byte, error)

func (*Cookie) PrepareCookieForWrite 

func (cookie *Cookie) PrepareCookieForWrite(cfg *config.HostCookie, encoder Encoder, ejector Ejector) (string, error)

PrepareCookieForWrite ejects UIDs as long as the cookie is too full

func (*Cookie) SetOptOut 

func (cookie *Cookie) SetOptOut(optOut bool)

SetOptOut is used to change whether or not we're allowed to sync cookies for this user.

func (*Cookie) Sync 

func (cookie *Cookie) Sync(key string, uid string) error

Sync tries to set the UID for some syncer key. It returns an error if the set didn't happen.

func (*Cookie) UnmarshalJSON 

func (cookie *Cookie) UnmarshalJSON(b []byte) error

func (*Cookie) Unsync 

func (cookie *Cookie) Unsync(key string)

Unsync removes the user's ID for the given syncer key from this cookie.

type Cooperative 

type Cooperative struct {
	Enabled        bool
	PriorityGroups [][]string
}

Cooperative specifies the settings for cooperative syncing for a given request, where bidders other than those used by the publisher are considered for syncing.

type Decoder 

type Decoder interface {
	Decode(encodedValue string) *Cookie
}

type Ejector 

type Ejector interface {
	Choose(uids map[string]UIDEntry) (string, error)
}

type Encoder 

type Encoder interface {
	// Encode a cookie into a base 64 string
	Encode(c *Cookie) (string, error)
}

type OldestEjector 

type OldestEjector struct{}

func (*OldestEjector) Choose 

func (o *OldestEjector) Choose(uids map[string]UIDEntry) (string, error)

Choose method for oldest ejector will return the oldest uid

type PriorityBidderEjector 

type PriorityBidderEjector struct {
	PriorityGroups   [][]string
	SyncersByBidder  map[string]Syncer
	IsSyncerPriority bool
	TieEjector       Ejector
}

func (*PriorityBidderEjector) Choose 

func (p *PriorityBidderEjector) Choose(uids map[string]UIDEntry) (string, error)

Choose method for priority ejector will return the oldest lowest priority element

type Privacy 

type Privacy interface {
	GDPRAllowsHostCookie() bool
	GDPRInScope() bool
	GDPRAllowsBidderSync(bidder string) bool
	CCPAAllowsBidderSync(bidder string) bool
	ActivityAllowsUserSync(bidder string) bool
}

Privacy determines which privacy policies will be enforced for a user sync request.

type Request 

type Request struct {
	Bidders        []string
	Cooperative    Cooperative
	Limit          int
	Privacy        Privacy
	SyncTypeFilter SyncTypeFilter
	GPPSID         string
	Debug          bool
}

Request specifies a user sync request.

type Result 

type Result struct {
	BiddersEvaluated []BidderEvaluation
	Status           Status
	SyncersChosen    []SyncerChoice
}

Result specifies which bidders were included in the evaluation and which syncers were chosen.

type SpecificBidderFilter 

type SpecificBidderFilter struct {
	// contains filtered or unexported fields
}

SpecificBidderFilter implements the BidderFilter which applies the same mode for a list of bidders.

func (SpecificBidderFilter) Allowed 

func (f SpecificBidderFilter) Allowed(bidder string) bool

Allowed returns true if the bidder is specified and the mode is include or if the bidder is not specified and the mode is exclude and returns false in the opposite cases or when the mode is invalid.

type Status 

type Status int

Status specifies the result of a sync evaluation. 

const (
	// StatusOK specifies user syncing is permitted.
	StatusOK Status = iota

	// StatusBlockedByUserOptOut specifies a user's cookie explicitly signals an opt-out.
	StatusBlockedByUserOptOut

	// StatusAlreadySynced specifies a user's cookie has an existing non-expired sync for a specific bidder.
	StatusAlreadySynced

	// StatusUnknownBidder specifies a requested bidder is unknown to Prebid Server.
	StatusUnknownBidder

	// StatusTypeNotSupported specifies a requested sync type is not supported by a specific bidder.
	StatusTypeNotSupported

	// StatusDuplicate specifies the bidder is a duplicate or shared a syncer key with another bidder choice.
	StatusDuplicate

	// StatusBlockedByPrivacy specifies a bidder sync url is not allowed by privacy activities
	StatusBlockedByPrivacy

	// StatusBlockedByRegulationScope specifies the bidder chose to not sync given GDPR being in scope or because of a GPPSID
	StatusBlockedByRegulationScope

	// StatusUnconfiguredBidder refers to a bidder who hasn't been configured to have a syncer key, but is known by Prebid Server
	StatusUnconfiguredBidder

	// StatusBlockedByDisabledUsersync refers to a bidder who won't be synced because it's been disabled in its config by the host
	StatusBlockedByDisabledUsersync
)

type Sync 

type Sync struct {
	URL         string
	Type        SyncType
	SupportCORS bool
}

Sync represents a user sync to be performed by the user's device.

type SyncType 

type SyncType string

SyncType specifies the mechanism used to perform a user sync. 

const (
	// SyncTypeUnknown specifies the user sync type is invalid or not specified.
	SyncTypeUnknown SyncType = ""

	// SyncTypeIFrame specifies the user sync is to be performed within an HTML iframe
	// and to expect the server to return a valid HTML page with an embedded script.
	SyncTypeIFrame SyncType = "iframe"

	// SyncTypeRedirect specifies the user sync is to be performed within an HTML image
	// and to expect the server to return a 302 redirect.
	SyncTypeRedirect SyncType = "redirect"
)

type SyncTypeFilter 

type SyncTypeFilter struct {
	IFrame   BidderFilter
	Redirect BidderFilter
}

SyncTypeFilter determines which sync types, if any, the bidder is permitted to use.

func (SyncTypeFilter) ForBidder 

func (t SyncTypeFilter) ForBidder(bidder string) []SyncType

ForBidder returns a slice of sync types the bidder is permitted to use.

type Syncer 

type Syncer interface {
	// Key is the name of the syncer as stored in the user's cookie. This is often, but not
	// necessarily, a one-to-one mapping with a bidder.
	Key() string

	// DefaultSyncType is the default SyncType for this syncer.
	DefaultSyncType() SyncType

	// SupportsType returns true if the syncer supports at least one of the specified sync types.
	SupportsType(syncTypes []SyncType) bool

	// GetSync returns a user sync for the user's device to perform, or an error if the none of the
	// sync types are supported or if macro substitution fails.
	GetSync(syncTypes []SyncType, userSyncMacros macros.UserSyncPrivacy) (Sync, error)
}

Syncer represents the user sync configuration for a bidder or a shared set of bidders.

func NewSyncer 

func NewSyncer(hostConfig config.UserSync, syncerConfig config.Syncer, bidder string) (Syncer, error)

NewSyncer creates a new Syncer from the provided configuration, or return an error if macro substition fails or an endpoint url is invalid.

type SyncerBuildError 

type SyncerBuildError struct {
	Bidder    string
	SyncerKey string
	Err       error
}

SyncerBuildError represents an error with building a syncer.

func (SyncerBuildError) Error 

func (e SyncerBuildError) Error() string

Error implements the standard error interface.

type SyncerChoice 

type SyncerChoice struct {
	Bidder string
	Syncer Syncer
}

SyncerChoice specifies a syncer chosen.

type UIDEntry 

type UIDEntry struct {
	// UID is the ID given to a user by a particular bidder
	UID string `json:"uid"`
	// Expires is the time at which this UID should no longer apply.
	Expires time.Time `json:"expires"`
}

UIDEntry bundles the UID with an Expiration date.

type UniformBidderFilter 

type UniformBidderFilter struct {
	// contains filtered or unexported fields
}

UniformBidderFilter implements the BidderFilter interface which applies the same mode for all bidders.

func (UniformBidderFilter) Allowed 

func (f UniformBidderFilter) Allowed(bidder string) bool

Allowed returns true if the mode is include and false if the mode is either exclude or invalid.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.