prebid.js 5.20.0 → 6.3.0

package/modules/yieldlabBidAdapter.md

@@ -11,53 +11,96 @@ Maintainer: solutions@yieldlab.de
 Module that connects to Yieldlab's demand sources
 
 # Test Parameters
+
+```javascript
+const adUnits = [
+    {
+        code: 'banner',
+        sizes: [ [ 728, 90 ] ],
+        bids: [{
+            bidder: 'yieldlab',
+            params: {
+                adslotId: '5220336',
+                supplyId: '1381604',
+                targeting: {
+                    key1: 'value1',
+                    key2: 'value2'
+                },
+                extId: 'abc',
+                iabContent: {
+                    id: 'some_id',
+                    episode: '1',
+                    title: 'some title',
+                    series: 'some series',
+                    season: 's1',
+                    artist: 'John Doe',
+                    genre: 'some genre',
+                    isrc: 'CC-XXX-YY-NNNNN',
+                    url: 'http://foo_url.de',
+                    cat: [ 'IAB1-1', 'IAB1-2', 'IAB2-10' ],
+                    context: '7',
+                    keywords: ['k1', 'k2'],
+                    live: '0'
+                }
+            }
+        }]
+    },
+    {
+        code: 'video',
+        sizes: [ [ 640, 480 ] ],
+        mediaTypes: {
+            video: {
+                context: 'instream' // or 'outstream'
+            }
+        },
+        bids: [{
+            bidder: 'yieldlab',
+            params: {
+                adslotId: '5220339',
+                supplyId: '1381604'
+            }
+        }]
+    },
+    {
+        code: 'native',
+        mediaTypes: {
+            native: {
+                // native config
+            }
+        },
+        bids: [{
+            bidder: 'yieldlab',
+            params: {
+                adslotId: '5220339',
+                supplyId: '1381604'
+            }
+        }]
+    }
+];
 ```
-    var adUnits = [
-           {
-               code: "banner",
-               sizes: [[728, 90]],
-               bids: [{
-                   bidder: "yieldlab",
-                   params: {
-                       adslotId: "5220336",
-                       supplyId: "1381604",
-                       targeting: {
-                           key1: "value1",
-                           key2: "value2"
-                       },
-                       extId: "abc",
-                       iabContent: {
-                           id: "some_id",
-                           episode: "1",
-                           title: "some title",
-                           series: "some series",
-                           season: "s1",
-                           artist: "John Doe",
-                           genre: "some genre",
-                           isrc: "CC-XXX-YY-NNNNN",
-                           url: "http://foo_url.de",
-                           cat: ["IAB1-1", "IAB1-2", "IAB2-10"],
-                           context: "7",
-                           keywords: ["k1", "k2"],
-                           live: "0"
-                       }
-                   }
-               }]
-           }, {
-               code: "video",
-               sizes: [[640, 480]],
-               mediaTypes: {
-                   video: {
-                       context: "instream" // or "outstream"
-                   }
-               },
-               bids: [{
-                   bidder: "yieldlab",
-                   params: {
-                       adslotId: "5220339",
-                       supplyId: "1381604"
-                   }
-               }]
-           }
-       ];
+
+# Multi-Format Setup
+
+A general overview of how to set up multi-format ads can be found in the offical Prebid.js docs. See: [show multi-format ads](https://docs.prebid.org/dev-docs/show-multi-format-ads.html)
+
+When setting up multi-format ads with Yieldlab make sure to always add at least one eligible Adslot per given media type in the ad unit configuration.
+
+```javascript
+const adUnit = {
+    code: 'multi-format-adslot',
+    mediaTypes: {
+        banner: {
+            sizes: [ [ 728, 90 ] ]
+        },
+        native: {
+            // native config
+        }
+    },
+    bids: [
+        // banner Adslot
+        { bidder: 'yieldlab', params: { adslotId: '1234', supplyId: '42' } },
+        // native Adslot
+        { bidder: 'yieldlab', params: { adslotId: '2345', supplyId: '42' } }
+    ]
+};
 ```

package/modules/yieldoneBidAdapter.js

@@ -1,4 +1,4 @@
-import { deepAccess, isEmpty, parseSizesInput, isStr, logWarn } from '../src/utils.js';
+import {deepAccess, isEmpty, isStr, logWarn, parseSizesInput} from '../src/utils.js';
 import {config} from '../src/config.js';
 import {registerBidder} from '../src/adapters/bidderFactory.js';
 import { Renderer } from '../src/Renderer.js';
@@ -11,6 +11,8 @@ const VIDEO_PLAYER_URL = 'https://img.ak.impact-ad.jp/ic/pone/ivt/firstview/js/d
 const CMER_PLAYER_URL = 'https://an.cmertv.com/hb/renderer/cmertv-video-yone-prebid.min.js';
 const VIEWABLE_PERCENTAGE_URL = 'https://img.ak.impact-ad.jp/ic/pone/ivt/firstview/js/prebid-adformat-config.js';
 
+const DEFAULT_VIDEO_SIZE = {w: 640, h: 360};
+
 export const spec = {
   code: BIDDER_CODE,
   aliases: ['y1'],
@@ -40,16 +42,18 @@ export const spec = {
         t: 'i'
       };
 
-      const videoMediaType = deepAccess(bidRequest, 'mediaTypes.video');
-      if ((isEmpty(bidRequest.mediaType) && isEmpty(bidRequest.mediaTypes)) ||
-      (bidRequest.mediaType === BANNER || (bidRequest.mediaTypes && bidRequest.mediaTypes[BANNER]))) {
-        const sizes = deepAccess(bidRequest, 'mediaTypes.banner.sizes') || bidRequest.sizes;
-        payload.sz = parseSizesInput(sizes).join(',');
-      } else if (bidRequest.mediaType === VIDEO || videoMediaType) {
-        const sizes = deepAccess(bidRequest, 'mediaTypes.video.playerSize') || bidRequest.sizes;
-        const size = parseSizesInput(sizes)[0];
-        payload.w = size.split('x')[0];
-        payload.h = size.split('x')[1];
+      const mediaType = getMediaType(bidRequest);
+      switch (mediaType) {
+        case BANNER:
+          payload.sz = getBannerSizes(bidRequest);
+          break;
+        case VIDEO:
+          const videoSize = getVideoSize(bidRequest);
+          payload.w = videoSize.w;
+          payload.h = videoSize.h;
+          break;
+        default:
+          break;
       }
 
       // LiveRampID
@@ -167,6 +171,106 @@ export const spec = {
   },
 }
 
+/**
+ * NOTE: server side does not yet support multiple formats.
+ * @param  {Object} bidRequest -
+ * @param  {boolean} [enabledOldFormat = true] - default: `true`.
+ * @return {string|null} - `"banner"` or `"video"` or `null`.
+ */
+function getMediaType(bidRequest, enabledOldFormat = true) {
+  let hasBannerType = Boolean(deepAccess(bidRequest, 'mediaTypes.banner'));
+  let hasVideoType = Boolean(deepAccess(bidRequest, 'mediaTypes.video'));
+
+  if (enabledOldFormat) {
+    hasBannerType = hasBannerType || bidRequest.mediaType === BANNER ||
+      (isEmpty(bidRequest.mediaTypes) && isEmpty(bidRequest.mediaType));
+    hasVideoType = hasVideoType || bidRequest.mediaType === VIDEO;
+  }
+
+  if (hasBannerType && hasVideoType) {
+    const playerParams = deepAccess(bidRequest, 'params.playerParams')
+    if (playerParams) {
+      return VIDEO;
+    } else {
+      return BANNER;
+    }
+  } else if (hasBannerType) {
+    return BANNER;
+  } else if (hasVideoType) {
+    return VIDEO;
+  }
+
+  return null;
+}
+
+/**
+ * NOTE:
+ *   If `mediaTypes.banner` exists, then `mediaTypes.banner.sizes` must also exist.
+ *   The reason for this is that Prebid.js will perform the verification and
+ *   if `mediaTypes.banner.sizes` is inappropriate, it will delete the entire `mediaTypes.banner`.
+ * @param  {Object} bidRequest -
+ * @param  {Object} bidRequest.banner -
+ * @param  {Array<string>} bidRequest.banner.sizes -
+ * @param  {boolean} [enabledOldFormat = true] - default: `true`.
+ * @return {string} - strings like `"300x250"` or `"300x250,728x90"`.
+ */
+function getBannerSizes(bidRequest, enabledOldFormat = true) {
+  let sizes = deepAccess(bidRequest, 'mediaTypes.banner.sizes');
+
+  if (enabledOldFormat) {
+    sizes = sizes || bidRequest.sizes;
+  }
+
+  return parseSizesInput(sizes).join(',');
+}
+
+/**
+ * @param  {Object} bidRequest -
+ * @param  {boolean} [enabledOldFormat = true] - default: `true`.
+ * @param  {boolean} [enabledFlux = true] - default: `true`.
+ * @return {{w: number, h: number}} -
+ */
+function getVideoSize(bidRequest, enabledOldFormat = true, enabledFlux = true) {
+  /**
+   * @param  {Array<number, number> | Array<Array<number, number>>} sizes -
+   * @return {{w: number, h: number} | null} -
+   */
+  const _getPlayerSize = (sizes) => {
+    let result = null;
+
+    const size = parseSizesInput(sizes)[0];
+    if (isEmpty(size)) {
+      return result;
+    }
+
+    const splited = size.split('x');
+    const sizeObj = {w: parseInt(splited[0], 10), h: parseInt(splited[1], 10)};
+    const _isValidPlayerSize = !(isEmpty(sizeObj)) && (isFinite(sizeObj.w) && isFinite(sizeObj.h));
+    if (!_isValidPlayerSize) {
+      return result;
+    }
+
+    result = sizeObj;
+    return result;
+  }
+
+  let playerSize = _getPlayerSize(deepAccess(bidRequest, 'mediaTypes.video.playerSize'));
+
+  if (enabledOldFormat) {
+    playerSize = playerSize || _getPlayerSize(bidRequest.sizes);
+  }
+
+  if (enabledFlux) {
+    // NOTE: `video.playerSize` in Flux is always [1,1].
+    if (playerSize && (playerSize.w === 1 && playerSize.h === 1)) {
+      // NOTE: `params.playerSize` is a specific object to support `FLUX`.
+      playerSize = _getPlayerSize(deepAccess(bidRequest, 'params.playerSize'));
+    }
+  }
+
+  return playerSize || DEFAULT_VIDEO_SIZE;
+}
+
 function newRenderer(response) {
   const renderer = Renderer.install({
     id: response.uid,

package/modules/zetaSspBidAdapter.md

@@ -10,7 +10,7 @@ Maintainer: miakovlev@zetaglobal.com
 
 Module that connects to Zeta's SSP
 
-# Test Parameters
+# Banner Ad Unit: For Publishers
 ```
         var adUnits = [
             {
@@ -40,3 +40,35 @@ Module that connects to Zeta's SSP
             }
         ];
 ```
+
+# Video Ad Unit: For Publishers
+```
+        var adUnits = [
+            {
+                mediaTypes: {
+                    video: {
+                        playerSize: [640, 480],
+                        context: 'outstream'
+                    }
+                },
+                bids: [
+                    {
+                        bidder: 'zeta_global_ssp',
+                        bidId: 12345,
+                        params: {
+                            placement: 12345,
+                            user: {
+                                uid: 12345,
+                                buyeruid: 12345
+                            },
+                            tags: {
+                                someTag: 123,
+                                sid: 'publisherId'
+                            },
+                            test: 1
+                        }
+                    }
+                ]
+            }
+        ];
+```

package/modules/zeta_global_sspBidAdapter.js

@@ -1,4 +1,4 @@
-import { logWarn, deepSetValue, deepAccess, isArray, isNumber, isBoolean, isStr } from '../src/utils.js';
+import {deepAccess, deepSetValue, isArray, isBoolean, isNumber, isStr, logWarn} from '../src/utils.js';
 import {registerBidder} from '../src/adapters/bidderFactory.js';
 import {BANNER, VIDEO} from '../src/mediaTypes.js';
 import {config} from '../src/config.js';
@@ -11,6 +11,8 @@ const DEFAULT_CUR = 'USD';
 const TTL = 200;
 const NET_REV = true;
 
+const VIDEO_REGEX = new RegExp(/VAST\s+version/);
+
 const DATA_TYPES = {
   'NUMBER': 'number',
   'STRING': 'string',
@@ -161,6 +163,7 @@ export const spec = {
               advertiserDomains: zetaBid.adomain
             };
           }
+          provideMediaType(zetaBid, bid);
           bidResponses.push(bid);
         })
       })
@@ -284,4 +287,22 @@ function isConnectedTV() {
   return /(smart[-]?tv|hbbtv|appletv|googletv|hdmi|netcast\.tv|viera|nettv|roku|\bdtv\b|sonydtv|inettvbrowser|\btv\b)/i.test(navigator.userAgent);
 }
 
+function provideMediaType(zetaBid, bid) {
+  if (zetaBid.ext && zetaBid.ext.bidtype) {
+    if (zetaBid.ext.bidtype === VIDEO) {
+      bid.mediaType = VIDEO;
+      bid.vastXml = bid.ad;
+    } else {
+      bid.mediaType = BANNER;
+    }
+  } else {
+    if (VIDEO_REGEX.test(bid.ad)) {
+      bid.mediaType = VIDEO;
+      bid.vastXml = bid.ad;
+    } else {
+      bid.mediaType = BANNER;
+    }
+  }
+}
+
 registerBidder(spec);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "5.20.0",
+  "version": "6.3.0",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {
@@ -11,6 +11,11 @@
     "type": "git",
     "url": "https://github.com/prebid/Prebid.js.git"
   },
+  "browserslist": [
+    "> 0.25%",
+    "not IE 11",
+    "not op_mini all"
+  ],
   "keywords": [
     "advertising",
     "auction",

package/plugins/pbjsGlobals.js

@@ -1,11 +1,13 @@
 
 let t = require('@babel/core').types;
 let prebid = require('../package.json');
+const path = require('path');
 
 module.exports = function(api, options) {
+  const pbGlobal = options.globalVarName || prebid.globalVarName;
   let replace = {
     '$prebid.version$': prebid.version,
-    '$$PREBID_GLOBAL$$': options.globalVarName || prebid.globalVarName,
+    '$$PREBID_GLOBAL$$': pbGlobal,
     '$$REPO_AND_VERSION$$': `${prebid.repository.url.split('/')[3]}_prebid_${prebid.version}`
   };
 
@@ -13,8 +15,33 @@ module.exports = function(api, options) {
     '$$REPO_AND_VERSION$$'
   ];
 
+  const PREBID_ROOT = path.resolve(__dirname, '..');
+
+  function getModuleName(filename) {
+    const modPath = path.parse(path.relative(PREBID_ROOT, filename));
+    if (modPath.ext.toLowerCase() !== '.js') {
+      return null;
+    }
+    if (modPath.dir === 'modules') {
+      // modules/moduleName.js -> moduleName
+      return modPath.name;
+    }
+    if (modPath.name.toLowerCase() === 'index' && path.dirname(modPath.dir) === 'modules') {
+      // modules/moduleName/index.js -> moduleName
+      return path.basename(modPath.dir);
+    }
+    return null;
+  }
+
   return {
     visitor: {
+      Program(path, state) {
+        const modName = getModuleName(state.filename);
+        if (modName != null) {
+          // append "registration" of module file to $$PREBID_GLOBAL$$.installedModules
+          path.node.body.push(...api.parse(`window.${pbGlobal}.installedModules.push('${modName}');`).program.body);
+        }
+      },
       StringLiteral(path) {
         Object.keys(replace).forEach(name => {
           if (path.node.value.includes(name)) {

package/src/adapterManager.js

@@ -262,14 +262,16 @@ adapterManager.makeBidRequests = hook('sync', function (adUnits, auctionStart, a
       }
 
       let adUnitsS2SCopy = getAdUnitCopyForPrebidServer(adUnits, s2sConfig);
-      let tid = generateUUID();
+
+      // uniquePbsTid is so we know which server to send which bids to during the callBids function
+      let uniquePbsTid = generateUUID();
       adaptersServerSide.forEach(bidderCode => {
         const bidderRequestId = getUniqueIdentifierStr();
         const bidderRequest = {
           bidderCode,
           auctionId,
           bidderRequestId,
-          tid,
+          uniquePbsTid,
           bids: hookedGetBids({bidderCode, auctionId, bidderRequestId, 'adUnits': deepClone(adUnitsS2SCopy), labels, src: CONSTANTS.S2S.SRC}),
           auctionStart: auctionStart,
           timeout: s2sConfig.timeout,
@@ -350,7 +352,7 @@ adapterManager.callBids = (adUnits, bidRequests, addBidResponse, doneCb, request
   serverBidRequests.forEach(serverBidRequest => {
     var index = -1;
     for (var i = 0; i < uniqueServerBidRequests.length; ++i) {
-      if (serverBidRequest.tid === uniqueServerBidRequests[i].tid) {
+      if (serverBidRequest.uniquePbsTid === uniqueServerBidRequests[i].uniquePbsTid) {
         index = i;
         break;
       }
@@ -360,7 +362,10 @@ adapterManager.callBids = (adUnits, bidRequests, addBidResponse, doneCb, request
     }
   });
 
-  let counter = 0
+  let counter = 0;
+
+  // $.source.tid MUST be a unique UUID and also THE SAME between all PBS Requests for a given Auction
+  const sourceTid = generateUUID();
   _s2sConfigs.forEach((s2sConfig) => {
     if (s2sConfig && uniqueServerBidRequests[counter] && includes(s2sConfig.bidders, uniqueServerBidRequests[counter].bidderCode)) {
       // s2s should get the same client side timeout as other client side requests.
@@ -370,13 +375,13 @@ adapterManager.callBids = (adUnits, bidRequests, addBidResponse, doneCb, request
       } : undefined);
       let adaptersServerSide = s2sConfig.bidders;
       const s2sAdapter = _bidderRegistry[s2sConfig.adapter];
-      let tid = uniqueServerBidRequests[counter].tid;
+      let uniquePbsTid = uniqueServerBidRequests[counter].uniquePbsTid;
       let adUnitsS2SCopy = uniqueServerBidRequests[counter].adUnitsS2SCopy;
 
-      let uniqueServerRequests = serverBidRequests.filter(serverBidRequest => serverBidRequest.tid === tid)
+      let uniqueServerRequests = serverBidRequests.filter(serverBidRequest => serverBidRequest.uniquePbsTid === uniquePbsTid);
 
       if (s2sAdapter) {
-        let s2sBidRequest = {tid, 'ad_units': adUnitsS2SCopy, s2sConfig};
+        let s2sBidRequest = {tid: sourceTid, 'ad_units': adUnitsS2SCopy, s2sConfig};
         if (s2sBidRequest.ad_units.length) {
           let doneCbs = uniqueServerRequests.map(bidRequest => {
             bidRequest.start = timestamp();
@@ -391,7 +396,8 @@ adapterManager.callBids = (adUnits, bidRequests, addBidResponse, doneCb, request
 
           // fire BID_REQUESTED event for each s2s bidRequest
           uniqueServerRequests.forEach(bidRequest => {
-            events.emit(CONSTANTS.EVENTS.BID_REQUESTED, bidRequest);
+            // add the new sourceTid
+            events.emit(CONSTANTS.EVENTS.BID_REQUESTED, {...bidRequest, tid: sourceTid});
           });
 
           // make bid requests

package/src/auction.js

@@ -59,7 +59,7 @@
 
 import {
   flatten, timestamp, adUnitsFilter, deepAccess, getBidRequest, getValue, parseUrl, generateUUID,
-  logMessage, bind, logError, logInfo, logWarn, isEmpty, _each, isFn, isEmptyStr
+  logMessage, bind, logError, logInfo, logWarn, isEmpty, _each, isFn, isEmptyStr, isAllowZeroCpmBidsEnabled
 } from './utils.js';
 import { getPriceBucketString } from './cpmBucketManager.js';
 import { getNativeTargeting } from './native.js';
@@ -567,7 +567,8 @@ function getPreparedBidForAuction({adUnitCode, bid, bidderRequest, auctionId}) {
 
 function setupBidTargeting(bidObject, bidderRequest) {
   let keyValues;
-  if (bidObject.bidderCode && (bidObject.cpm > 0 || bidObject.dealId)) {
+  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);
     keyValues = getKeyValueTargetingPairs(bidObject.bidderCode, bidObject, bidReq);
   }

package/src/prebid.js

@@ -47,8 +47,7 @@ $$PREBID_GLOBAL$$.libLoaded = true;
 $$PREBID_GLOBAL$$.version = 'v$prebid.version$';
 logInfo('Prebid.js v$prebid.version$ loaded');
 
-// modules list generated from build
-$$PREBID_GLOBAL$$.installedModules = ['v$prebid.modulesList$'];
+$$PREBID_GLOBAL$$.installedModules = $$PREBID_GLOBAL$$.installedModules || [];
 
 // create adUnit array
 $$PREBID_GLOBAL$$.adUnits = $$PREBID_GLOBAL$$.adUnits || [];

package/src/targeting.js

@@ -1,6 +1,6 @@
 import {
   uniques, isGptPubadsDefined, getHighestCpm, getOldestHighestCpmBid, groupBy, isAdUnitCodeMatchingSlot, timestamp,
-  deepAccess, deepClone, logError, logWarn, logInfo, isFn, isArray, logMessage, isStr
+  deepAccess, deepClone, logError, logWarn, logInfo, isFn, isArray, logMessage, isStr, isAllowZeroCpmBidsEnabled
 } from './utils.js';
 import { config } from './config.js';
 import { NATIVE_TARGETING_KEYS } from './native.js';
@@ -18,6 +18,10 @@ var pbTargetingKeys = [];
 const MAX_DFP_KEYLENGTH = 20;
 const TTL_BUFFER = 1000;
 
+const CFG_ALLOW_TARGETING_KEYS = `targetingControls.allowTargetingKeys`;
+const CFG_ADD_TARGETING_KEYS = `targetingControls.addTargetingKeys`;
+const TARGETING_KEY_CONFIGURATION_ERROR_MSG = `Only one of "${CFG_ALLOW_TARGETING_KEYS}" or "${CFG_ADD_TARGETING_KEYS}" can be set`;
+
 export const TARGETING_KEYS = Object.keys(CONSTANTS.TARGETING_KEYS).map(
   key => CONSTANTS.TARGETING_KEYS[key]
 );
@@ -261,7 +265,17 @@ export function newTargeting(auctionManager) {
     });
 
     const defaultKeys = Object.keys(Object.assign({}, CONSTANTS.DEFAULT_TARGETING_KEYS, CONSTANTS.NATIVE_KEYS));
-    const allowedKeys = config.getConfig('targetingControls.allowTargetingKeys') || defaultKeys;
+    let allowedKeys = config.getConfig(CFG_ALLOW_TARGETING_KEYS);
+    const addedKeys = config.getConfig(CFG_ADD_TARGETING_KEYS);
+
+    if (addedKeys != null && allowedKeys != null) {
+      throw new Error(TARGETING_KEY_CONFIGURATION_ERROR_MSG);
+    } else if (addedKeys != null) {
+      allowedKeys = defaultKeys.concat(addedKeys);
+    } else {
+      allowedKeys = allowedKeys || defaultKeys;
+    }
+
     if (Array.isArray(allowedKeys) && allowedKeys.length > 0) {
       targeting = getAllowedTargetingKeyValues(targeting, allowedKeys);
     }
@@ -284,6 +298,13 @@ export function newTargeting(auctionManager) {
     return targeting;
   };
 
+  // warn about conflicting configuration
+  config.getConfig('targetingControls', function (config) {
+    if (deepAccess(config, CFG_ALLOW_TARGETING_KEYS) != null && deepAccess(config, CFG_ADD_TARGETING_KEYS) != null) {
+      logError(TARGETING_KEY_CONFIGURATION_ERROR_MSG);
+    }
+  });
+
   // create an encoded string variant based on the keypairs of the provided object
   //  - note this will encode the characters between the keys (ie = and &)
   function convertKeysToQueryForm(keyMap) {
@@ -438,7 +459,7 @@ export function newTargeting(auctionManager) {
     const adUnitCodes = getAdUnitCodes(adUnitCode);
     return bidsReceived
       .filter(bid => includes(adUnitCodes, bid.adUnitCode))
-      .filter(bid => bid.cpm > 0)
+      .filter(bid => (isAllowZeroCpmBidsEnabled(bid.bidderCode)) ? bid.cpm >= 0 : bid.cpm > 0)
       .map(bid => bid.adUnitCode)
       .filter(uniques)
       .map(adUnitCode => bidsReceived