prebid.js 7.25.0 → 7.27.0

package/modules/genericAnalyticsAdapter.js

@@ -0,0 +1,157 @@
+import AnalyticsAdapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
+import {prefixLog, isPlainObject} from '../src/utils.js';
+import * as CONSTANTS from '../src/constants.json';
+import adapterManager from '../src/adapterManager.js';
+import {ajaxBuilder} from '../src/ajax.js';
+
+const DEFAULTS = {
+  batchSize: 1,
+  batchDelay: 100,
+  method: 'POST'
+}
+
+const TYPES = {
+  handler: 'function',
+  batchSize: 'number',
+  batchDelay: 'number',
+  gvlid: 'number',
+}
+
+const MAX_CALL_DEPTH = 20;
+
+export function GenericAnalytics() {
+  const parent = AnalyticsAdapter({analyticsType: 'endpoint'});
+  const {logError, logWarn} = prefixLog('Generic analytics:');
+  let batch = [];
+  let callDepth = 0;
+  let options, handler, timer, translate;
+
+  function optionsAreValid(options) {
+    if (!options.url && !options.handler) {
+      logError('options must specify either `url` or `handler`')
+      return false;
+    }
+    if (options.hasOwnProperty('method') && !['GET', 'POST'].includes(options.method)) {
+      logError('options.method must be GET or POST');
+      return false;
+    }
+    for (const [field, type] of Object.entries(TYPES)) {
+      // eslint-disable-next-line valid-typeof
+      if (options.hasOwnProperty(field) && typeof options[field] !== type) {
+        logError(`options.${field} must be a ${type}`);
+        return false;
+      }
+    }
+    if (options.hasOwnProperty('events')) {
+      if (!isPlainObject(options.events)) {
+        logError('options.events must be an object');
+        return false;
+      }
+      for (const [event, handler] of Object.entries(options.events)) {
+        if (!CONSTANTS.EVENTS.hasOwnProperty(event)) {
+          logWarn(`options.events.${event} does not match any known Prebid event`);
+          if (typeof handler !== 'function') {
+            logError(`options.events.${event} must be a function`);
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  function processBatch() {
+    const currentBatch = batch;
+    batch = [];
+    callDepth++;
+    try {
+      // the pub-provided handler may inadvertently cause an infinite chain of events;
+      // even just logging an exception from it may cause an AUCTION_DEBUG event, that
+      // gets back to the handler, that throws another exception etc.
+      // to avoid the issue, put a cap on recursion
+      if (callDepth === MAX_CALL_DEPTH) {
+        logError('detected probable infinite recursion, discarding events', currentBatch);
+      }
+      if (callDepth >= MAX_CALL_DEPTH) {
+        return;
+      }
+      try {
+        handler(currentBatch);
+      } catch (e) {
+        logError('error executing options.handler', e);
+      }
+    } finally {
+      callDepth--;
+    }
+  }
+
+  function translator(eventHandlers) {
+    if (!eventHandlers) {
+      return (data) => data;
+    }
+    return function ({eventType, args}) {
+      if (eventHandlers.hasOwnProperty(eventType)) {
+        try {
+          return eventHandlers[eventType](args);
+        } catch (e) {
+          logError(`error executing options.events.${eventType}`, e);
+        }
+      }
+    }
+  }
+
+  return Object.assign(
+    Object.create(parent),
+    {
+      gvlid(config) {
+        return config?.options?.gvlid
+      },
+      enableAnalytics(config) {
+        if (optionsAreValid(config?.options || {})) {
+          options = Object.assign({}, DEFAULTS, config.options);
+          handler = options.handler || defaultHandler(options);
+          translate = translator(options.events);
+          parent.enableAnalytics.call(this, config);
+        }
+      },
+      track(event) {
+        if (event.eventType === CONSTANTS.EVENTS.AUCTION_INIT && event.args.hasOwnProperty('config')) {
+          // clean up auctionInit event
+          // TODO: remove this special case in v8
+          delete event.args.config;
+        }
+        const datum = translate(event);
+        if (datum != null) {
+          batch.push(datum);
+          if (timer != null) {
+            clearTimeout(timer);
+            timer = null;
+          }
+          if (batch.length >= options.batchSize) {
+            processBatch();
+          } else {
+            timer = setTimeout(processBatch, options.batchDelay);
+          }
+        }
+      }
+    }
+  )
+}
+
+export function defaultHandler({url, method, batchSize, ajax = ajaxBuilder()}) {
+  const callbacks = {
+    success() {},
+    error() {}
+  }
+  const extract = batchSize > 1 ? (events) => events : (events) => events[0];
+  const serialize = method === 'GET' ? (data) => ({data: JSON.stringify(data)}) : (data) => JSON.stringify(data);
+
+  return function (events) {
+    ajax(url, callbacks, serialize(extract(events)), {method})
+  }
+}
+
+adapterManager.registerAnalyticsAdapter({
+  adapter: GenericAnalytics(),
+  code: 'generic',
+});

package/modules/geoedgeRtdProvider.js

@@ -18,6 +18,8 @@
 import { submodule } from '../src/hook.js';
 import { ajax } from '../src/ajax.js';
 import { generateUUID, insertElement, isEmpty, logError } from '../src/utils.js';
+import * as events from '../src/events.js';
+import CONSTANTS from '../src/constants.json';
 
 /** @type {string} */
 const SUBMODULE_NAME = 'geoedge';
@@ -105,6 +107,7 @@ function getMacros(bid, key) {
     '%%PATTERN:hb_bidder%%': bid.bidderCode,
     '%_isHb!': true,
     '%_hbcid!': bid.creativeId || '',
+    '%_hbadomains': bid.meta && bid.meta.advertiserDomains,
     '%%PATTERN:hb_pb%%': bid.pbHg,
     '%%SITE%%': location.hostname,
     '%_pimp%': PV_ID
@@ -184,6 +187,24 @@ function conditionallyWrap(bidResponse, config, userConsent) {
   }
 }
 
+/**
+ * Fire billable events for applicable bids
+ */
+function fireBillableEventsForApplicableBids(params) {
+  events.on(CONSTANTS.EVENTS.BID_WON, function (winningBid) {
+    if (shouldWrap(winningBid, params)) {
+      events.emit(CONSTANTS.EVENTS.BILLABLE_EVENT, {
+        vendor: SUBMODULE_NAME,
+        billingId: generateUUID(),
+        type: 'impression',
+        transactionId: winningBid.transactionId,
+        auctionId: winningBid.auctionId,
+        bidId: winningBid.requestId
+      });
+    }
+  });
+}
+
 function init(config, userConsent) {
   let params = config.params;
   if (!params || !params.key) {
@@ -191,6 +212,7 @@ function init(config, userConsent) {
     return false;
   }
   preloadClient(params.key);
+  fireBillableEventsForApplicableBids(params);
   return true;
 }
 

package/modules/glomexBidAdapter.js

@@ -4,9 +4,11 @@ import {BANNER} from '../src/mediaTypes.js';
 
 const ENDPOINT = 'https://prebid.mes.glomex.cloud/request-bid'
 const BIDDER_CODE = 'glomex'
+const GVLID = 967
 
 export const spec = {
   code: BIDDER_CODE,
+  gvlid: GVLID,
   supportedMediaTypes: [BANNER],
 
   isBidRequestValid: function (bid) {

package/modules/gravitoIdSystem.js

@@ -39,19 +39,18 @@ export const gravitoIdSystemSubmodule = {
   * decode the stored id value for passing to bid requests
   * @function
   * @param { {gravitompId: string} } value
-  * @returns { {gravitompId: {id: string} } | undefined }
+  * @returns { {gravitompId: {string} } | undefined }
   */
   decode: function(value) {
     if (value && typeof value === 'object') {
-      const result = {};
+      var result = {};
       if (value.gravitompId) {
-        result.id = value.gravitompId
+        result = value.gravitompId
       }
       return {gravitompId: result};
     }
     return undefined;
   },
-
 }
 
 submodule('userId', gravitoIdSystemSubmodule);