prebid.js 7.26.0 → 7.28.0

package/modules/bucksenseBidAdapter.js

@@ -4,7 +4,7 @@ import { BANNER } from '../src/mediaTypes.js';
 
 const WHO = 'BKSHBID-005';
 const BIDDER_CODE = 'bucksense';
-const URL = 'https://prebid.bksn.se/prebidjs/';
+const URL = 'https://directo.prebidserving.com/prebidjs/';
 
 export const spec = {
   code: BIDDER_CODE,

package/modules/criteoBidAdapter.js

@@ -672,18 +672,18 @@ function enrichSlotWithFloors(slot, bidRequest) {
       if (bidRequest.mediaTypes?.banner) {
         slotFloors.banner = {};
         const bannerSizes = parseSizes(deepAccess(bidRequest, 'mediaTypes.banner.sizes'))
-        bannerSizes.forEach(bannerSize => slotFloors.banner[parseSize(bannerSize).toString()] = getFloor({ size: bannerSize, mediaType: BANNER }));
+        bannerSizes.forEach(bannerSize => slotFloors.banner[parseSize(bannerSize).toString()] = getFloor.call(bidRequest, { 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()] = getFloor({ size: videoSize, mediaType: VIDEO }));
+        videoSizes.forEach(videoSize => slotFloors.video[parseSize(videoSize).toString()] = getFloor.call(bidRequest, { size: videoSize, mediaType: VIDEO }));
       }
 
       if (bidRequest.mediaTypes?.native) {
         slotFloors.native = {};
-        slotFloors.native['*'] = getFloor({ size: '*', mediaType: NATIVE });
+        slotFloors.native['*'] = getFloor.call(bidRequest, { size: '*', mediaType: NATIVE });
       }
 
       if (Object.keys(slotFloors).length > 0) {

package/modules/discoveryBidAdapter.js

@@ -277,6 +277,8 @@ function getItems(validBidRequests, bidderRequest) {
 function getParam(validBidRequests, bidderRequest) {
   const pubcid = utils.deepAccess(validBidRequests[0], 'crumbs.pubcid');
   let isMobile = getDevice() ? 1 : 0;
+  // input test status by Publisher. more frequently for test true req
+  let isTest = validBidRequests[0].params.test || 0;
   let auctionId = getKv(bidderRequest, 'auctionId');
   let items = getItems(validBidRequests, bidderRequest);
 
@@ -290,6 +292,7 @@ function getParam(validBidRequests, bidderRequest) {
   if (items && items.length) {
     let c = {
       id: 'pp_hbjs_' + auctionId,
+      test: +isTest,
       at: 1,
       bcat: globals['bcat'],
       badv: globals['adv'],

package/modules/eplanningBidAdapter.js

@@ -128,9 +128,9 @@ export const spec = {
                 advertiserDomains: ad.adom
               };
             }
-            if (isVastResponse(ad)) {
+            if (request && request.data && request.data.vv) {
               bidResponse.vastXml = ad.adm;
-              bidResponse.mediaTypes = VIDEO;
+              bidResponse.mediaType = VIDEO;
             } else {
               bidResponse.ad = ad.adm;
             }
@@ -504,8 +504,4 @@ function registerAuction(storageID) {
   return true;
 }
 
-function isVastResponse(bid) {
-  return bid.adm.match(/^(<VAST)|(<VideoAdServingTemplate)/gmi);
-}
-
 registerBidder(spec);

package/modules/fluctBidAdapter.js

@@ -62,6 +62,11 @@ export const spec = {
       });
 
       data.params = request.params;
+
+      if (request.schain) {
+        data.schain = request.schain;
+      }
+
       const searchParams = new URLSearchParams({
         dfpUnitCode: request.params.dfpUnitCode,
         tagId: request.params.tagId,

package/modules/gdprEnforcement.js

@@ -2,7 +2,7 @@
  * This module gives publishers extra set of features to enforce individual purposes of TCF v2
  */
 
-import {deepAccess, hasDeviceAccess, isArray, logWarn} from '../src/utils.js';
+import {deepAccess, hasDeviceAccess, isArray, logError, logWarn} from '../src/utils.js';
 import {config} from '../src/config.js';
 import adapterManager, {gdprDataHandler} from '../src/adapterManager.js';
 import {find, includes} from '../src/polyfill.js';
@@ -11,13 +11,7 @@ import {getHook} from '../src/hook.js';
 import {validateStorageEnforcement} from '../src/storageManager.js';
 import * as events from '../src/events.js';
 import CONSTANTS from '../src/constants.json';
-
-// modules for which vendor consent is not needed (see https://github.com/prebid/Prebid.js/issues/8161)
-const VENDORLESS_MODULES = new Set([
-  'sharedId',
-  'pubCommonId',
-  'pubProvidedId',
-]);
+import {VENDORLESS_GVLID} from '../src/consentHandler.js';
 
 export const STRICT_STORAGE_ENFORCEMENT = 'strictStorageEnforcement';
 
@@ -71,7 +65,7 @@ export const internal = {
  * @param {{string|Object}} - module
  * @return {number} - GVL ID
  */
-export function getGvlid(module) {
+export function getGvlid(module, ...args) {
   let gvlid = null;
   if (module) {
     // Check user defined GVL Mapping in pbjs.setConfig()
@@ -86,7 +80,7 @@ export function getGvlid(module) {
       return gvlid;
     }
 
-    gvlid = internal.getGvlidForBidAdapter(moduleCode) || internal.getGvlidForUserIdModule(module) || internal.getGvlidForAnalyticsAdapter(moduleCode);
+    gvlid = internal.getGvlidForBidAdapter(moduleCode) || internal.getGvlidForUserIdModule(module) || internal.getGvlidForAnalyticsAdapter(moduleCode, ...args);
   }
   return gvlid;
 }
@@ -120,10 +114,19 @@ function getGvlidForUserIdModule(userIdModule) {
 /**
  * Returns GVL ID for an analytics adapter. If an analytics adapter does not have an associated GVL ID, it returns 'null'.
  * @param {string} code - 'provider' property on the analytics adapter config
+ * @param {{}} config - analytics configuration object
  * @return {number} GVL ID
  */
-function getGvlidForAnalyticsAdapter(code) {
-  return adapterManager.getAnalyticsAdapter(code) && (adapterManager.getAnalyticsAdapter(code).gvlid || null);
+function getGvlidForAnalyticsAdapter(code, config) {
+  const adapter = adapterManager.getAnalyticsAdapter(code);
+  return adapter?.gvlid || ((gvlid) => {
+    if (typeof gvlid !== 'function') return gvlid;
+    try {
+      return gvlid.call(adapter.adapter, config);
+    } catch (e) {
+      logError(`Error invoking ${code} adapter.gvlid()`, e)
+    }
+  })(adapter?.adapter?.gvlid)
 }
 
 export function shouldEnforce(consentData, purpose, name) {
@@ -145,20 +148,20 @@ export function shouldEnforce(consentData, purpose, name) {
  * @param {Object} consentData - gdpr consent data
  * @param {string=} currentModule - Bidder code of the current module
  * @param {number=} gvlId - GVL ID for the module
- * @param vendorlessModule a predicate function that takes a module name, and returns true if the module does not need vendor consent
  * @returns {boolean}
  */
-export function validateRules(rule, consentData, currentModule, gvlId, vendorlessModule = VENDORLESS_MODULES.has.bind(VENDORLESS_MODULES)) {
+export function validateRules(rule, consentData, currentModule, gvlId) {
   const purposeId = TCF2[Object.keys(TCF2).filter(purposeName => TCF2[purposeName].name === rule.purpose)[0]].id;
 
   // return 'true' if vendor present in 'vendorExceptions'
-  if (includes(rule.vendorExceptions || [], currentModule)) {
+  if ((rule.vendorExceptions || []).includes(currentModule)) {
     return true;
   }
+  const vendorConsentRequred = !((gvlId === VENDORLESS_GVLID || (rule.softVendorExceptions || []).includes(currentModule)))
 
   // get data from the consent string
   const purposeConsent = deepAccess(consentData, `vendorData.purpose.consents.${purposeId}`);
-  const vendorConsent = deepAccess(consentData, `vendorData.vendor.consents.${gvlId}`);
+  const vendorConsent = vendorConsentRequred ? deepAccess(consentData, `vendorData.vendor.consents.${gvlId}`) : true;
   const liTransparency = deepAccess(consentData, `vendorData.purpose.legitimateInterests.${purposeId}`);
 
   /*
@@ -166,7 +169,7 @@ export function validateRules(rule, consentData, currentModule, gvlId, vendorles
     or the user has consented. Similar with vendors.
   */
   const purposeAllowed = rule.enforcePurpose === false || purposeConsent === true;
-  const vendorAllowed = vendorlessModule(currentModule) || rule.enforceVendor === false || vendorConsent === true;
+  const vendorAllowed = rule.enforceVendor === false || vendorConsent === true;
 
   /*
     Few if any vendors should be declaring Legitimate Interest for Device Access (Purpose 1), but some are claiming
@@ -183,19 +186,18 @@ export function validateRules(rule, consentData, currentModule, gvlId, vendorles
 /**
  * This hook checks whether module has permission to access device or not. Device access include cookie and local storage
  * @param {Function} fn reference to original function (used by hook logic)
- * @param isVendorless if true, do not require vendor consent (for e.g. core modules)
  * @param {Number=} gvlid gvlid of the module
  * @param {string=} moduleName name of the module
  * @param result
  */
-export function deviceAccessHook(fn, isVendorless, gvlid, moduleName, result, {validate = validateRules} = {}) {
+export function deviceAccessHook(fn, gvlid, moduleName, result, {validate = validateRules} = {}) {
   result = Object.assign({}, {
     hasEnforcementHook: true
   });
   if (!hasDeviceAccess()) {
     logWarn('Device access is disabled by Publisher');
     result.valid = false;
-  } else if (isVendorless && !strictStorageEnforcement) {
+  } else if (gvlid === VENDORLESS_GVLID && !strictStorageEnforcement) {
     // for vendorless (core) storage, do not enforce rules unless strictStorageEnforcement is set
     result.valid = true;
   } else {
@@ -203,13 +205,13 @@ export function deviceAccessHook(fn, isVendorless, gvlid, moduleName, result, {v
     if (shouldEnforce(consentData, 1, moduleName)) {
       const curBidder = config.getCurrentBidder();
       // Bidders have a copy of storage object with bidder code binded. Aliases will also pass the same bidder code when invoking storage functions and hence if alias tries to access device we will try to grab the gvl id for alias instead of original bidder
-      if (curBidder && (curBidder != moduleName) && adapterManager.aliasRegistry[curBidder] === moduleName) {
+      if (curBidder && (curBidder !== moduleName) && adapterManager.aliasRegistry[curBidder] === moduleName) {
         gvlid = getGvlid(curBidder);
       } else {
         gvlid = getGvlid(moduleName) || gvlid;
       }
       const curModule = moduleName || curBidder;
-      let isAllowed = validate(purpose1Rule, consentData, curModule, gvlid, isVendorless ? () => true : undefined);
+      let isAllowed = validate(purpose1Rule, consentData, curModule, gvlid,);
       if (isAllowed) {
         result.valid = true;
       } else {
@@ -221,7 +223,7 @@ export function deviceAccessHook(fn, isVendorless, gvlid, moduleName, result, {v
       result.valid = true;
     }
   }
-  fn.call(this, isVendorless, gvlid, moduleName, result);
+  fn.call(this, gvlid, moduleName, result);
 }
 
 /**
@@ -314,7 +316,7 @@ export function enableAnalyticsHook(fn, config) {
     }
     config = config.filter(conf => {
       const analyticsAdapterCode = conf.provider;
-      const gvlid = getGvlid(analyticsAdapterCode);
+      const gvlid = getGvlid(analyticsAdapterCode, conf);
       const isAllowed = !!validateRules(purpose7Rule, consentData, analyticsAdapterCode, gvlid);
       if (!isAllowed) {
         analyticsBlocked.push(analyticsAdapterCode);

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);

package/modules/gridBidAdapter.js

@@ -652,7 +652,7 @@ function getUserIdFromFPDStorage() {
 function segmentProcessing(segment, forceSegName) {
   return segment
     .map((seg) => {
-      const value = seg && (seg.value || seg.id || seg);
+      const value = seg && (seg.id || seg);
       if (typeof value === 'string' || typeof value === 'number') {
         return {
           value: value.toString(),

package/modules/gridNMBidAdapter.js

@@ -432,7 +432,7 @@ export function getSyncUrl() {
 function segmentProcessing(segment, forceSegName) {
   return segment
     .map((seg) => {
-      const value = seg && (seg.value || seg.id || seg);
+      const value = seg && (seg.id || seg);
       if (typeof value === 'string' || typeof value === 'number') {
         return {
           value: value.toString(),

package/modules/growthCodeAnalyticsAdapter.js

@@ -0,0 +1,176 @@
+/**
+ * growthCodeAnalyticsAdapter.js - GrowthCode Analytics Adapter
+ */
+import { ajax } from '../src/ajax.js';
+import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
+import adapterManager from '../src/adapterManager.js';
+import * as utils from '../src/utils.js';
+import CONSTANTS from '../src/constants.json';
+import { getStorageManager } from '../src/storageManager.js';
+import {getRefererInfo} from '../src/refererDetection.js';
+import {logError, logInfo} from '../src/utils.js';
+
+const MODULE_NAME = 'growthCodeAnalytics';
+const DEFAULT_PID = 'INVALID_PID'
+const ENDPOINT_URL = 'https://p2.gcprivacy.com/v1/pb/analytics'
+
+export const storage = getStorageManager();
+
+let sessionId = utils.generateUUID();
+
+let trackEvents = [];
+let pid = DEFAULT_PID;
+let url = ENDPOINT_URL;
+
+let eventQueue = [];
+
+let startAuction = 0;
+let bidRequestTimeout = 0;
+let analyticsType = 'endpoint';
+
+let growthCodeAnalyticsAdapter = Object.assign(adapter({url: url, analyticsType}), {
+  track({eventType, eventData}) {
+    eventData = eventData ? JSON.parse(JSON.stringify(eventData)) : {};
+    let data = {};
+    if (!trackEvents.includes(eventType)) return;
+    switch (eventType) {
+      case CONSTANTS.EVENTS.AUCTION_INIT: {
+        data = eventData;
+        startAuction = data.timestamp;
+        bidRequestTimeout = data.timeout;
+        break;
+      }
+
+      case CONSTANTS.EVENTS.AUCTION_END: {
+        data = eventData;
+        data.start = startAuction;
+        data.end = Date.now();
+        break;
+      }
+
+      case CONSTANTS.EVENTS.BID_ADJUSTMENT: {
+        data.bidders = eventData;
+        break;
+      }
+
+      case CONSTANTS.EVENTS.BID_TIMEOUT: {
+        data.bidders = eventData;
+        data.duration = bidRequestTimeout;
+        break;
+      }
+
+      case CONSTANTS.EVENTS.BID_REQUESTED: {
+        data = eventData;
+        break;
+      }
+
+      case CONSTANTS.EVENTS.BID_RESPONSE: {
+        data = eventData;
+        delete data.ad;
+        break;
+      }
+
+      case CONSTANTS.EVENTS.BID_WON: {
+        data = eventData;
+        delete data.ad;
+        delete data.adUrl;
+        break;
+      }
+
+      case CONSTANTS.EVENTS.BIDDER_DONE: {
+        data = eventData;
+        break;
+      }
+
+      case CONSTANTS.EVENTS.SET_TARGETING: {
+        data.targetings = eventData;
+        break;
+      }
+
+      case CONSTANTS.EVENTS.REQUEST_BIDS: {
+        data = eventData;
+        break;
+      }
+
+      case CONSTANTS.EVENTS.ADD_AD_UNITS: {
+        data = eventData;
+        break;
+      }
+
+      default:
+        return;
+    }
+
+    data.eventType = eventType;
+    data.timestamp = data.timestamp || Date.now();
+
+    sendEvent(data);
+  }
+});
+
+growthCodeAnalyticsAdapter.originEnableAnalytics = growthCodeAnalyticsAdapter.enableAnalytics;
+
+growthCodeAnalyticsAdapter.enableAnalytics = function(conf = {}) {
+  if (typeof conf.options === 'object') {
+    if (conf.options.pid) {
+      pid = conf.options.pid;
+      url = conf.options.url ? conf.options.url : ENDPOINT_URL;
+    } else {
+      logError(MODULE_NAME + ' Not a valid PartnerID')
+      return
+    }
+    if (conf.options.trackEvents) {
+      trackEvents = conf.options.trackEvents;
+    }
+  } else {
+    logError(MODULE_NAME + ' Invalid configuration');
+    return;
+  }
+
+  growthCodeAnalyticsAdapter.originEnableAnalytics(conf);
+};
+
+function logToServer() {
+  if (pid === DEFAULT_PID) return;
+  if (eventQueue.length > 1) {
+    let data = {
+      session: sessionId,
+      pid: pid,
+      timestamp: Date.now(),
+      timezoneoffset: new Date().getTimezoneOffset(),
+      url: getRefererInfo().page,
+      referer: document.referrer,
+      events: eventQueue
+    };
+
+    ajax(url, {
+      success: response => {
+        logInfo(MODULE_NAME + ' Send Data to Server')
+      },
+      error: error => {
+        logInfo(MODULE_NAME + ' Problem Send Data to Server: ' + error)
+      }
+    }, JSON.stringify(data), {method: 'POST', withCredentials: true})
+
+    eventQueue = [
+    ];
+  }
+}
+
+function sendEvent(event) {
+  eventQueue.push(event);
+  logInfo(MODULE_NAME + 'Analytics Event: ' + event);
+
+  if (event.eventType === CONSTANTS.EVENTS.AUCTION_END) {
+    logToServer();
+  }
+}
+
+adapterManager.registerAnalyticsAdapter({
+  adapter: growthCodeAnalyticsAdapter,
+  code: 'growthCodeAnalytics'
+});
+
+growthCodeAnalyticsAdapter.logToServer = logToServer;
+
+export default growthCodeAnalyticsAdapter;