prebid.js 7.24.0 → 7.26.0

package/modules/zeusPrimeRtdProvider.js

@@ -0,0 +1,357 @@
+/**
+ * This module adds Zeus Insights For Publishers (ZIP) provider to the real time data module
+ * The {@link module:modules/realTimeData} module is required
+ *
+ * This module will request the article topics for the current page and add them as page keyvalues
+ * for the ad requests.
+ *
+ * @module modules/zeusInsightsForPublishersRtdProvider
+ * @requires module:modules/realTimeData
+ */
+
+import { logInfo, logError, logWarn, logMessage } from '../src/utils.js'
+import { submodule } from '../src/hook.js'
+import { ajaxBuilder } from '../src/ajax.js'
+
+class Logger {
+  get showDebug() {
+    if (this._showDebug === true || this._showDebug === false) {
+      return this._showDebug
+    }
+
+    return window.zeusPrime?.debug || false
+  }
+  set showDebug(shouldShow) {
+    this._showDebug = shouldShow
+  }
+
+  get error() {
+    return logError.bind(this, 'zeusPrimeRtdProvider: ')
+  }
+  get warn() {
+    return logWarn.bind(this, 'zeusPrimeRtdProvider: ')
+  }
+  get info() {
+    return logInfo.bind(this, 'zeusPrimeRtdProvider: ')
+  }
+  get debug() {
+    if (this.showDebug) {
+      return logMessage.bind(this, 'zeusPrimeRtdProvider: ')
+    }
+
+    return () => {}
+  }
+}
+
+var logger = new Logger()
+
+function loadCommandQueue() {
+  window.zeusPrime = window.zeusPrime || { cmd: [] }
+  const queue = [...window.zeusPrime.cmd]
+
+  window.zeusPrime.cmd = []
+  window.zeusPrime.cmd.push = (callback) => {
+    callback(window.zeusPrime)
+  }
+
+  queue.forEach((callback) => callback(window.zeusPrime))
+}
+
+function markStatusComplete(key) {
+  const status = window?.zeusPrime?.status
+  if (status) {
+    status[key] = true
+  }
+}
+
+function createStatus() {
+  if (window.zeusPrime && !window.zeusPrime.status) {
+    Object.defineProperty(window.zeusPrime, 'status', {
+      enumerable: false,
+      value: {
+        initComplete: false,
+        primeKeyValueSet: false,
+        insightsReqSent: false,
+        insightsReqReceived: false,
+        insightsKeyValueSet: false,
+        scriptComplete: false,
+      },
+    })
+  }
+}
+
+function loadPrimeQueryParams() {
+  try {
+    const params = new URLSearchParams(window.location.search)
+    params.forEach((paramValue, paramKey) => {
+      if (!paramKey.startsWith('zeus_prime_')) {
+        return
+      }
+
+      let key = paramKey.replace('zeus_prime_', '')
+      let value = paramValue.toLowerCase()
+
+      if (value === 'true' || value === '1') {
+        value = true
+      } else if (value === 'false' || value === '0') {
+        value = false
+      }
+
+      window.zeusPrime[key] = value
+    })
+  } catch (_) {}
+}
+
+const DEFAULT_API = 'https://insights.zeustechnology.com'
+
+function init(gamId = null, options = {}) {
+  window.zeusPrime = window.zeusPrime || { cmd: [] }
+
+  window.zeusPrime.gamId = gamId || options.gamId || window.zeusPrime.gamId || undefined
+  window.zeusPrime.api = DEFAULT_API
+  window.zeusPrime.hostname = options.hostname || window.location?.hostname || ''
+  window.zeusPrime.pathname = options.pathname || window.location?.pathname || ''
+  window.zeusPrime.pageUrl = `${window.zeusPrime.hostname}${window.zeusPrime.pathname}`
+  window.zeusPrime.pageHash = options.pageHash || null
+  window.zeusPrime.debug = window.zeusPrime.debug || options.debug === true || false
+  window.zeusPrime.disabled = window.zeusPrime.disabled || options.disabled === true || false
+
+  loadPrimeQueryParams()
+
+  logger.showDebug = window.zeusPrime.debug
+
+  createStatus()
+  markStatusComplete('initComplete')
+}
+
+function setTargeting() {
+  const { gamId, hostname } = window.zeusPrime
+
+  if (typeof gamId !== 'string') {
+    throw new Error(`window.zeusPrime.gamId must be a string. Received: ${String(gamId)}`)
+  }
+
+  addKeyValueToGoogletag(`zeus_${gamId}`, hostname)
+  logger.debug(`Setting zeus_${gamId}=${hostname}`)
+  markStatusComplete('primeKeyValueSet')
+}
+
+function setPrimeAsDisabled() {
+  addKeyValueToGoogletag('zeus_prime', 'false')
+  logger.debug('Disabling prime; Setting key-value zeus_prime to false')
+}
+
+function addKeyValueToGoogletag(key, value) {
+  window.googletag = window.googletag || { cmd: [] }
+  window.googletag.cmd.push(function () {
+    window.googletag.pubads().setTargeting(key, value)
+  })
+}
+
+function isInsightsPage(pathname = '') {
+  const NOT_SECTIONS = [
+    {
+      test: /\/search/,
+      type: 'search',
+    },
+    {
+      test: /\/author/,
+      type: 'author',
+    },
+    {
+      test: /\/event/,
+      type: 'event',
+    },
+    {
+      test: /\/homepage/,
+      type: 'front',
+    },
+    {
+      test: /^\/?$/,
+      type: 'front',
+    },
+  ]
+
+  const typeObj = NOT_SECTIONS.find((pg) => pathname.match(pg.test))
+  return typeObj === undefined
+}
+
+async function getUrlHash(canonical) {
+  try {
+    const buf = await window.crypto.subtle.digest(
+      'SHA-1',
+      new TextEncoder('utf-8').encode(canonical)
+    )
+    const hashed = Array.prototype.map
+      .call(new Uint8Array(buf), (x) => `00${x.toString(16)}`.slice(-2))
+      .join('')
+
+    return hashed
+  } catch (e) {
+    logger.error('Failed to load hash', e.message)
+    logger.debug('Exception', e)
+    return ''
+  }
+}
+
+async function sendPrebidRequest(url) {
+  return new Promise((resolve, reject) => {
+    const ajax = ajaxBuilder()
+    ajax(url, {
+      success: (responseText, response) => {
+        resolve({
+          ...response,
+          status: response.status,
+          json: () => JSON.parse(responseText),
+        })
+      },
+
+      error: (responseText, response) => {
+        if (!response.status) {
+          reject(response)
+        }
+
+        let json = responseText
+        if (responseText) {
+          try {
+            json = JSON.parse(responseText)
+          } catch (_) {
+            json = null
+          }
+        }
+
+        resolve({
+          status: response.status,
+          json: () => json || null,
+          responseValue: json,
+        })
+      },
+    })
+  })
+}
+
+async function requestTopics() {
+  const { api, hostname, pageUrl } = window.zeusPrime
+
+  if (!window.zeusPrime.pageHash) {
+    window.zeusPrime.pageHash = await getUrlHash(pageUrl)
+  }
+
+  const pageHash = window.zeusPrime.pageHash
+  const zeusInsightsUrl = `${api}/${hostname}/${pageHash}?article_location=${pageUrl}`
+
+  logger.debug('Requesting topics', zeusInsightsUrl)
+  try {
+    markStatusComplete('insightsReqSent')
+    const response = await sendPrebidRequest(zeusInsightsUrl)
+    if (response.status === 200) {
+      logger.debug('topics found')
+      markStatusComplete('insightsReqReceived')
+      return await response.json()
+    } else if (
+      response.status === 204 ||
+      response.status < 200 ||
+      (response.status >= 300 && response.status <= 399)
+    ) {
+      logger.debug('no topics found')
+      markStatusComplete('insightsReqReceived')
+      return null
+    } else {
+      logger.error(`Topics request returned error: ${response.status}`)
+      markStatusComplete('insightsReqReceived')
+      return null
+    }
+  } catch (e) {
+    logger.error('failed to request topics', e)
+    return null
+  }
+}
+
+function setTopicsTargeting(topics = []) {
+  if (topics.length === 0) {
+    return
+  }
+
+  window.googletag = window.googletag || { cmd: [] }
+  window.googletag.cmd.push(function () {
+    window.googletag.pubads().setTargeting('zeus_insights', topics)
+  })
+
+  markStatusComplete('insightsKeyValueSet')
+}
+
+async function startTopicsRequest() {
+  if (isInsightsPage(window.zeusPrime.pathname)) {
+    const response = await requestTopics()
+    if (response) {
+      setTopicsTargeting(response?.topics)
+    }
+  } else {
+    logger.debug('This page is not eligible for topics, request will be skipped')
+  }
+}
+
+async function run(gamId, options = {}) {
+  logger.showDebug = options.debug || false
+
+  try {
+    init(gamId, options)
+    loadCommandQueue()
+
+    if (window.zeusPrime.disabled) {
+      setPrimeAsDisabled()
+    } else {
+      setTargeting()
+      await startTopicsRequest()
+    }
+  } catch (e) {
+    logger.error('Failed to run.', e.message || e)
+  } finally {
+    markStatusComplete('scriptComplete')
+  }
+}
+
+/**
+ * @preserve
+ * Initializes the ZeusPrime RTD Submodule. The config provides the GamID for this
+ * site that is used to configure Prime.
+ * @param {object} config The Prebid configuration for this module.
+ * @param {object} config.params The parameters for this module.
+ * @param {string} config.params.gamId The Gam ID (or Network Code) in GAM for this site.
+ */
+function initModule(config) {
+  const { params } = config || {}
+  const { gamId, ...rest } = params || {}
+  run(gamId, rest)
+}
+
+/**
+ * @preserve
+ * @type {RtdSubmodule}
+ */
+const zeusPrimeSubmodule = {
+  /**
+   * @preserve
+   * The name of the plugin.
+   * @type {string}
+   */
+  name: 'zeusPrime',
+
+  /**
+   * @preserve
+   * ZeusPrime use
+   */
+  init: initModule,
+}
+
+/**
+ * @preserve
+ * Register the Sub Module.
+ */
+function registerSubModule() {
+  submodule('realTimeData', zeusPrimeSubmodule)
+}
+
+registerSubModule()
+
+export { zeusPrimeSubmodule }

package/modules/zeusPrimeRtdProvider.md

@@ -0,0 +1,60 @@
+# Overview
+
+Module Name: Zeus Prime RTD Provider
+Module Type: Rtd Provider
+Maintainer: support@zeustechnology.com
+
+## Description
+
+The Zeus Prime RTD Provider provides integration of Zeus Prime onto sites with Prebid. This module will request information from Zeus Prime servers to add the page level targeting required for Prime into the customer's ad setup.
+
+Zeus Prime runs as soon as the code is initialized, so it can retrieve the information required from the Zeus Prime server to create the targeting key-values. Zeus Prime will provide two page level key-values: `zeus_<yourGamId>` and `zeus_insights`. Zeus Prime provides contextual information about a pages content, and does not provide user information that could present privacy implications.
+
+For more information and help with setting up Zeus Prime, see the [onboarding documentation site](https://onboarding.zeustechnology.com).
+
+## Usage
+
+To use Zeus Prime, add `zeusPrimeRtdProvider` into your Prebid build: 
+
+```
+gulp build --modules=rtdModule,zeusPrimeRtdProvider
+```
+
+> Note that the global RTD module, `rtdModule`, is required for the Zeus Prime RTD module.
+
+Once the code is included, configure Zeus Prime in your Prebid configuration: 
+
+```javascript
+pbjs.setConfig({
+  ...,
+  realTimeData: {
+    dataProviders: [{
+      name: 'zeusPrime',
+      waitForIt: false,
+      params: {
+        gamId: '<yourGamId>'
+      }
+    }]
+  },
+  ...
+})
+```
+
+## Parameters
+
+The parameters below describe the configuration object used to configure Zeus Prime. 
+
+| Name                   | Type     | Description                                                                                   | Default |
+|------------------------|----------|-----------------------------------------------------------------------------------------------|---------|
+| name                   | String   | This will always be `zeusPrime`                                                               | -       |
+| waitForIt              | Boolean  | Should be false since Zeus Prime runs on initial load and not during the bidding cycle.       | `false` |
+| params                 | Object   |                                                                                               | -       |
+| params.gamId           | String   | The gamId or Google Ad Manager Network Code to access your Google Ad Manager instance.        | -       |
+
+### `gamId` Parameter
+
+Zeus Prime requires the gamId parameter, or the Google Ad Manager Network Code, to reference your account. See the [Google documentation](https://support.google.com/admanager/answer/7674889?hl=en) to find out where you can retrieve the Network Code.
+
+## Troubleshooting 
+
+For troubleshooting steps and guides to assist with verifying your Zeus Prime installation, see our [installation documentation](https://onboarding.zeustechnology.com/docs/installation).

package/package.json

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

package/src/adloader.js

@@ -6,7 +6,6 @@ const _requestCache = new WeakMap();
 const _approvedLoadExternalJSList = [
   'debugging',
   'adloox',
-  'admatic',
   'criteo',
   'outstream',
   'adagio',

package/test/spec/modules/adagioBidAdapter_spec.js

@@ -400,7 +400,7 @@ describe('Adagio bid adapter', () => {
             skipafter: 4,
             minduration: 10,
             maxduration: 30,
-            placement: [3],
+            placement: 3,
             protocols: [8]
           }
         }).build();
@@ -415,7 +415,7 @@ describe('Adagio bid adapter', () => {
           skipafter: 4,
           minduration: 10,
           maxduration: 30,
-          placement: [3],
+          placement: 3,
           protocols: [8],
           w: 300,
           h: 250