prebid.js 6.3.0 → 6.7.0

package/modules/viewability.js

@@ -0,0 +1,177 @@
+import { logWarn, logInfo, isStr, isFn, triggerPixel, insertHtmlIntoIframe } from '../src/utils.js';
+import { getGlobal } from '../src/prebidGlobal.js';
+import find from 'core-js-pure/features/array/find.js';
+
+export const MODULE_NAME = 'viewability';
+
+export function init() {
+  (getGlobal()).viewability = {
+    startMeasurement: startMeasurement,
+    stopMeasurement: stopMeasurement,
+  };
+
+  listenMessagesFromCreative();
+}
+
+const observers = {};
+
+function isValid(vid, element, tracker, criteria) {
+  if (!element) {
+    logWarn(`${MODULE_NAME}: no html element provided`);
+    return false;
+  }
+
+  let validTracker = tracker &&
+    ((tracker.method === 'img' && isStr(tracker.value)) ||
+    (tracker.method === 'js' && isStr(tracker.value)) ||
+    (tracker.method === 'callback' && isFn(tracker.value)));
+
+  if (!validTracker) {
+    logWarn(`${MODULE_NAME}: invalid tracker`, tracker);
+    return false;
+  }
+
+  if (!criteria || !criteria.inViewThreshold || !criteria.timeInView) {
+    logWarn(`${MODULE_NAME}: missing criteria`, criteria);
+    return false;
+  }
+
+  if (!vid || observers[vid]) {
+    logWarn(`${MODULE_NAME}: must provide an unregistered vid`, vid);
+    return false;
+  }
+
+  return true;
+}
+
+function stopObserving(observer, vid, element) {
+  observer.unobserve(element);
+  observers[vid].done = true;
+}
+
+function fireViewabilityTracker(element, tracker) {
+  switch (tracker.method) {
+    case 'img':
+      triggerPixel(tracker.value, () => {
+        logInfo(`${MODULE_NAME}: viewability pixel fired`, tracker.value);
+      });
+      break;
+    case 'js':
+      insertHtmlIntoIframe(`<script src="${tracker.value}"></script>`);
+      break;
+    case 'callback':
+      tracker.value(element);
+      break;
+  }
+}
+
+function viewabilityCriteriaMet(observer, vid, element, tracker) {
+  stopObserving(observer, vid, element);
+  fireViewabilityTracker(element, tracker);
+}
+
+/**
+ * Start measuring viewability of an element
+ * @typedef {{ method: string='img','js','callback', value: string|function }} ViewabilityTracker { method: 'img', value: 'http://my.tracker/123' }
+ * @typedef {{ inViewThreshold: number, timeInView: number }} ViewabilityCriteria { inViewThreshold: 0.5, timeInView: 1000 }
+ * @param {string} vid unique viewability identifier
+ * @param {HTMLElement} element
+ * @param {ViewabilityTracker} tracker
+ * @param {ViewabilityCriteria} criteria
+ */
+export function startMeasurement(vid, element, tracker, criteria) {
+  if (!isValid(vid, element, tracker, criteria)) {
+    return;
+  }
+
+  const options = {
+    root: null,
+    rootMargin: '0px',
+    threshold: criteria.inViewThreshold,
+  };
+
+  let observer;
+  let viewable = false;
+  let stateChange = (entries) => {
+    viewable = entries[0].isIntersecting;
+
+    if (viewable) {
+      observers[vid].timeoutId = window.setTimeout(() => {
+        viewabilityCriteriaMet(observer, vid, element, tracker);
+      }, criteria.timeInView);
+    } else if (observers[vid].timeoutId) {
+      window.clearTimeout(observers[vid].timeoutId);
+    }
+  };
+
+  observer = new IntersectionObserver(stateChange, options);
+  observers[vid] = {
+    observer: observer,
+    element: element,
+    timeoutId: null,
+    done: false,
+  };
+
+  observer.observe(element);
+
+  logInfo(`${MODULE_NAME}: startMeasurement called with:`, arguments);
+}
+
+/**
+ * Stop measuring viewability of an element
+ * @param {string} vid unique viewability identifier
+ */
+export function stopMeasurement(vid) {
+  if (!vid || !observers[vid]) {
+    logWarn(`${MODULE_NAME}: must provide a registered vid`, vid);
+    return;
+  }
+
+  observers[vid].observer.unobserve(observers[vid].element);
+  if (observers[vid].timeoutId) {
+    window.clearTimeout(observers[vid].timeoutId);
+  }
+
+  // allow the observer under this vid to be created again
+  if (!observers[vid].done) {
+    delete observers[vid];
+  }
+}
+
+function listenMessagesFromCreative() {
+  window.addEventListener('message', receiveMessage, false);
+}
+
+/**
+ * Recieve messages from creatives
+ * @param {MessageEvent} evt
+ */
+export function receiveMessage(evt) {
+  var key = evt.message ? 'message' : 'data';
+  var data = {};
+  try {
+    data = JSON.parse(evt[key]);
+  } catch (e) {
+    return;
+  }
+
+  if (!data || data.message !== 'Prebid Viewability') {
+    return;
+  }
+
+  switch (data.action) {
+    case 'startMeasurement':
+      let element = data.elementId && document.getElementById(data.elementId);
+      if (!element) {
+        element = find(document.getElementsByTagName('IFRAME'), iframe => (iframe.contentWindow || iframe.contentDocument.defaultView) == evt.source);
+      }
+
+      startMeasurement(data.vid, element, data.tracker, data.criteria);
+      break;
+    case 'stopMeasurement':
+      stopMeasurement(data.vid);
+      break;
+  }
+}
+
+init();

package/modules/viewability.md

@@ -0,0 +1,87 @@
+# Overview
+
+Module Name: Viewability
+
+Purpose: Track when a given HTML element becomes viewable
+
+Maintainer: atrajkovic@magnite.com
+
+# Configuration
+
+Module does not need any configuration, as long as you include it in your PBJS bundle.
+Viewability module has only two functions `startMeasurement` and `stopMeasurement` which can be used to enable more complex viewability measurements. Since it allows tracking from within creative (possibly inside a safe frame) this module registers a message listener, for messages with a format that is described bellow.
+
+## `startMeasurement`
+
+| startMeasurement Arg Object | Scope | Type | Description | Example |
+| --------------------- | -------- | ------------ | -------------------------------------------------------------------------------- | --------- |
+| vid | Required | String | Unique viewability identifier, used to reference particular observer | `"ae0f9"` |
+| element | Required | HTMLElement |  Reference to an HTML element that needs to be tracked | `document.getElementById('test_div')` |
+| tracker | Required | ViewabilityTracker | How viewaility event is communicated back to the parties of interest | `{ method: 'img', value: 'http://my.tracker/123' }` |
+| criteria | Required | ViewabilityCriteria| Defines custom viewability criteria using the threshold and duration provided  | `{ inViewThreshold: 0.5, timeInView: 1000 }` |
+
+| ViewabilityTracker | Scope | Type | Description | Example |
+| --------------------- | -------- | ------------ | -------------------------------------------------------------------------------- | --------- |
+| method | Required | String | Type of method for Tracker | `'img' OR 'js' OR 'callback'` |
+| value | Required | String | URL string for 'img' and 'js' Trackers, or a function for 'callback' Tracker | `'http://my.tracker/123'` |
+
+| ViewabilityCriteria | Scope | Type | Description | Example |
+| --------------------- | -------- | ------------ | -------------------------------------------------------------------------------- | --------- |
+| inViewThreshold | Required | Number | Represents a percentage threshold for the Element to be registered as in view | `0.5` |
+| timeInView | Required | Number | Number of milliseconds that a given element needs to be in view continuously, above the threshold | `1000` |
+
+## Please Note:
+- `vid` allows for multiple trackers, with different criteria to be registered for a given HTML element, independently. It's not autogenerated by `startMeasurement()`, it needs to be provided by the caller so that it doesn't have to be posted back to the source iframe (in case viewability is started from within the creative).
+- In case of 'callback' method, HTML element is being passed back to the callback function.
+- When a tracker needs to be started, without direct access to pbjs, postMessage mechanism can be used to invoke `startMeasurement`, with a following payload: `vid`, `tracker` and `criteria` as described above, but also with `message: 'Prebid Viewability'` and `action: 'startMeasurement'`. Optionally payload can provide `elementId`, if available at that time (for ad servers where name of the iframe is known, or adservers that render outside an iframe). If `elementId` is not provided, viewability module will try to find the iframe that corresponds to the message source. 
+
+
+## `stopMeasurement`
+
+| stopMeasurement Arg Object | Scope | Type | Description | Example |
+| --------------------- | -------- | ------------ | -------------------------------------------------------------------------------- | --------- |
+| vid | Required | String | Unique viewability identifier, referencing an already started viewability tracker. | `"ae0f9"` |
+
+## Please Note:
+- When a tracker needs to be stopped, without direct access to pbjs, postMessage mechanism can be used here as well. To invoke `stopMeasurement`, you provide the payload with `vid`, `message: 'Prebid Viewability'` and `action: 'stopMeasurement`. Check the example bellow.
+
+# Examples
+
+## Example of starting a viewability measurement, when you have direct access to pbjs
+```
+pbjs.viewability.startMeasurement(
+    'ae0f9', 
+    document.getElementById('test_div'),
+    { method: 'img', value: 'http://my.tracker/123' },
+    { inViewThreshold: 0.5, timeInView: 1000 }
+);
+```
+
+## Example of starting a viewability measurement from within a rendered creative
+```
+let viewabilityRecord = {
+    vid: 'ae0f9',
+    tracker: { method: 'img', value: 'http://my.tracker/123'},
+    criteria: { inViewThreshold: 0.5, timeInView: 1000 },
+    message: 'Prebid Viewability',
+    action: 'startMeasurement'
+}
+
+window.parent.postMessage(JSON.stringify(viewabilityRecord), '*');
+```
+
+## Example of stopping the viewability measurement, when you have direct access to pbjs
+```
+pbjs.viewability.stopMeasurement('ae0f9');
+```
+
+## Example of stopping the viewability measurement from within a rendered creative
+```
+let viewabilityRecord = {
+    vid: 'ae0f9',
+    message: 'Prebid Viewability',
+    action: 'stopMeasurement'
+}
+
+window.parent.postMessage(JSON.stringify(viewabilityRecord), '*');
+```

package/modules/welectBidAdapter.js

@@ -0,0 +1,106 @@
+import { deepAccess } from '../src/utils.js';
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+
+const BIDDER_CODE = 'welect';
+const DEFAULT_DOMAIN = 'www.welect.de';
+
+export const spec = {
+  code: BIDDER_CODE,
+  aliases: ['wlt'],
+  gvlid: 282,
+  supportedMediaTypes: ['video'],
+
+  // short code
+  /**
+   * Determines whether or not the given bid request is valid.
+   *
+   * @param {BidRequest} bid The bid params to validate.
+   * @return boolean True if this is a valid bid, and false otherwise.
+   */
+  isBidRequestValid: function (bid) {
+    return (
+      deepAccess(bid, 'mediaTypes.video.context') === 'instream' &&
+      !!bid.params.placementId
+    );
+  },
+  /**
+   * Make a server request from the list of BidRequests.
+   *
+   * @param {validBidRequests[]} - an array of bids
+   * @return ServerRequest Info describing the request to the server.
+   */
+  buildRequests: function (validBidRequests) {
+    return validBidRequests.map((bidRequest) => {
+      let rawSizes =
+        deepAccess(bidRequest, 'mediaTypes.video.playerSize') ||
+        bidRequest.sizes;
+      let size = rawSizes[0];
+
+      let domain = bidRequest.params.domain || DEFAULT_DOMAIN;
+
+      let url = `https://${domain}/api/v2/preflight/${bidRequest.params.placementId}`;
+
+      let gdprConsent = null;
+
+      if (bidRequest && bidRequest.gdprConsent) {
+        gdprConsent = {
+          gdpr_consent: {
+            gdprApplies: bidRequest.gdprConsent.gdprApplies,
+            tcString: bidRequest.gdprConsent.gdprConsent,
+          },
+        };
+      }
+
+      const data = {
+        width: size[0],
+        height: size[1],
+        bid_id: bidRequest.bidId,
+        ...gdprConsent,
+      };
+
+      return {
+        method: 'POST',
+        url: url,
+        data: data,
+        options: {
+          contentType: 'application/json',
+          withCredentials: false,
+          crossOrigin: true,
+        },
+      };
+    });
+  },
+  /**
+   * Unpack the response from the server into a list of bids.
+   *
+   * @param {ServerResponse} serverResponse A successful response from the server.
+   * @return {Bid[]} An array of bids which were nested inside the server.
+   */
+  interpretResponse: function (serverResponse, bidRequest) {
+    const responseBody = serverResponse.body;
+
+    if (typeof responseBody !== 'object' || responseBody.available !== true) {
+      return [];
+    }
+
+    const bidResponses = [];
+    const bidResponse = {
+      requestId: responseBody.bidResponse.requestId,
+      cpm: responseBody.bidResponse.cpm,
+      width: responseBody.bidResponse.width,
+      height: responseBody.bidResponse.height,
+      creativeId: responseBody.bidResponse.creativeId,
+      currency: responseBody.bidResponse.currency,
+      netRevenue: responseBody.bidResponse.netRevenue,
+      ttl: responseBody.bidResponse.ttl,
+      ad: responseBody.bidResponse.ad,
+      vastUrl: responseBody.bidResponse.vastUrl,
+      meta: {
+        advertiserDomains: responseBody.bidResponse.meta.advertiserDomains
+      }
+    };
+    bidResponses.push(bidResponse);
+    return bidResponses;
+  },
+};
+registerBidder(spec);

package/modules/yieldmoBidAdapter.js

@@ -55,13 +55,8 @@ export const spec = {
         p: [],
         page_url: bidderRequest.refererInfo.referer,
         bust: new Date().getTime().toString(),
-        pr: (LOCAL_WINDOW.document && LOCAL_WINDOW.document.referrer) || '',
-        scrd: LOCAL_WINDOW.devicePixelRatio || 0,
         dnt: getDNT(),
         description: getPageDescription(),
-        title: LOCAL_WINDOW.document.title || '',
-        w: LOCAL_WINDOW.innerWidth,
-        h: LOCAL_WINDOW.innerHeight,
         userConsent: JSON.stringify({
           // case of undefined, stringify will remove param
           gdprApplies: deepAccess(bidderRequest, 'gdprConsent.gdprApplies') || '',
@@ -70,6 +65,14 @@ export const spec = {
         us_privacy: deepAccess(bidderRequest, 'uspConsent') || ''
       };
 
+      if (canAccessTopWindow()) {
+        serverRequest.pr = (LOCAL_WINDOW.document && LOCAL_WINDOW.document.referrer) || '';
+        serverRequest.scrd = LOCAL_WINDOW.devicePixelRatio || 0;
+        serverRequest.title = LOCAL_WINDOW.document.title || '';
+        serverRequest.w = LOCAL_WINDOW.innerWidth;
+        serverRequest.h = LOCAL_WINDOW.innerHeight;
+      }
+
       const mtp = window.navigator.maxTouchPoints;
       if (mtp) {
         serverRequest.mtp = mtp;
@@ -609,3 +612,18 @@ function getEids(bidRequest) {
     return createEidsArray(bidRequest.userId) || [];
   }
 };
+
+/**
+ * Check if top window can be accessed
+ *
+ * @return {boolean} true if can access top window otherwise false
+ */
+function canAccessTopWindow() {
+  try {
+    if (getWindowTop().location.href) {
+      return true;
+    }
+  } catch (error) {
+    return false;
+  }
+}

package/modules/zeta_global_sspAnalyticsAdapter.js

@@ -0,0 +1,97 @@
+import { logInfo, logError } from '../src/utils.js';
+import { ajax } from '../src/ajax.js';
+import adapterManager from '../src/adapterManager.js';
+import CONSTANTS from '../src/constants.json';
+
+import adapter from '../src/AnalyticsAdapter.js';
+
+const ZETA_GVL_ID = 833;
+const ADAPTER_CODE = 'zeta_global_ssp';
+const BASE_URL = 'https://ssp.disqus.com/prebid/event';
+const LOG_PREFIX = 'ZetaGlobalSsp-Analytics: ';
+
+/// /////////// VARIABLES ////////////////////////////////////
+
+let publisherId; // int
+
+/// /////////// HELPER FUNCTIONS /////////////////////////////
+
+function sendEvent(eventType, event) {
+  ajax(
+    BASE_URL + '/' + eventType,
+    null,
+    JSON.stringify(event)
+  );
+}
+
+/// /////////// ADAPTER EVENT HANDLER FUNCTIONS //////////////
+
+function adRenderSucceededHandler(args) {
+  let eventType = CONSTANTS.EVENTS.AD_RENDER_SUCCEEDED
+  logInfo(LOG_PREFIX + 'handle ' + eventType + ' event');
+
+  sendEvent(eventType, args);
+}
+
+function auctionEndHandler(args) {
+  let eventType = CONSTANTS.EVENTS.AUCTION_END;
+  logInfo(LOG_PREFIX + 'handle ' + eventType + ' event');
+
+  sendEvent(eventType, args);
+}
+
+/// /////////// ADAPTER DEFINITION ///////////////////////////
+
+let baseAdapter = adapter({ analyticsType: 'endpoint' });
+let zetaAdapter = Object.assign({}, baseAdapter, {
+
+  enableAnalytics(config = {}) {
+    let error = false;
+
+    if (typeof config.options === 'object') {
+      if (config.options.sid) {
+        publisherId = Number(config.options.sid);
+      }
+    } else {
+      logError(LOG_PREFIX + 'Config not found');
+      error = true;
+    }
+
+    if (!publisherId) {
+      logError(LOG_PREFIX + 'Missing sid (publisher id)');
+      error = true;
+    }
+
+    if (error) {
+      logError(LOG_PREFIX + 'Analytics is disabled due to error(s)');
+    } else {
+      baseAdapter.enableAnalytics.call(this, config);
+    }
+  },
+
+  disableAnalytics() {
+    publisherId = undefined;
+    baseAdapter.disableAnalytics.apply(this, arguments);
+  },
+
+  track({ eventType, args }) {
+    switch (eventType) {
+      case CONSTANTS.EVENTS.AD_RENDER_SUCCEEDED:
+        adRenderSucceededHandler(args);
+        break;
+      case CONSTANTS.EVENTS.AUCTION_END:
+        auctionEndHandler(args);
+        break;
+    }
+  }
+});
+
+/// /////////// ADAPTER REGISTRATION /////////////////////////
+
+adapterManager.registerAnalyticsAdapter({
+  adapter: zetaAdapter,
+  code: ADAPTER_CODE,
+  gvlid: ZETA_GVL_ID
+});
+
+export default zetaAdapter;

package/modules/zeta_global_sspAnalyticsAdapter.md

@@ -0,0 +1,24 @@
+# Zeta Global SSP Analytics Adapter
+
+## Overview
+
+Module Name: Zeta Global SSP Analytics Adapter\
+Module Type: Analytics Adapter\
+Maintainer: abermanov@zetaglobal.com
+
+## Description
+
+Analytics Adapter which sends auctionEnd and adRenderSucceeded events to Zeta Global SSP analytics endpoints
+
+## How to configure
+```
+pbjs.enableAnalytics({
+    provider: 'zeta_global_ssp',
+    options: {
+        sid: 111,
+        tags: {
+            ...
+        }
+    }
+});
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "6.3.0",
+  "version": "6.7.0",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {

package/src/auction.js

@@ -569,7 +569,7 @@ function setupBidTargeting(bidObject, bidderRequest) {
   let keyValues;
   const cpmCheck = (isAllowZeroCpmBidsEnabled(bidObject.bidderCode)) ? bidObject.cpm >= 0 : bidObject.cpm > 0;
   if (bidObject.bidderCode && (cpmCheck || bidObject.dealId)) {
-    let bidReq = find(bidderRequest.bids, bid => bid.adUnitCode === bidObject.adUnitCode);
+    let bidReq = find(bidderRequest.bids, bid => bid.adUnitCode === bidObject.adUnitCode && bid.bidId === bidObject.requestId);
     keyValues = getKeyValueTargetingPairs(bidObject.bidderCode, bidObject, bidReq);
   }
 
@@ -744,7 +744,7 @@ function setKeys(keyValues, bidderSettings, custBidObj, bidReq) {
     var value = kvPair.val;
 
     if (keyValues[key]) {
-      logWarn('The key: ' + key + ' is getting ovewritten');
+      logWarn('The key: ' + key + ' is being overwritten');
     }
 
     if (isFn(value)) {

package/src/config.js

@@ -1,6 +1,6 @@
 /*
  * Module for getting and setting Prebid configuration.
- */
+*/
 
 /**
  * @typedef {Object} MediaTypePriceGranularity
@@ -580,7 +580,7 @@ export function newConfig() {
       .forEach(listener => listener.callback(options));
   }
 
-  function setBidderConfig(config) {
+  function setBidderConfig(config, mergeFlag = false) {
     try {
       check(config);
       config.bidders.forEach(bidder => {
@@ -592,7 +592,8 @@ export function newConfig() {
           let option = (topic === 'fpd') ? convertFpd(config.config[topic]) : config.config[topic];
 
           if (isPlainObject(option)) {
-            bidderConfig[bidder][prop] = Object.assign({}, bidderConfig[bidder][prop] || {}, option);
+            const func = mergeFlag ? mergeDeep : Object.assign;
+            bidderConfig[bidder][prop] = func({}, bidderConfig[bidder][prop] || {}, option);
           } else {
             bidderConfig[bidder][prop] = option;
           }
@@ -601,6 +602,7 @@ export function newConfig() {
     } catch (e) {
       logError(e);
     }
+
     function check(obj) {
       if (!isPlainObject(obj)) {
         throw 'setBidderConfig bidder options must be an object';
@@ -614,6 +616,26 @@ export function newConfig() {
     }
   }
 
+  function mergeConfig(obj) {
+    if (!isPlainObject(obj)) {
+      logError('mergeConfig input must be an object');
+      return;
+    }
+
+    const mergedConfig = Object.keys(obj).reduce((accum, key) => {
+      const prevConf = _getConfig(key)[key] || {};
+      accum[key] = mergeDeep(prevConf, obj[key]);
+      return accum;
+    }, {});
+
+    setConfig({ ...mergedConfig });
+    return mergedConfig;
+  }
+
+  function mergeBidderConfig(obj) {
+    return setBidderConfig(obj, true);
+  }
+
   /**
    * Internal functions for core to execute some synchronous code while having an active bidder set.
    */
@@ -653,12 +675,14 @@ export function newConfig() {
     getConfig,
     readConfig,
     setConfig,
+    mergeConfig,
     setDefaults,
     resetConfig,
     runWithBidder,
     callbackWithBidder,
     setBidderConfig,
     getBidderConfig,
+    mergeBidderConfig,
     convertAdUnitFpd,
     getLegacyFpd,
     getLegacyImpFpd

package/src/hook.js

@@ -13,14 +13,18 @@ export function setupBeforeHookFnOnce(baseFn, hookFn, priority = 15) {
     baseFn.before(hookFn, priority);
   }
 }
+const submoduleInstallMap = {};
 
-export function module(name, install) {
+export function module(name, install, {postInstallAllowed = false} = {}) {
   hook('async', function (submodules) {
     submodules.forEach(args => install(...args));
+    if (postInstallAllowed) submoduleInstallMap[name] = install;
   }, name)([]); // will be queued until hook.ready() called in pbjs.processQueue();
 }
 
 export function submodule(name, ...args) {
+  const install = submoduleInstallMap[name];
+  if (install) return install(...args);
   getHook(name).before((next, modules) => {
     modules.push(args);
     next(modules);