prebid.js 7.25.0 → 7.27.0

package/libraries/analyticsAdapter/AnalyticsAdapter.js

@@ -1,47 +1,68 @@
 import CONSTANTS from '../../src/constants.json';
-import { ajax } from '../../src/ajax.js';
-import { logMessage, _each } from '../../src/utils.js';
-import * as events from '../../src/events.js'
+import {ajax} from '../../src/ajax.js';
+import {logError, logMessage} from '../../src/utils.js';
+import * as events from '../../src/events.js';
 
 export const _internal = {
   ajax
 };
-
-const {
-  EVENTS: {
-    AUCTION_INIT,
-    AUCTION_END,
-    REQUEST_BIDS,
-    BID_REQUESTED,
-    BID_TIMEOUT,
-    BID_RESPONSE,
-    NO_BID,
-    BID_WON,
-    BID_ADJUSTMENT,
-    BIDDER_DONE,
-    SET_TARGETING,
-    AD_RENDER_FAILED,
-    AD_RENDER_SUCCEEDED,
-    AUCTION_DEBUG,
-    ADD_AD_UNITS,
-    BILLABLE_EVENT
-  }
-} = CONSTANTS;
-
 const ENDPOINT = 'endpoint';
 const BUNDLE = 'bundle';
 
+export const DEFAULT_INCLUDE_EVENTS = Object.values(CONSTANTS.EVENTS)
+  .filter(ev => ev !== CONSTANTS.EVENTS.AUCTION_DEBUG);
+
+let debounceDelay = 100;
+
+export function setDebounceDelay(delay) {
+  debounceDelay = delay;
+}
+
 export default function AnalyticsAdapter({ url, analyticsType, global, handler }) {
-  const _queue = [];
-  let _eventCount = 0;
-  let _enableCheck = true;
-  let _handlers;
-  let _enabled = false;
-  let _sampled = true;
-
-  if (analyticsType === ENDPOINT || BUNDLE) {
-    _emptyQueue();
-  }
+  const queue = [];
+  let handlers;
+  let enabled = false;
+  let sampled = true;
+  let provider;
+
+  const emptyQueue = (() => {
+    let running = false;
+    let timer;
+    const clearQueue = () => {
+      if (!running) {
+        running = true; // needed to avoid recursive re-processing when analytics event handlers trigger other events
+        try {
+          let i = 0;
+          let notDecreasing = 0;
+          while (queue.length > 0) {
+            i++;
+            const len = queue.length;
+            queue.shift()();
+            if (queue.length >= len) {
+              notDecreasing++;
+            } else {
+              notDecreasing = 0
+            }
+            if (notDecreasing >= 10) {
+              logError('Detected probable infinite loop, discarding events', queue)
+              queue.length = 0;
+              return;
+            }
+          }
+          logMessage(`${provider} analytics: processed ${i} events`);
+        } finally {
+          running = false;
+        }
+      }
+    };
+    return function () {
+      if (timer != null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      debounceDelay === 0 ? clearQueue() : timer = setTimeout(clearQueue, debounceDelay);
+    }
+  })();
 
   return Object.defineProperties({
     track: _track,
@@ -54,7 +75,7 @@ export default function AnalyticsAdapter({ url, analyticsType, global, handler }
     getUrl: () => url
   }, {
     enabled: {
-      get: () => _enabled
+      get: () => enabled
     }
   });
 
@@ -72,69 +93,58 @@ export default function AnalyticsAdapter({ url, analyticsType, global, handler }
     _internal.ajax(url, callback, JSON.stringify({ eventType, args }));
   }
 
-  function _enqueue({ eventType, args }) {
-    const _this = this;
-
-    if (global && window[global] && eventType && args) {
-      this.track({ eventType, args });
-    } else {
-      _queue.push(function () {
-        _eventCount++;
-        _this.track({ eventType, args });
-      });
-    }
+  function _enqueue({eventType, args}) {
+    queue.push(() => {
+      this.track({eventType, args});
+    });
+    emptyQueue();
   }
 
   function _enable(config) {
+    provider = config?.provider;
     var _this = this;
 
     if (typeof config === 'object' && typeof config.options === 'object') {
-      _sampled = typeof config.options.sampling === 'undefined' || Math.random() < parseFloat(config.options.sampling);
+      sampled = typeof config.options.sampling === 'undefined' || Math.random() < parseFloat(config.options.sampling);
     } else {
-      _sampled = true;
+      sampled = true;
     }
 
-    if (_sampled) {
+    if (sampled) {
+      const trackedEvents = (() => {
+        const {includeEvents = DEFAULT_INCLUDE_EVENTS, excludeEvents = []} = (config || {});
+        return new Set(
+          Object.values(CONSTANTS.EVENTS)
+            .filter(ev => includeEvents.includes(ev))
+            .filter(ev => !excludeEvents.includes(ev))
+        );
+      })();
+
       // first send all events fired before enableAnalytics called
       events.getEvents().forEach(event => {
-        if (!event) {
+        if (!event || !trackedEvents.has(event.eventType)) {
           return;
         }
 
         const { eventType, args } = event;
-
-        if (eventType !== BID_TIMEOUT) {
-          _enqueue.call(_this, { eventType, args });
-        }
+        _enqueue.call(_this, { eventType, args });
       });
 
       // Next register event listeners to send data immediately
-
-      _handlers = {
-        [REQUEST_BIDS]: args => this.enqueue({ eventType: REQUEST_BIDS, args }),
-        [BID_REQUESTED]: args => this.enqueue({ eventType: BID_REQUESTED, args }),
-        [BID_RESPONSE]: args => this.enqueue({ eventType: BID_RESPONSE, args }),
-        [NO_BID]: args => this.enqueue({ eventType: NO_BID, args }),
-        [BID_TIMEOUT]: args => this.enqueue({ eventType: BID_TIMEOUT, args }),
-        [BID_WON]: args => this.enqueue({ eventType: BID_WON, args }),
-        [BID_ADJUSTMENT]: args => this.enqueue({ eventType: BID_ADJUSTMENT, args }),
-        [BIDDER_DONE]: args => this.enqueue({ eventType: BIDDER_DONE, args }),
-        [SET_TARGETING]: args => this.enqueue({ eventType: SET_TARGETING, args }),
-        [AUCTION_END]: args => this.enqueue({ eventType: AUCTION_END, args }),
-        [AD_RENDER_FAILED]: args => this.enqueue({ eventType: AD_RENDER_FAILED, args }),
-        [AD_RENDER_SUCCEEDED]: args => this.enqueue({ eventType: AD_RENDER_SUCCEEDED, args }),
-        [AUCTION_DEBUG]: args => this.enqueue({ eventType: AUCTION_DEBUG, args }),
-        [ADD_AD_UNITS]: args => this.enqueue({ eventType: ADD_AD_UNITS, args }),
-        [BILLABLE_EVENT]: args => this.enqueue({ eventType: BILLABLE_EVENT, args }),
-        [AUCTION_INIT]: args => {
-          args.config = typeof config === 'object' ? config.options || {} : {}; // enableAnaltyics configuration object
-          this.enqueue({ eventType: AUCTION_INIT, args });
-        }
-      };
-
-      _each(_handlers, (handler, event) => {
-        events.on(event, handler);
-      });
+      handlers = Object.fromEntries(
+        Array.from(trackedEvents)
+          .map((ev) => {
+            const handler = ev === CONSTANTS.EVENTS.AUCTION_INIT
+              ? (args) => {
+                // TODO: remove this special case in v8
+                args.config = typeof config === 'object' ? config.options || {} : {};
+                this.enqueue({eventType: ev, args});
+              }
+              : (args) => this.enqueue({eventType: ev, args});
+            events.on(ev, handler);
+            return [ev, handler];
+          })
+      )
     } else {
       logMessage(`Analytics adapter for "${global}" disabled by sampling`);
     }
@@ -144,31 +154,14 @@ export default function AnalyticsAdapter({ url, analyticsType, global, handler }
     this.enableAnalytics = function _enable() {
       return logMessage(`Analytics adapter for "${global}" already enabled, unnecessary call to \`enableAnalytics\`.`);
     };
-    _enabled = true;
+    enabled = true;
   }
 
   function _disable() {
-    _each(_handlers, (handler, event) => {
+    Object.entries(handlers || {}).forEach(([event, handler]) => {
       events.off(event, handler);
-    });
+    })
     this.enableAnalytics = this._oldEnable ? this._oldEnable : _enable;
-    _enabled = false;
-  }
-
-  function _emptyQueue() {
-    if (_enableCheck) {
-      for (var i = 0; i < _queue.length; i++) {
-        _queue[i]();
-      }
-
-      // override push to execute the command immediately from now on
-      _queue.push = function (fn) {
-        fn();
-      };
-
-      _enableCheck = false;
-    }
-
-    logMessage(`event count sent to ${global}: ${_eventCount}`);
+    enabled = false;
   }
 }

package/modules/.submodules.json

@@ -57,6 +57,7 @@
       "akamaiDapRtdProvider",
       "blueconicRtdProvider",
       "browsiRtdProvider",
+      "captifyRtdProvider",
       "dgkeywordRtdProvider",
       "geoedgeRtdProvider",
       "hadronRtdProvider",
@@ -71,7 +72,8 @@
       "reconciliationRtdProvider",
       "sirdataRtdProvider",
       "timeoutRtdProvider",
-      "weboramaRtdProvider"
+      "weboramaRtdProvider", 
+      "zeusPrimeRtdProvider"
     ],
     "fpdModule": [
       "enrichmentFpdModule",

package/modules/admaticBidAdapter.js

@@ -1,94 +1,102 @@
 import { getValue, logError, deepAccess, getBidIdParameter, isArray } from '../src/utils.js';
-import { loadExternalScript } from '../src/adloader.js';
-import {registerBidder} from '../src/adapters/bidderFactory.js';
-
-const ENDPOINT_URL = 'https://layer.serve.admatic.com.tr/pb';
-const SYNC_URL = 'https://cdn.serve.admatic.com.tr/showad/sync.js';
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { BANNER, VIDEO } from '../src/mediaTypes.js';
+let SYNC_URL = '';
 const BIDDER_CODE = 'admatic';
-
 export const spec = {
-  code: 'admatic',
-  supportedMediaTypes: ['video', 'banner'],
-  /**
-   * 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.
+  code: BIDDER_CODE,
+  aliases: [
+    {code: 'pixad'}
+  ],
+  supportedMediaTypes: [BANNER, VIDEO],
+  /** f
+   * @param {object} bid
+   * @return {boolean}
    */
-  isBidRequestValid: function(bid) {
+  isBidRequestValid: (bid) => {
     let isValid = false;
-    if (typeof bid.params !== 'undefined') {
-      let isValidNetworkId = _validateId(getValue(bid.params, 'networkId'));
-      isValid = isValidNetworkId;// && isValidTypeId;
+    if (bid?.params) {
+      const isValidNetworkId = _validateId(getValue(bid.params, 'networkId'));
+      const isValidHost = _validateString(getValue(bid.params, 'host'));
+      isValid = isValidNetworkId && isValidHost;
     }
 
     if (!isValid) {
-      logError('AdMatic networkId parameters are required. Bid aborted.');
+      logError(`${bid.bidder} networkId and host parameters are required. Bid aborted.`);
     }
     return isValid;
   },
+
   /**
-   * Make a server request from the list of BidRequests.
-   *
-   * @param {validBidRequests[]} an array of bids
-   * @return ServerRequest Info describing the request to the server.
+   * @param {BidRequest[]} validBidRequests
+   * @return {ServerRequest}
    */
-  buildRequests: function(validBidRequests, bidderRequest) {
+  buildRequests: (validBidRequests, bidderRequest) => {
     const bids = validBidRequests.map(buildRequestObject);
     const networkId = getValue(validBidRequests[0].params, 'networkId');
+    const host = getValue(validBidRequests[0].params, 'host');
     const currency = getValue(validBidRequests[0].params, 'currency') || 'TRY';
-
-    setTimeout(() => {
-      loadExternalScript(SYNC_URL, BIDDER_CODE);
-    }, bidderRequest.timeout);
+    const bidderName = validBidRequests[0].bidder;
 
     const payload = {
-      'user': {
-        'ua': navigator.userAgent
+      user: {
+        ua: navigator.userAgent
       },
-      'blacklist': [],
-      'site': {
-        'page': location.href,
-        'ref': location.origin,
-        'publisher': {
-          'name': location.hostname,
-          'publisherId': networkId
+      blacklist: [],
+      site: {
+        page: location.href,
+        ref: location.origin,
+        publisher: {
+          name: location.hostname,
+          publisherId: networkId
         }
       },
       imp: bids,
       ext: {
-        'cur': currency,
-        'type': 'admatic'
+        cur: currency,
+        bidder: bidderName
       }
     };
 
-    const payloadString = JSON.stringify(payload);
-    return {
-      method: 'POST',
-      url: ENDPOINT_URL,
-      data: payloadString,
-      options: {
-        contentType: 'application/json'
+    if (payload) {
+      switch (bidderName) {
+        case 'pixad':
+          SYNC_URL = 'https://static.pixad.com.tr/sync.html';
+          break;
+        default:
+          SYNC_URL = 'https://cdn.serve.admatic.com.tr/showad/sync.html';
+          break;
       }
-    };
+
+      return { method: 'POST', url: `https://${host}/pb?bidder=${bidderName}`, data: payload, options: { contentType: 'application/json' } };
+    }
+  },
+
+  getUserSyncs: function (syncOptions, responses) {
+    if (syncOptions.iframeEnabled) {
+      return [{
+        type: 'iframe',
+        url: SYNC_URL
+      }];
+    }
   },
+
   /**
-   * Unpack the response from the server into a list of bids.
-   *
-   * @param {*} serverResponse A successful response from the server.
-   * @return {Bid[]} An array of bids which were nested inside the server.
+   * @param {*} response
+   * @param {ServerRequest} request
+   * @return {Bid[]}
    */
   interpretResponse: (response, request) => {
     const body = response.body || response;
     const bidResponses = [];
-    if (body.data.length > 0) {
-      body.data.forEach(function (bid) {
+    if (body && body?.data && isArray(body.data)) {
+      body.data.forEach(bid => {
         const resbid = {
           requestId: bid.id,
           cpm: bid.price,
           width: bid.width,
           height: bid.height,
-          currency: body.cur,
+          currency: body.cur || 'TRY',
           netRevenue: true,
           ad: bid.party_tag,
           creativeId: bid.creative_id,
@@ -96,22 +104,68 @@ export const spec = {
             advertiserDomains: bid && bid.adomain ? bid.adomain : []
           },
           ttl: 360,
-          bidder: 'admatic',
-          timeToRespond: 1,
-          requestTimestamp: 1
+          bidder: bid.bidder
         };
+
         bidResponses.push(resbid);
       });
-    };
+    }
     return bidResponses;
   }
 };
 
+function enrichSlotWithFloors(slot, bidRequest) {
+  try {
+    const slotFloors = {};
+
+    if (bidRequest.getFloor) {
+      if (bidRequest.mediaTypes?.banner) {
+        slotFloors.banner = {};
+        const bannerSizes = parseSizes(deepAccess(bidRequest, 'mediaTypes.banner.sizes'))
+        bannerSizes.forEach(bannerSize => slotFloors.banner[parseSize(bannerSize).toString()] = bidRequest.getFloor({ size: bannerSize, mediaType: BANNER }));
+      }
+
+      if (bidRequest.mediaTypes?.video) {
+        slotFloors.video = {};
+        const videoSizes = parseSizes(deepAccess(bidRequest, 'mediaTypes.video.playerSize'))
+        videoSizes.forEach(videoSize => slotFloors.video[parseSize(videoSize).toString()] = bidRequest.getFloor({ size: videoSize, mediaType: VIDEO }));
+      }
+
+      if (Object.keys(slotFloors).length > 0) {
+        if (!slot) {
+          slot = {}
+        }
+        Object.assign(slot, {
+          floors: slotFloors
+        });
+      }
+    }
+  } catch (e) {
+    logError('Could not parse floors from Prebid: ' + e);
+  }
+}
+
+function parseSizes(sizes, parser = s => s) {
+  if (sizes == undefined) {
+    return [];
+  }
+  if (Array.isArray(sizes[0])) { // is there several sizes ? (ie. [[728,90],[200,300]])
+    return sizes.map(size => parser(size));
+  }
+  return [parser(sizes)]; // or a single one ? (ie. [728,90])
+}
+
+function parseSize(size) {
+  return size[0] + 'x' + size[1];
+}
+
 function buildRequestObject(bid) {
   const reqObj = {};
   reqObj.size = getSizes(bid);
   reqObj.id = getBidIdParameter('bidId', bid);
-  reqObj.floor = getValue(bid.params, 'floor') || 0.01;
+
+  enrichSlotWithFloors(reqObj, bid);
+
   return reqObj;
 }
 
@@ -144,4 +198,8 @@ function _validateId(id) {
   return (parseInt(id) > 0);
 }
 
+function _validateString(str) {
+  return (typeof str == 'string');
+}
+
 registerBidder(spec);

package/modules/admaticBidAdapter.md

@@ -19,7 +19,7 @@ Use `admatic` as bidder.
           bidder: 'admatic',
           params: { 
               networkId: 12345,
-              floor: 0.5
+              host: 'layer.serve.admatic.com.tr'
           }
       }]
     },{
@@ -29,7 +29,7 @@ Use `admatic` as bidder.
           bidder: 'admatic',
           params: { 
               networkId: 12345,
-              floor: 0.5
+              host: 'layer.serve.admatic.com.tr'
           }
       }]
     }];

package/modules/admixerBidAdapter.js

@@ -5,7 +5,7 @@ import {BANNER, VIDEO, NATIVE} from '../src/mediaTypes.js';
 import { convertOrtbRequestToProprietaryNative } from '../src/native.js';
 
 const BIDDER_CODE = 'admixer';
-const ALIASES = ['go2net', 'adblender', 'adsyield', 'futureads'];
+const ALIASES = ['go2net', 'adblender', 'adsyield', 'futureads', 'smn'];
 const ENDPOINT_URL = 'https://inv-nets.admixer.net/prebid.1.2.aspx';
 export const spec = {
   code: BIDDER_CODE,