prebid.js 7.14.0 → 7.16.0

package/src/auction.js

@@ -77,6 +77,7 @@ import * as events from './events.js'
 import adapterManager from './adapterManager.js';
 import CONSTANTS from './constants.json';
 import {GreedyPromise} from './utils/promise.js';
+import {useMetrics} from './utils/perfMetrics.js';
 
 const { syncUsers } = userSync;
 
@@ -116,7 +117,8 @@ export function resetAuctionState() {
   *    (from getConfig('ortb2') + requestBids({ortb2})) and bidder (a map from bidderCode to ortb2)
   * @returns {Auction} auction instance
   */
-export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, auctionId, ortb2Fragments}) {
+export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, auctionId, ortb2Fragments, metrics}) {
+  metrics = useMetrics(metrics);
   let _adUnits = adUnits;
   let _labels = labels;
   let _adUnitCodes = adUnitCodes;
@@ -150,7 +152,8 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
       noBids: _noBids,
       bidsReceived: _bidsReceived,
       winningBids: _winningBids,
-      timeout: _timeout
+      timeout: _timeout,
+      metrics: metrics
     };
   }
 
@@ -179,6 +182,9 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
 
       _auctionStatus = AUCTION_COMPLETED;
       _auctionEnd = Date.now();
+      metrics.checkpoint('auctionEnd');
+      metrics.timeBetween('requestBids', 'auctionEnd', 'requestBids.total');
+      metrics.timeBetween('callBids', 'auctionEnd', 'requestBids.callBids');
 
       events.emit(CONSTANTS.EVENTS.AUCTION_END, getProperties());
       bidsBackCallback(_adUnits, function () {
@@ -225,9 +231,12 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
     _auctionStatus = AUCTION_STARTED;
     _auctionStart = Date.now();
 
-    let bidRequests = adapterManager.makeBidRequests(_adUnits, _auctionStart, _auctionId, _timeout, _labels, ortb2Fragments);
+    let bidRequests = metrics.measureTime('requestBids.makeRequests',
+      () => adapterManager.makeBidRequests(_adUnits, _auctionStart, _auctionId, _timeout, _labels, ortb2Fragments, metrics));
     logInfo(`Bids Requested for Auction with id: ${_auctionId}`, bidRequests);
 
+    metrics.checkpoint('callBids')
+
     if (bidRequests.length < 1) {
       logWarn('No valid bid requests returned for auction');
       auctionDone();
@@ -358,7 +367,8 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
     getBidRequests: () => _bidderRequests,
     getBidsReceived: () => _bidsReceived,
     getNoBids: () => _noBids,
-    getFPD: () => ortb2Fragments
+    getFPD: () => ortb2Fragments,
+    getMetrics: () => metrics,
   };
 }
 
@@ -482,6 +492,9 @@ export function doCallbacksIfTimedout(auctionInstance, bidResponse) {
 export function addBidToAuction(auctionInstance, bidResponse) {
   setupBidTargeting(bidResponse);
 
+  const metrics = useMetrics(bidResponse.metrics);
+  metrics.timeSince('addBidResponse', 'addBidResponse.total');
+
   events.emit(CONSTANTS.EVENTS.BID_RESPONSE, bidResponse);
   auctionInstance.addBidReceived(bidResponse);
 

package/src/auctionManager.js

@@ -24,6 +24,7 @@ import { newAuction, getStandardBidderSettings, AUCTION_COMPLETED } from './auct
 import {find} from './polyfill.js';
 import {AuctionIndex} from './auctionIndex.js';
 import CONSTANTS from './constants.json';
+import {useMetrics} from './utils/perfMetrics.js';
 
 /**
  * Creates new instance of auctionManager. There will only be one instance of auctionManager but
@@ -36,6 +37,10 @@ export function newAuctionManager() {
   const auctionManager = {};
 
   auctionManager.addWinningBid = function(bid) {
+    const metrics = useMetrics(bid.metrics);
+    metrics.checkpoint('bidWon');
+    metrics.timeBetween('auctionEnd', 'bidWon', 'render.pending');
+    metrics.timeBetween('requestBids', 'bidWon', 'render.e2e');
     const auction = find(_auctions, auction => auction.getAuctionId() === bid.auctionId);
     if (auction) {
       bid.status = CONSTANTS.BID_STATUS.RENDERED;

package/src/constants.json

@@ -152,6 +152,8 @@
     "MAIN": 3
   },
   "NATIVE_KEYS_THAT_ARE_NOT_ASSETS": [
+    "privacyLink",
+    "clickUrl",
     "sendTargetingKeys",
     "adTemplate",
     "rendererUrl",

package/src/native.js

@@ -80,7 +80,7 @@ const SUPPORTED_TYPES = {
   image: IMAGE
 };
 
-const { NATIVE_ASSET_TYPES, NATIVE_IMAGE_TYPES, PREBID_NATIVE_DATA_KEYS_TO_ORTB, NATIVE_KEYS_THAT_ARE_NOT_ASSETS } = CONSTANTS;
+const { NATIVE_ASSET_TYPES, NATIVE_IMAGE_TYPES, PREBID_NATIVE_DATA_KEYS_TO_ORTB, NATIVE_KEYS_THAT_ARE_NOT_ASSETS, NATIVE_KEYS } = CONSTANTS;
 
 // inverse native maps useful for converting to legacy
 const PREBID_NATIVE_DATA_KEYS_TO_ORTB_INVERSE = inverse(PREBID_NATIVE_DATA_KEYS_TO_ORTB);
@@ -488,6 +488,10 @@ export function toOrtbNativeRequest(legacyNativeAssets) {
   for (let key in legacyNativeAssets) {
     // skip conversion for non-asset keys
     if (NATIVE_KEYS_THAT_ARE_NOT_ASSETS.includes(key)) continue;
+    if (!NATIVE_KEYS.hasOwnProperty(key)) {
+      logError(`Unrecognized native asset code: ${key}. Asset will be ignored.`);
+      continue;
+    }
 
     const asset = legacyNativeAssets[key];
     let required = 0;
@@ -560,7 +564,6 @@ export function toOrtbNativeRequest(legacyNativeAssets) {
       // in `ext` case, required field is not needed
       delete ortbAsset.required;
     }
-
     ortb.assets.push(ortbAsset);
   }
   return ortb;

package/src/prebid.js

@@ -1,28 +1,54 @@
 /** @module pbjs */
 
-import { getGlobal } from './prebidGlobal.js';
+import {getGlobal} from './prebidGlobal.js';
 import {
-  adUnitsFilter, flatten, getHighestCpm, isArrayOfNums, isGptPubadsDefined, uniques, logInfo,
-  contains, logError, isArray, deepClone, deepAccess, isNumber, logWarn, logMessage, isFn,
-  transformAdServerTargetingObj, bind, replaceAuctionPrice, replaceClickThrough, insertElement,
-  inIframe, callBurl, createInvisibleIframe, generateUUID, unsupportedBidderMessage, isEmpty, mergeDeep, deepSetValue
+  adUnitsFilter,
+  bind,
+  callBurl,
+  contains,
+  createInvisibleIframe,
+  deepAccess,
+  deepClone,
+  deepSetValue,
+  flatten,
+  generateUUID,
+  getHighestCpm,
+  inIframe,
+  insertElement,
+  isArray,
+  isArrayOfNums,
+  isEmpty,
+  isFn,
+  isGptPubadsDefined,
+  isNumber,
+  logError,
+  logInfo,
+  logMessage,
+  logWarn,
+  mergeDeep,
+  replaceAuctionPrice,
+  replaceClickThrough,
+  transformAdServerTargetingObj,
+  uniques,
+  unsupportedBidderMessage
 } from './utils.js';
-import { listenMessagesFromCreative } from './secureCreatives.js';
-import { userSync } from './userSync.js';
-import { config } from './config.js';
-import { auctionManager } from './auctionManager.js';
-import { filters, targeting } from './targeting.js';
+import {listenMessagesFromCreative} from './secureCreatives.js';
+import {userSync} from './userSync.js';
+import {config} from './config.js';
+import {auctionManager} from './auctionManager.js';
+import {filters, targeting} from './targeting.js';
 import {hook, wrapHook} from './hook.js';
-import { loadSession } from './debugging.js';
+import {loadSession} from './debugging.js';
 import {includes} from './polyfill.js';
-import { adunitCounter } from './adUnits.js';
-import { executeRenderer, isRendererRequired } from './Renderer.js';
-import { createBid } from './bidfactory.js';
-import { storageCallbacks } from './storageManager.js';
-import { emitAdRenderSucceeded, emitAdRenderFail } from './adRendering.js';
-import {gdprDataHandler, getS2SBidderSet, uspDataHandler, default as adapterManager} from './adapterManager.js';
+import {adunitCounter} from './adUnits.js';
+import {executeRenderer, isRendererRequired} from './Renderer.js';
+import {createBid} from './bidfactory.js';
+import {storageCallbacks} from './storageManager.js';
+import {emitAdRenderFail, emitAdRenderSucceeded} from './adRendering.js';
+import {default as adapterManager, gdprDataHandler, getS2SBidderSet, uspDataHandler} from './adapterManager.js';
 import CONSTANTS from './constants.json';
-import * as events from './events.js'
+import * as events from './events.js';
+import {newMetrics, useMetrics} from './utils/perfMetrics.js';
 
 const $$PREBID_GLOBAL$$ = getGlobal();
 const { triggerUserSyncs } = userSync;
@@ -584,7 +610,7 @@ $$PREBID_GLOBAL$$.removeAdUnit = function (adUnitCode) {
  * @alias module:pbjs.requestBids
  */
 $$PREBID_GLOBAL$$.requestBids = (function() {
-  const delegate = hook('async', function ({ bidsBackHandler, timeout, adUnits, adUnitCodes, labels, auctionId, ortb2 } = {}) {
+  const delegate = hook('async', function ({ bidsBackHandler, timeout, adUnits, adUnitCodes, labels, auctionId, ortb2, metrics } = {}) {
     events.emit(REQUEST_BIDS);
     const cbTimeout = timeout || config.getConfig('bidderTimeout');
     logInfo('Invoking $$PREBID_GLOBAL$$.requestBids', arguments);
@@ -592,7 +618,7 @@ $$PREBID_GLOBAL$$.requestBids = (function() {
       global: mergeDeep({}, config.getAnyConfig('ortb2') || {}, ortb2 || {}),
       bidder: Object.fromEntries(Object.entries(config.getBidderConfig()).map(([bidder, cfg]) => [bidder, cfg.ortb2]).filter(([_, ortb2]) => ortb2 != null))
     }
-    return startAuction({bidsBackHandler, timeout: cbTimeout, adUnits, adUnitCodes, labels, auctionId, ortb2Fragments});
+    return startAuction({bidsBackHandler, timeout: cbTimeout, adUnits, adUnitCodes, labels, auctionId, ortb2Fragments, metrics});
   }, 'requestBids');
 
   return wrapHook(delegate, function requestBids(req = {}) {
@@ -600,15 +626,17 @@ $$PREBID_GLOBAL$$.requestBids = (function() {
     // any hook has a chance to run.
     // otherwise, if the caller goes on to use addAdUnits/removeAdUnits, any asynchronous logic
     // in any hook might see their effects.
+    req.metrics = newMetrics();
+    req.metrics.checkpoint('requestBids');
     let adUnits = req.adUnits || $$PREBID_GLOBAL$$.adUnits;
     req.adUnits = (isArray(adUnits) ? adUnits.slice() : [adUnits]);
     return delegate.call(this, req);
   });
 })();
 
-export const startAuction = hook('async', function ({ bidsBackHandler, timeout: cbTimeout, adUnits, adUnitCodes, labels, auctionId, ortb2Fragments } = {}) {
+export const startAuction = hook('async', function ({ bidsBackHandler, timeout: cbTimeout, adUnits, adUnitCodes, labels, auctionId, ortb2Fragments, metrics } = {}) {
   const s2sBidders = getS2SBidderSet(config.getConfig('s2sConfig') || []);
-  adUnits = checkAdUnitSetup(adUnits);
+  adUnits = useMetrics(metrics).measureTime('requestBids.validate', () => checkAdUnitSetup(adUnits));
 
   if (adUnitCodes && adUnitCodes.length) {
     // if specific adUnitCodes supplied filter adUnits for those codes
@@ -678,7 +706,8 @@ export const startAuction = hook('async', function ({ bidsBackHandler, timeout:
     cbTimeout,
     labels,
     auctionId,
-    ortb2Fragments
+    ortb2Fragments,
+    metrics,
   });
 
   let adUnitsLen = adUnits.length;

package/src/secureCreatives.js

@@ -4,7 +4,7 @@
  */
 
 import * as events from './events.js';
-import { fireNativeTrackers, getAssetMessage, getAllAssetsMessage } from './native.js';
+import {fireNativeTrackers, getAllAssetsMessage, getAssetMessage} from './native.js';
 import constants from './constants.json';
 import {deepAccess, isApnGetTagDefined, isGptPubadsDefined, logError, logWarn, replaceAuctionPrice} from './utils.js';
 import {auctionManager} from './auctionManager.js';

package/src/utils/perfMetrics.js

@@ -0,0 +1,386 @@
+import {config} from '../config.js';
+export const CONFIG_TOGGLE = 'performanceMetrics';
+const getTime = window.performance && window.performance.now ? () => window.performance.now() : () => Date.now();
+const NODES = new WeakMap();
+
+export function metricsFactory({now = getTime, mkNode = makeNode, mkTimer = makeTimer, mkRenamer = (rename) => rename, nodes = NODES} = {}) {
+  return function newMetrics() {
+    function makeMetrics(self, rename = (n) => ({forEach(fn) { fn(n); }})) {
+      rename = mkRenamer(rename);
+
+      function accessor(slot) {
+        return function (name) {
+          return self.dfWalk({
+            visit(edge, node) {
+              const obj = node[slot];
+              if (obj.hasOwnProperty(name)) {
+                return obj[name];
+              }
+            }
+          });
+        };
+      }
+
+      const getTimestamp = accessor('timestamps');
+
+      /**
+       * Register a metric.
+       *
+       * @param name metric name
+       * @param value metric valiue
+       */
+      function setMetric(name, value) {
+        const names = rename(name);
+        self.dfWalk({
+          follow(inEdge, outEdge) {
+            return outEdge.propagate && (!inEdge || !inEdge.stopPropagation)
+          },
+          visit(edge, node) {
+            names.forEach(name => {
+              if (edge == null) {
+                node.metrics[name] = value;
+              } else {
+                if (!node.groups.hasOwnProperty(name)) {
+                  node.groups[name] = [];
+                }
+                node.groups[name].push(value);
+              }
+            })
+          }
+        });
+      }
+
+      /**
+       * Mark the current time as a checkpoint with the given name, to be referenced later
+       * by `timeSince` or `timeBetween`.
+       *
+       * @param name checkpoint name
+       */
+      function checkpoint(name) {
+        self.timestamps[name] = now();
+      }
+
+      /**
+       * Get the tame passed since `checkpoint`, and optionally save it as a metric.
+       *
+       * @param checkpoint checkpoint name
+       * @param metric? metric name
+       * @return {number} time between now and `checkpoint`
+       */
+      function timeSince(checkpoint, metric) {
+        const ts = getTimestamp(checkpoint);
+        const elapsed = ts != null ? now() - ts : null;
+        if (metric != null) {
+          setMetric(metric, elapsed);
+        }
+        return elapsed;
+      }
+
+      /**
+       * Get the time passed between `startCheckpoint` and `endCheckpoint`, optionally saving it as a metric.
+       *
+       * @param startCheckpoint begin checkpoint
+       * @param endCheckpoint end checkpoint
+       * @param metric? metric name
+       * @return {number} time passed between `startCheckpoint` and `endCheckpoint`
+       */
+      function timeBetween(startCheckpoint, endCheckpoint, metric) {
+        const start = getTimestamp(startCheckpoint);
+        const end = getTimestamp(endCheckpoint);
+        const elapsed = start != null && end != null ? end - start : null;
+        if (metric != null) {
+          setMetric(metric, elapsed);
+        }
+        return elapsed;
+      }
+
+      /**
+       * A function that, when called, stops a time measure and saves it as a metric.
+       *
+       * @typedef {function(): void} MetricsTimer
+       * @template {function} F
+       * @property {function(F): F} stopBefore returns a wrapper around the given function that begins by
+       *   stopping this time measure.
+       * @property {function(F): F} stopAfter returns a wrapper around the given function that ends by
+       *   stopping this time measure.
+       */
+
+      /**
+       * Start measuring a time metric with the given name.
+       *
+       * @param name metric name
+       * @return {MetricsTimer}
+       */
+      function startTiming(name) {
+        return mkTimer(now, (val) => setMetric(name, val))
+      }
+
+      /**
+       * Run fn and measure the time spent in it.
+       *
+       * @template T
+       * @param name the name to use for the measured time metric
+       * @param {function(): T} fn
+       * @return {T} the return value of `fn`
+       */
+      function measureTime(name, fn) {
+        return startTiming(name).stopAfter(fn)();
+      }
+
+      /**
+       * @typedef {function: T} HookFn
+       * @property {function(T): void} bail
+       *
+       * @template T
+       * @typedef {T: HookFn} TimedHookFn
+       * @property {function(): void} stopTiming
+       * @property {T} untimed
+       */
+
+      /**
+       * Convenience method for measuring time spent in a `.before` or `.after` hook.
+       *
+       * @template T
+       * @param name metric name
+       * @param {HookFn} next the hook's `next` (first) argument
+       * @param {function(TimedHookFn): T} fn a function that will be run immediately; it takes `next`,
+       *    where both `next` and `next.bail` automatically
+       *    call `stopTiming` before continuing with the original hook.
+       * @return {T} fn's return value
+       */
+      function measureHookTime(name, next, fn) {
+        const stopTiming = startTiming(name);
+        return fn((function (orig) {
+          const next = stopTiming.stopBefore(orig);
+          next.bail = orig.bail && stopTiming.stopBefore(orig.bail);
+          next.stopTiming = stopTiming;
+          next.untimed = orig;
+          return next;
+        })(next));
+      }
+
+      /**
+       * Get all registered metrics.
+       * @return {{}}
+       */
+      function getMetrics() {
+        let result = {}
+        self.dfWalk({
+          visit(edge, node) {
+            result = Object.assign({}, !edge || edge.includeGroups ? node.groups : null, node.metrics, result);
+          }
+        });
+        return result;
+      }
+
+      /**
+       * Create and return a new metrics object that starts as a view on all metrics registered here,
+       * and - by default - also propagates all new metrics here.
+       *
+       * Propagated metrics are grouped together, and intended for repeated operations. For example, with the following:
+       *
+       * ```
+       * const metrics = newMetrics();
+       * const requests = metrics.measureTime('buildRequests', buildRequests)
+       * requests.forEach((req) => {
+       *   const requestMetrics = metrics.fork();
+       *   requestMetrics.measureTime('processRequest', () => processRequest(req);
+       * })
+       * ```
+       *
+       * if `buildRequests` takes 10ms and returns 3 objects, which respectively take 100, 200, and 300ms in `processRequest`, then
+       * the final `metrics.getMetrics()` would be:
+       *
+       * ```
+       * {
+       *    buildRequests: 10,
+       *    processRequest: [100, 200, 300]
+       * }
+       * ```
+       *
+       * while the inner `requestMetrics.getMetrics()` would be:
+       *
+       * ```
+       * {
+       *   buildRequests: 10,
+       *   processRequest: 100 // or 200 for the 2nd loop, etc
+       * }
+       * ```
+       *
+       *
+       * @param propagate if false, the forked metrics will not be propagated here
+       * @param stopPropagation if true, propagation from the new metrics is stopped here - instead of
+       *   continuing up the chain (if for example these metrics were themselves created through `.fork()`)
+       * @param includeGroups if true, the forked metrics will also replicate metrics that were propagated
+       *   here from elsewhere. For example:
+       *   ```
+       *   const metrics = newMetrics();
+       *   const op1 = metrics.fork();
+       *   const withoutGroups = metrics.fork();
+       *   const withGroups = metrics.fork({includeGroups: true});
+       *   op1.setMetric('foo', 'bar');
+       *   withoutGroups.getMetrics() // {}
+       *   withGroups.getMetrics() // {foo: ['bar']}
+       *   ```
+       */
+      function fork({propagate = true, stopPropagation = false, includeGroups = false} = {}) {
+        return makeMetrics(mkNode([[self, {propagate, stopPropagation, includeGroups}]]), rename);
+      }
+
+      /**
+       * Join `otherMetrics` with these; all metrics from `otherMetrics` will (by default) be propagated here,
+       * and all metrics from here will be included in `otherMetrics`.
+       *
+       * `propagate`, `stopPropagation` and `includeGroups` have the same semantics as in `.fork()`.
+       */
+      function join(otherMetrics, {propagate = true, stopPropagation = false, includeGroups = false} = {}) {
+        const other = nodes.get(otherMetrics);
+        if (other != null) {
+          other.addParent(self, {propagate, stopPropagation, includeGroups});
+        }
+      }
+
+      /**
+       * return a version of these metrics where all new metrics are renamed according to `renameFn`.
+       *
+       * @param {function(String): Array[String]} renameFn
+       */
+      function renameWith(renameFn) {
+        return makeMetrics(self, renameFn);
+      }
+
+      /**
+       * Create a new metrics object that uses the same propagation and renaming rules as this one.
+       */
+      function newMetrics() {
+        return makeMetrics(self.newSibling(), rename);
+      }
+
+      const metrics = {
+        startTiming,
+        measureTime,
+        measureHookTime,
+        checkpoint,
+        timeSince,
+        timeBetween,
+        setMetric,
+        getMetrics,
+        fork,
+        join,
+        newMetrics,
+        renameWith,
+        toJSON() {
+          return getMetrics();
+        }
+      };
+      nodes.set(metrics, self);
+      return metrics;
+    }
+
+    return makeMetrics(mkNode([]));
+  }
+}
+
+function wrapFn(fn, before, after) {
+  return function () {
+    before && before();
+    try {
+      return fn.apply(this, arguments);
+    } finally {
+      after && after();
+    }
+  };
+}
+
+function makeTimer(now, cb) {
+  const start = now();
+  let done = false;
+  function stopTiming() {
+    if (!done) {
+      // eslint-disable-next-line standard/no-callback-literal
+      cb(now() - start);
+      done = true;
+    }
+  }
+  stopTiming.stopBefore = (fn) => wrapFn(fn, stopTiming);
+  stopTiming.stopAfter = (fn) => wrapFn(fn, null, stopTiming);
+  return stopTiming;
+}
+
+function makeNode(parents) {
+  return {
+    metrics: {},
+    timestamps: {},
+    groups: {},
+    addParent(node, edge) {
+      parents.push([node, edge]);
+    },
+    newSibling() {
+      return makeNode(parents.slice());
+    },
+    dfWalk({visit, follow = () => true, visited = new Set(), inEdge} = {}) {
+      let res;
+      if (!visited.has(this)) {
+        visited.add(this);
+        res = visit(inEdge, this);
+        if (res != null) return res;
+        for (const [parent, outEdge] of parents) {
+          if (follow(inEdge, outEdge)) {
+            res = parent.dfWalk({visit, follow, visited, inEdge: outEdge});
+            if (res != null) return res;
+          }
+        }
+      }
+    }
+  };
+}
+
+const nullMetrics = (() => {
+  const nop = function () {};
+  const empty = () => ({});
+  const none = {forEach: nop};
+  const nullTimer = () => null;
+  nullTimer.stopBefore = (fn) => fn;
+  nullTimer.stopAfter = (fn) => fn;
+  const nullNode = Object.defineProperties(
+    {dfWalk: nop, newSibling: () => nullNode, addParent: nop},
+    Object.fromEntries(['metrics', 'timestamps', 'groups'].map(prop => [prop, {get: empty}])));
+  return metricsFactory({
+    now: () => 0,
+    mkNode: () => nullNode,
+    mkRenamer: () => () => none,
+    mkTimer: () => nullTimer,
+    nodes: {get: nop, set: nop}
+  })();
+})();
+
+let enabled = true;
+config.getConfig(CONFIG_TOGGLE, (cfg) => { enabled = !!cfg[CONFIG_TOGGLE] });
+
+/**
+ * convenience fallback function for metrics that may be undefined, especially during tests.
+ */
+export function useMetrics(metrics) {
+  return (enabled && metrics) || nullMetrics;
+}
+
+export const newMetrics = (() => {
+  const makeMetrics = metricsFactory();
+  return function () {
+    return enabled ? makeMetrics() : nullMetrics;
+  }
+})();
+
+export function hookTimer(prefix, getMetrics) {
+  return function(name, hookFn) {
+    return function (next, ...args) {
+      const that = this;
+      return useMetrics(getMetrics.apply(that, args)).measureHookTime(prefix + name, next, function (next) {
+        return hookFn.call(that, next, ...args);
+      });
+    }
+  }
+}
+
+export const timedAuctionHook = hookTimer('requestBids.', (req) => req.metrics);
+export const timedBidResponseHook = hookTimer('addBidResponse.', (_, bid) => bid.metrics)

package/src/utils.js

@@ -4,7 +4,7 @@ import {find, includes} from './polyfill.js';
 import CONSTANTS from './constants.json';
 import {GreedyPromise} from './utils/promise.js';
 export { default as deepAccess } from 'dlv/index.js';
-export { default as deepSetValue } from 'dset';
+export { dset as deepSetValue } from 'dset';
 
 var tArr = 'Array';
 var tStr = 'String';

package/test/helpers/testing-utils.js

@@ -1,12 +1,13 @@
 /* eslint-disable no-console */
 const {expect} = require('chai');
+const DEFAULT_TIMEOUT = 2000;
 const utils = {
   host: (process.env.TEST_SERVER_HOST) ? process.env.TEST_SERVER_HOST : 'localhost',
   protocol: (process.env.TEST_SERVER_PROTOCOL) ? 'https' : 'http',
   testPageURL: function(name) {
     return `${utils.protocol}://${utils.host}:9999/test/pages/${name}`
   },
-  waitForElement: function(elementRef, time = 2000) {
+  waitForElement: function(elementRef, time = DEFAULT_TIMEOUT) {
     let element = $(elementRef);
     element.waitForExist({timeout: time});
   },
@@ -14,7 +15,7 @@ const utils = {
     let iframe = $(frameRef);
     browser.switchToFrame(iframe);
   },
-  loadAndWaitForElement(url, selector, pause = 3000, timeout = 2000, retries = 3, attempt = 1) {
+  loadAndWaitForElement(url, selector, pause = 3000, timeout = DEFAULT_TIMEOUT, retries = 3, attempt = 1) {
     browser.url(url);
     browser.pause(pause);
     if (selector != null) {
@@ -27,7 +28,7 @@ const utils = {
       }
     }
   },
-  setupTest({url, waitFor, expectGAMCreative = null, pause = 3000, timeout = 2000, retries = 3}, name, fn) {
+  setupTest({url, waitFor, expectGAMCreative = null, pause = 3000, timeout = DEFAULT_TIMEOUT, retries = 3}, name, fn) {
     describe(name, function () {
       this.retries(retries);
       before(() => utils.loadAndWaitForElement(url, waitFor, pause, timeout, retries));