prebid.js 9.53.2 → 9.53.4

package/libraries/objectGuard/ortbGuard.js

@@ -7,11 +7,7 @@ import {
   ORTB_UFPD_PATHS
 } from '../../src/activities/redactor.js';
 import {objectGuard, writeProtectRule} from './objectGuard.js';
-import {mergeDeep} from '../../src/utils.js';
-
-/**
- * @typedef {import('./objectGuard.js').ObjectGuard} ObjectGuard
- */
+import {logError} from '../../src/utils.js';
 
 function ortb2EnrichRules(isAllowed = isActivityAllowed) {
   return [
@@ -32,20 +28,10 @@ export function ortb2GuardFactory(isAllowed = isActivityAllowed) {
   return objectGuard(ortb2TransmitRules(isAllowed).concat(ortb2EnrichRules(isAllowed)));
 }
 
-/**
- *
- *
- * @typedef {Function} ortb2Guard
- * @param {{}} ortb2 ORTB object to guard
- * @param {{}} params activity params to use for activity checks
- * @returns {ObjectGuard}
- */
-
 /*
  * Get a guard for an ORTB object. Read access is restricted in the same way it'd be redacted (see activites/redactor.js);
  * and writes are checked against the enrich* activites.
  *
- * @type ortb2Guard
  */
 export const ortb2Guard = ortb2GuardFactory();
 
@@ -53,40 +39,44 @@ export function ortb2FragmentsGuardFactory(guardOrtb2 = ortb2Guard) {
   return function guardOrtb2Fragments(fragments, params) {
     fragments.global = fragments.global || {};
     fragments.bidder = fragments.bidder || {};
-    const bidders = new Set(Object.keys(fragments.bidder));
-    const verifiers = [];
-
-    function makeGuard(ortb2) {
-      const guard = guardOrtb2(ortb2, params);
-      verifiers.push(guard.verify);
-      return guard.obj;
-    }
-
-    const obj = {
-      global: makeGuard(fragments.global),
-      bidder: Object.fromEntries(Object.entries(fragments.bidder).map(([bidder, ortb2]) => [bidder, makeGuard(ortb2)]))
+    const guard = {
+      global: guardOrtb2(fragments.global, params),
+      bidder: new Proxy(fragments.bidder, {
+        get(target, prop, receiver) {
+          let bidderData = Reflect.get(target, prop, receiver);
+          if (bidderData != null) {
+            bidderData = guardOrtb2(bidderData, params)
+          }
+          return bidderData;
+        },
+        set(target, prop, newValue, receiver) {
+          if (newValue == null || typeof newValue !== 'object') {
+            logError(`ortb2Fragments.bidder[bidderCode] must be an object`);
+          }
+          let bidderData = Reflect.get(target, prop, receiver);
+          if (bidderData == null) {
+            bidderData = target[prop] = {};
+          }
+          bidderData = guardOrtb2(bidderData, params);
+          Object.entries(newValue).forEach(([prop, value]) => {
+            bidderData[prop] = value;
+          })
+          return true;
+        }
+      })
     };
 
-    return {
-      obj,
-      verify() {
-        Object.entries(obj.bidder)
-          .filter(([bidder]) => !bidders.has(bidder))
-          .forEach(([bidder, ortb2]) => {
-            const repl = {};
-            const guard = guardOrtb2(repl, params);
-            mergeDeep(guard.obj, ortb2);
-            guard.verify();
-            fragments.bidder[bidder] = repl;
-          })
-        verifiers.forEach(fn => fn());
-      }
-    }
+    return Object.defineProperties(
+      {},
+      Object.fromEntries(
+        // disallow overwriting of the top level `global` / `bidder`
+        Object.entries(guard).map(([prop, obj]) => [prop, {get: () => obj}])
+      )
+    )
   }
 }
 
 /**
  * Get a guard for an ortb2Fragments object.
- * @type {function(*, *): ObjectGuard}
  */
 export const guardOrtb2Fragments = ortb2FragmentsGuardFactory();

package/libraries/pubmaticUtils/plugins/dynamicTimeout.js

@@ -0,0 +1,209 @@
+import { logInfo } from '../../../src/utils.js';
+import { getGlobal } from '../../../src/prebidGlobal.js';
+import { bidderTimeoutFunctions } from '../../bidderTimeoutUtils/bidderTimeoutUtils.js';
+import { shouldThrottle } from '../pubmaticUtils.js';
+
+let _dynamicTimeoutConfig = null;
+export const getDynamicTimeoutConfig = () => _dynamicTimeoutConfig;
+export const setDynamicTimeoutConfig = (config) => { _dynamicTimeoutConfig = config; }
+
+export const CONSTANTS = Object.freeze({
+  LOG_PRE_FIX: 'PubMatic-Dynamic-Timeout: ',
+  INCLUDES_VIDEOS: 'includesVideo',
+  NUM_AD_UNITS: 'numAdUnits',
+  DEVICE_TYPE: 'deviceType',
+  CONNECTION_SPEED: 'connectionSpeed',
+  DEFAULT_SKIP_RATE: 50,
+  DEFAULT_THRESHOLD_TIMEOUT: 500
+});
+
+export const RULES_PERCENTAGE = {
+  [CONSTANTS.INCLUDES_VIDEOS]: {
+    "true": 20, // 20% of bidderTimeout
+    "false": 5  // 5% of bidderTimeout
+  },
+  [CONSTANTS.NUM_AD_UNITS]: {
+    "1-5": 10,   // 10% of bidderTimeout
+    "6-10": 20,  // 20% of bidderTimeout
+    "11-15": 30  // 30% of bidderTimeout
+  },
+  [CONSTANTS.DEVICE_TYPE]: {
+    "2": 5,   // 5% of bidderTimeout
+    "4": 10,  // 10% of bidderTimeout
+    "5": 20   // 20% of bidderTimeout
+  },
+  [CONSTANTS.CONNECTION_SPEED]: {
+    "slow": 20,     // 20% of bidderTimeout
+    "medium": 10,   // 10% of bidderTimeout
+    "fast": 5,      // 5% of bidderTimeout
+    "unknown": 1    // 1% of bidderTimeout
+  }
+};
+
+/**
+ * Initialize the dynamic timeout plugin
+ * @param {Object} pluginName - Plugin name
+ * @param {Object} configJsonManager - Configuration JSON manager object
+ * @returns {Promise<boolean>} - Promise resolving to initialization status
+ */
+export async function init(pluginName, configJsonManager) {
+  const config = configJsonManager.getConfigByName(pluginName);
+  if (!config) {
+    logInfo(`${CONSTANTS.LOG_PRE_FIX} Dynamic Timeout configuration not found`);
+    return false;
+  }
+  // Set the Dynamic Timeout config
+  setDynamicTimeoutConfig(config);
+
+  if (!getDynamicTimeoutConfig()?.enabled) {
+    logInfo(`${CONSTANTS.LOG_PRE_FIX} Dynamic Timeout configuration is disabled`);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Process bid request by applying dynamic timeout adjustments
+ * @param {Object} reqBidsConfigObj - Bid request config object
+ * @returns {Object} - Updated bid request config object with adjusted timeout
+ */
+export function processBidRequest(reqBidsConfigObj) {
+  // Cache config to avoid multiple calls
+  const timeoutConfig = getDynamicTimeoutConfig();
+
+  // Check if request should be throttled based on skipRate
+  const skipRate = (timeoutConfig?.config?.skipRate !== undefined && timeoutConfig?.config?.skipRate !== null) ? timeoutConfig?.config?.skipRate : CONSTANTS.DEFAULT_SKIP_RATE;
+  if (shouldThrottle(skipRate)) {
+    logInfo(`${CONSTANTS.LOG_PRE_FIX} Dynamic timeout is skipped (skipRate: ${skipRate}%)`);
+    return reqBidsConfigObj;
+  }
+
+  logInfo(`${CONSTANTS.LOG_PRE_FIX} Dynamic timeout is applying...`);
+
+  // Get ad units and bidder timeout
+  const adUnits = reqBidsConfigObj.adUnits || getGlobal().adUnits;
+  const bidderTimeout = getBidderTimeout(reqBidsConfigObj);
+
+  // Calculate and apply additional timeout
+  const rules = getRules(bidderTimeout);
+  const additionalTimeout = bidderTimeoutFunctions.calculateTimeoutModifier(adUnits, rules);
+
+  reqBidsConfigObj.timeout = getFinalTimeout(bidderTimeout, additionalTimeout);
+
+  logInfo(`${CONSTANTS.LOG_PRE_FIX} Timeout adjusted from ${bidderTimeout}ms to ${reqBidsConfigObj.timeout}ms (added ${additionalTimeout}ms)`);
+  return reqBidsConfigObj;
+}
+
+/**
+ * Get targeting data
+ * @param {Array} adUnitCodes - Ad unit codes
+ * @param {Object} config - Module configuration
+ * @param {Object} userConsent - User consent data
+ * @param {Object} auction - Auction object
+ * @returns {Object} - Targeting data
+ */
+export function getTargeting(adUnitCodes, config, userConsent, auction) {
+  // Implementation for targeting data, if not applied then do nothing
+}
+
+// Export the dynamic timeout functions
+export const DynamicTimeout = {
+  init,
+  processBidRequest,
+  getTargeting
+};
+
+// Helper Functions
+
+export const getFinalTimeout = (bidderTimeout, additionalTimeout) => {
+  // Calculate the final timeout by adding bidder timeout and additional timeout
+  const calculatedTimeout = parseInt(bidderTimeout) + parseInt(additionalTimeout);
+  const thresholdTimeout = getDynamicTimeoutConfig()?.config?.thresholdTimeout || CONSTANTS.DEFAULT_THRESHOLD_TIMEOUT;
+
+  // Handle cases where the calculated timeout might be negative or below threshold
+  if (calculatedTimeout < thresholdTimeout) {
+    // Log warning for negative or very low timeouts
+    if (calculatedTimeout < 0) {
+      logInfo(`${CONSTANTS.LOG_PRE_FIX} Warning: Negative timeout calculated (${calculatedTimeout}ms), using threshold (${thresholdTimeout}ms)`);
+    } else if (calculatedTimeout < thresholdTimeout) {
+      logInfo(`${CONSTANTS.LOG_PRE_FIX} Calculated timeout (${calculatedTimeout}ms) below threshold, using threshold (${thresholdTimeout}ms)`);
+    }
+    return thresholdTimeout;
+  }
+
+  return calculatedTimeout;
+}
+
+export const getBidderTimeout = (reqBidsConfigObj) => {
+  return getDynamicTimeoutConfig()?.config?.bidderTimeout
+    ? getDynamicTimeoutConfig()?.config?.bidderTimeout
+    : reqBidsConfigObj?.timeout || getGlobal()?.getConfig('bidderTimeout');
+}
+
+/**
+ * Get rules based on percentage values and bidderTimeout
+ * @param {number} bidderTimeout - Bidder timeout in milliseconds
+ * @returns {Object} - Rules with calculated millisecond values
+ */
+export const getRules = (bidderTimeout) => {
+  const timeoutConfig = getDynamicTimeoutConfig();
+
+  // In milliseconds - If timeout rules provided by publishers are available then return it
+  if (timeoutConfig?.config?.timeoutRules && Object.keys(timeoutConfig.config.timeoutRules).length > 0) {
+    return timeoutConfig.config.timeoutRules;
+  }
+  // In milliseconds - Check for rules in priority order, If ML model rules are available then return it
+  if (timeoutConfig?.data && Object.keys(timeoutConfig.data).length > 0) {
+    return timeoutConfig.data;
+  }
+  // In Percentage - If no rules are available then create rules from the default defined - values are in percentages
+  return createDynamicRules(RULES_PERCENTAGE, bidderTimeout);
+}
+
+/**
+ * Creates dynamic rules based on percentage values and bidder timeout
+ * @param {Object} percentageRules - Rules with percentage values
+ * @param {number} bidderTimeout - Bidder timeout in milliseconds
+ * @return {Object} - Rules with calculated millisecond values
+ */
+export const createDynamicRules = (percentageRules, bidderTimeout) => {
+  // Return empty object if required parameters are missing or invalid
+  if (!percentageRules || typeof percentageRules !== 'object') {
+    logInfo(`${CONSTANTS.LOG_PRE_FIX} Invalid percentage rules provided to createDynamicRules`);
+    return {};
+  }
+
+  // Handle negative or zero bidderTimeout gracefully
+  if (!bidderTimeout || typeof bidderTimeout !== 'number' || bidderTimeout <= 0) {
+    logInfo(`${CONSTANTS.LOG_PRE_FIX} Invalid bidderTimeout (${bidderTimeout}ms) provided to createDynamicRules`);
+    return {};
+  }
+
+  // Create a new rules object with millisecond values
+  return Object.entries(percentageRules).reduce((dynamicRules, [category, rules]) => {
+    // Skip if rules is not an object
+    if (!rules || typeof rules !== 'object') {
+      logInfo(`${CONSTANTS.LOG_PRE_FIX} Skipping invalid rule category: ${category}`);
+      return dynamicRules;
+    }
+
+    // Initialize category in the dynamic rules
+    dynamicRules[category] = {};
+
+    // Convert each percentage value to milliseconds
+    Object.entries(rules).forEach(([key, percentValue]) => {
+      // Ensure percentage value is a number and not zero
+      if (typeof percentValue === 'number' && percentValue !== 0) {
+        const calculatedTimeout = Math.floor(bidderTimeout * (percentValue / 100));
+        dynamicRules[category][key] = calculatedTimeout;
+
+        // Log warning for negative calculated timeouts
+        if (calculatedTimeout < 0) {
+          logInfo(`${CONSTANTS.LOG_PRE_FIX} Warning: Negative timeout calculated for ${category}.${key}: ${calculatedTimeout}ms`);
+        }
+      }
+    });
+
+    return dynamicRules;
+  }, {});
+};

package/libraries/pubmaticUtils/plugins/floorProvider.js

@@ -0,0 +1,168 @@
+// plugins/floorProvider.js
+import { logInfo, logError, isFn, logMessage, isEmpty } from '../../../src/utils.js';
+import { getDeviceType as fetchDeviceType, getOS } from '../../userAgentUtils/index.js';
+import { getBrowserType, getCurrentTimeOfDay, getUtmValue } from '../pubmaticUtils.js';
+import { config as conf } from '../../../src/config.js';
+
+/**
+ * This RTD module has a dependency on the priceFloors module.
+ * We utilize the continueAuction function from the priceFloors module to incorporate price floors data into the current auction.
+ */
+import { continueAuction } from '../../../modules/priceFloors.js'; // eslint-disable-line prebid/validate-imports
+
+let _floorConfig = null;
+export const getFloorConfig = () => _floorConfig;
+export const setFloorsConfig = (config) => { _floorConfig = config; }
+
+let _configJsonManager = null;
+export const getConfigJsonManager = () => _configJsonManager;
+export const setConfigJsonManager = (configJsonManager) => { _configJsonManager = configJsonManager; }
+
+export const CONSTANTS = Object.freeze({
+  LOG_PRE_FIX: 'PubMatic-Floor-Provider: '
+});
+
+/**
+ * Initialize the floor provider
+ * @param {Object} pluginName - Plugin name
+ * @param {Object} configJsonManager - Configuration JSON manager object
+ * @returns {Promise<boolean>} - Promise resolving to initialization status
+ */
+export async function init(pluginName, configJsonManager) {
+  // Process floor-specific configuration
+  const config = configJsonManager.getConfigByName(pluginName);
+  if (!config) {
+    logInfo(`${CONSTANTS.LOG_PRE_FIX} Floor configuration not found`);
+    return false;
+  }
+  setFloorsConfig(config);
+
+  if (!getFloorConfig()?.enabled) {
+    logInfo(`${CONSTANTS.LOG_PRE_FIX} Floor configuration is disabled`);
+    return false;
+  }
+
+  if (!isFn(continueAuction)) {
+    logError(`${CONSTANTS.LOG_PRE_FIX} continueAuction is not a function. Please ensure to add priceFloors module.`);
+    return false;
+  }
+
+  setConfigJsonManager(configJsonManager);
+  try {
+    conf.setConfig(prepareFloorsConfig());
+    logMessage(`${CONSTANTS.LOG_PRE_FIX} dynamicFloors config set successfully`);
+  } catch (error) {
+    logError(`${CONSTANTS.LOG_PRE_FIX} Error setting dynamicFloors config: ${error}`);
+  }
+
+  logInfo(`${CONSTANTS.LOG_PRE_FIX} Floor configuration loaded`);
+
+  return true;
+}
+
+/**
+ * Process bid request
+ * @param {Object} reqBidsConfigObj - Bid request config object
+ * @returns {Object} - Updated bid request config object
+ */
+export function processBidRequest(reqBidsConfigObj) {
+  try {
+    const hookConfig = {
+      reqBidsConfigObj,
+      context: null, // Removed 'this' as it's not applicable in function-based implementation
+      nextFn: () => true,
+      haveExited: false,
+      timer: null
+    };
+
+    // Apply floor configuration
+    continueAuction(hookConfig);
+    logInfo(`${CONSTANTS.LOG_PRE_FIX} Applied floor configuration to auction`);
+
+    return reqBidsConfigObj;
+  } catch (error) {
+    logError(`${CONSTANTS.LOG_PRE_FIX} Error applying floor configuration: ${error}`);
+    return reqBidsConfigObj;
+  }
+}
+
+/**
+ * Get targeting data
+ * @param {Array} adUnitCodes - Ad unit codes
+ * @param {Object} config - Module configuration
+ * @param {Object} userConsent - User consent data
+ * @param {Object} auction - Auction object
+ * @returns {Object} - Targeting data
+ */
+export function getTargeting(adUnitCodes, config, userConsent, auction) {
+  // Implementation for targeting data, if not applied then do nothing
+}
+
+// Export the floor provider functions
+export const FloorProvider = {
+  init,
+  processBidRequest,
+  getTargeting
+};
+
+// Helper Functions
+
+export const defaultValueTemplate = {
+  currency: 'USD',
+  skipRate: 0,
+  schema: {
+    fields: ['mediaType', 'size']
+  }
+};
+
+// Getter Functions
+export const getTimeOfDay = () => getCurrentTimeOfDay();
+export const getBrowser = () => getBrowserType();
+export const getOs = () => getOS().toString();
+export const getDeviceType = () => fetchDeviceType().toString();
+export const getCountry = () => getConfigJsonManager().country;
+export const getBidder = (request) => request?.bidder;
+export const getUtm = () => getUtmValue();
+
+export const prepareFloorsConfig = () => {
+  if (!getFloorConfig()?.enabled || !getFloorConfig()?.config) {
+    return undefined;
+  }
+
+  // Floor configs from adunit / setconfig
+  const defaultFloorConfig = conf.getConfig('floors') ?? {};
+  if (defaultFloorConfig?.endpoint) {
+    delete defaultFloorConfig.endpoint;
+  }
+
+  let ymUiConfig = { ...getFloorConfig().config };
+
+  // default values provided by publisher on YM UI
+  const defaultValues = ymUiConfig.defaultValues ?? {};
+  // If floorsData is not present or is an empty object, use default values
+  const ymFloorsData = isEmpty(getFloorConfig().data)
+    ? { ...defaultValueTemplate, values: { ...defaultValues } }
+    : getFloorConfig().data;
+
+  delete ymUiConfig.defaultValues;
+  // If skiprate is provided in configs, overwrite the value in ymFloorsData
+  (ymUiConfig.skipRate !== undefined) && (ymFloorsData.skipRate = ymUiConfig.skipRate);
+
+  // merge default configs from page, configs
+  return {
+    floors: {
+      ...defaultFloorConfig,
+      ...ymUiConfig,
+      data: ymFloorsData,
+      additionalSchemaFields: {
+        deviceType: getDeviceType,
+        timeOfDay: getTimeOfDay,
+        browser: getBrowser,
+        os: getOs,
+        utm: getUtm,
+        country: getCountry,
+        bidder: getBidder,
+      },
+    },
+  };
+};

package/libraries/pubmaticUtils/plugins/pluginManager.js

@@ -0,0 +1,106 @@
+import { logInfo, logWarn, logError } from "../../../src/utils.js";
+
+// pluginManager.js
+export const plugins = new Map();
+export const CONSTANTS = Object.freeze({
+  LOG_PRE_FIX: 'PubMatic-Plugin-Manager: '
+});
+
+/**
+ * Initialize the plugin manager with constants
+ * @returns {Object} - Plugin manager functions
+ */
+export const PluginManager = () => ({
+  register,
+  initialize,
+  executeHook
+});
+
+/**
+ * Register a plugin with the plugin manager
+ * @param {string} name - Plugin name
+ * @param {Object} plugin - Plugin object
+ * @returns {Object} - Plugin manager functions
+ */
+const register = (name, plugin) => {
+  if (plugins.has(name)) {
+    logWarn(`${CONSTANTS.LOG_PRE_FIX} Plugin ${name} already registered`);
+    return;
+  }
+  plugins.set(name, plugin);
+};
+
+/**
+ * Unregister a plugin from the plugin manager
+ * @param {string} name - Plugin name
+ * @returns {Object} - Plugin manager functions
+ */
+const unregister = (name) => {
+  if (plugins.has(name)) {
+    logInfo(`${CONSTANTS.LOG_PRE_FIX} Unregistering plugin ${name}`);
+    plugins.delete(name);
+  }
+};
+
+/**
+ * Initialize all registered plugins with their specific config
+ * @param {Object} configJsonManager - Configuration JSON manager object
+ * @returns {Promise} - Promise resolving when all plugins are initialized
+ */
+const initialize = async (configJsonManager) => {
+  const initPromises = [];
+
+  // Initialize each plugin with its specific config
+  for (const [name, plugin] of plugins.entries()) {
+    if (plugin.init) {
+      const initialized = await plugin.init(name, configJsonManager);
+      if (!initialized) {
+        unregister(name);
+      }
+      initPromises.push(initialized);
+    }
+  }
+
+  return Promise.all(initPromises);
+};
+
+/**
+ * Execute a hook on all registered plugins synchronously
+ * @param {string} hookName - Name of the hook to execute
+ * @param {...any} args - Arguments to pass to the hook
+ * @returns {Object} - Object containing merged results from all plugins
+ */
+const executeHook = (hookName, ...args) => {
+  // Cache results to avoid repeated processing
+  const results = {};
+
+  try {
+    // Get all plugins that have the specified hook method
+    const pluginsWithHook = Array.from(plugins.entries())
+      .filter(([_, plugin]) => typeof plugin[hookName] === 'function');
+
+    // Process each plugin synchronously
+    for (const [name, plugin] of pluginsWithHook) {
+      try {
+        // Call the plugin's hook method synchronously
+        const result = plugin[hookName](...args);
+
+        // Skip null/undefined results
+        if (result === null || result === undefined) {
+          continue;
+        }
+
+        // If result is an object, merge it
+        if (typeof result === 'object') {
+          Object.assign(results, result);
+        }
+      } catch (error) {
+        logError(`${CONSTANTS.LOG_PRE_FIX} Error executing hook ${hookName} in plugin ${name}: ${error.message}`);
+      }
+    }
+  } catch (error) {
+    logError(`${CONSTANTS.LOG_PRE_FIX} Error in executeHookSync: ${error.message}`);
+  }
+
+  return results;
+};