prebid.js 9.52.0 → 9.53.2

package/modules/prebidServerBidAdapter/index.js

@@ -1,9 +1,13 @@
 import Adapter from '../../src/adapter.js';
 import {
+  compressDataWithGZip,
+  debugTurnedOn,
   deepClone,
   flatten,
   generateUUID,
+  getParameterByName,
   insertUserSyncIframe,
+  isGzipCompressionSupported,
   isNumber,
   isPlainObject,
   isStr,
@@ -14,7 +18,7 @@ import {
   triggerPixel,
   uniques,
 } from '../../src/utils.js';
-import {EVENTS, REJECTION_REASON, S2S} from '../../src/constants.js';
+import {DEBUG_MODE, EVENTS, REJECTION_REASON, S2S} from '../../src/constants.js';
 import adapterManager, {s2sActivityParams} from '../../src/adapterManager.js';
 import {config} from '../../src/config.js';
 import {addPaapiConfig, isValid} from '../../src/adapters/bidderFactory.js';
@@ -66,6 +70,7 @@ let _s2sConfigs;
  * @property {number} [maxBids=1]
  * @property {AdapterOptions} [adapterOptions] adds arguments to resulting OpenRTB payload to Prebid Server
  * @property {Object} [syncUrlModifier]
+ * @property {boolean} [filterBidderlessCalls=false] filter out ad units without bidders or storedrequest before sending to PBS
  */
 
 /**
@@ -97,7 +102,8 @@ export const s2sDefaultConfig = {
       {event: 1, methods: [1, 2]}
     ],
   },
-  maxTimeout: 1500
+  maxTimeout: 1500,
+  filterBidderlessCalls: false
 };
 
 config.setDefaults({
@@ -511,43 +517,61 @@ export const processPBSRequest = hook('async', function (s2sBidRequest, bidReque
   events.emit(EVENTS.BEFORE_PBS_HTTP, requestData)
   logInfo('BidRequest: ' + requestData);
   if (request && requestData.requestJson && requestData.endpointUrl) {
-    const networkDone = s2sBidRequest.metrics.startTiming('net');
-    ajax(
-      requestData.endpointUrl,
-      {
-        success: function (response) {
-          networkDone();
-          let result;
-          try {
-            result = JSON.parse(response);
-            const {bids, paapi} = s2sBidRequest.metrics.measureTime('interpretResponse', () => interpretPBSResponse(result, request));
-            bids.forEach(onBid);
-            if (paapi) {
-              paapi.forEach(onFledge);
+    const callAjax = (payload, endpointUrl) => {
+      const networkDone = s2sBidRequest.metrics.startTiming('net');
+      ajax(
+        endpointUrl,
+        {
+          success: function (response) {
+            networkDone();
+            let result;
+            try {
+              result = JSON.parse(response);
+              const {bids, paapi} = s2sBidRequest.metrics.measureTime('interpretResponse', () => interpretPBSResponse(result, request));
+              bids.forEach(onBid);
+              if (paapi) {
+                paapi.forEach(onFledge);
+              }
+            } catch (error) {
+              logError(error);
             }
-          } catch (error) {
-            logError(error);
-          }
-          if (!result || (result.status && result.status.includes('Error'))) {
-            logError('error parsing response: ', result ? result.status : 'not valid JSON');
-            onResponse(false, requestedBidders);
-          } else {
-            onResponse(true, requestedBidders, result);
+            if (!result || (result.status && result.status.includes('Error'))) {
+              logError('error parsing response: ', result ? result.status : 'not valid JSON');
+              onResponse(false, requestedBidders);
+            } else {
+              onResponse(true, requestedBidders, result);
+            }
+          },
+          error: function () {
+            networkDone();
+            onError.apply(this, arguments);
           }
         },
-        error: function () {
-          networkDone();
-          onError.apply(this, arguments);
+        payload,
+        {
+          contentType: 'text/plain',
+          withCredentials: true,
+          browsingTopics: isActivityAllowed(ACTIVITY_TRANSMIT_UFPD, s2sActivityParams(s2sBidRequest.s2sConfig)),
+          customHeaders: requestData.customHeaders
         }
-      },
-      requestData.requestJson,
-      {
-        contentType: 'text/plain',
-        withCredentials: true,
-        browsingTopics: isActivityAllowed(ACTIVITY_TRANSMIT_UFPD, s2sActivityParams(s2sBidRequest.s2sConfig)),
-        customHeaders: requestData.customHeaders
-      }
-    );
+      );
+    }
+
+    const enableGZipCompression = s2sBidRequest.s2sConfig.endpointCompression && !requestData.customHeaders['Content-Encoding'];
+    const debugMode = getParameterByName(DEBUG_MODE).toUpperCase() === 'TRUE' || debugTurnedOn();
+    if (enableGZipCompression && debugMode) {
+      logWarn('Skipping GZIP compression for PBS as debug mode is enabled');
+    }
+
+    if (enableGZipCompression && !debugMode && isGzipCompressionSupported()) {
+      compressDataWithGZip(requestData.requestJson).then(compressedPayload => {
+        const url = new URL(requestData.endpointUrl);
+        url.searchParams.set('gzip', '1');
+        callAjax(compressedPayload, url.href);
+      });
+    } else {
+      callAjax(requestData.requestJson, requestData.endpointUrl);
+    }
   } else {
     logError('PBS request not made.  Check endpoints.');
   }

package/modules/pubmaticRtdProvider.js

@@ -1,8 +1,9 @@
 import { submodule } from '../src/hook.js';
-import { logError, isStr, isPlainObject, isEmpty, isFn, mergeDeep } from '../src/utils.js';
+import { logError, logInfo, isStr, isPlainObject, isEmpty, isFn, mergeDeep } from '../src/utils.js';
 import { config as conf } from '../src/config.js';
 import { getDeviceType as fetchDeviceType, getOS } from '../libraries/userAgentUtils/index.js';
 import { getLowEntropySUA } from '../src/fpd/sua.js';
+import { getGlobal } from '../src/prebidGlobal.js';
 
 /**
  * @typedef {import('../modules/rtdModule/index.js').RtdSubmodule} RtdSubmodule
@@ -14,7 +15,7 @@ import { getLowEntropySUA } from '../src/fpd/sua.js';
  */
 import { continueAuction } from './priceFloors.js'; // eslint-disable-line prebid/validate-imports
 
-const CONSTANTS = Object.freeze({
+export const CONSTANTS = Object.freeze({
   SUBMODULE_NAME: 'pubmatic',
   REAL_TIME_MODULE: 'realTimeData',
   LOG_PRE_FIX: 'PubMatic-Rtd-Provider: ',
@@ -33,6 +34,21 @@ const CONSTANTS = Object.freeze({
     BASEURL: 'https://ads.pubmatic.com/AdServer/js/pwt',
     FLOORS: 'floors.json',
     CONFIGS: 'config.json'
+  },
+  BID_STATUS: {
+    NOBID: 0,
+    WON: 1,
+    FLOORED: 2
+  },
+  MULTIPLIERS: {
+    WIN: 1.0,
+    FLOORED: 0.8,
+    NOBID: 1.2
+  },
+  TARGETING_KEYS: {
+    PM_YM_FLRS: 'pm_ym_flrs', // Whether RTD floor was applied
+    PM_YM_FLRV: 'pm_ym_flrv', // Final floor value (after applying multiplier)
+    PM_YM_BID_S: 'pm_ym_bid_s' // Bid status (0: No bid, 1: Won, 2: Floored)
   }
 });
 
@@ -65,6 +81,14 @@ export let configMerged;
 // configMerged is a reference to the function that can resolve configMergedPromise whenever we want
 let configMergedPromise = new Promise((resolve) => { configMerged = resolve; });
 export let _country;
+// Store multipliers from floors.json, will use default values from CONSTANTS if not available
+export let _multipliers = null;
+
+// Use a private variable for profile configs
+let _profileConfigs;
+// Export getter and setter functions for _profileConfigs
+export const getProfileConfigs = () => _profileConfigs;
+export const setProfileConfigs = (configs) => { _profileConfigs = configs; };
 
 // Waits for a given promise to resolve within a timeout
 export function withTimeout(promise, ms) {
@@ -104,6 +128,303 @@ export const getBrowserType = () => {
   return browserIndex.toString();
 }
 
+// Find all bids for a specific ad unit
+function findBidsForAdUnit(auction, code) {
+  return auction?.bidsReceived?.filter(bid => bid.adUnitCode === code) || [];
+}
+
+// Find rejected bids for a specific ad unit
+function findRejectedBidsForAdUnit(auction, code) {
+  if (!auction?.bidsRejected) return [];
+
+  // If bidsRejected is an array
+  if (Array.isArray(auction.bidsRejected)) {
+    return auction.bidsRejected.filter(bid => bid.adUnitCode === code);
+  }
+
+  // If bidsRejected is an object mapping bidders to their rejected bids
+  if (typeof auction.bidsRejected === 'object') {
+    return Object.values(auction.bidsRejected)
+      .filter(Array.isArray)
+      .flatMap(bidderBids => bidderBids.filter(bid => bid.adUnitCode === code));
+  }
+
+  return [];
+}
+
+// Find a rejected bid due to price floor
+function findRejectedFloorBid(rejectedBids) {
+  return rejectedBids.find(bid => {
+    const errorMessage = bid.statusMessage || bid.status || '';
+    return errorMessage.includes('price floor') ||
+           (bid.floorData?.floorValue && bid.cpm < bid.floorData.floorValue);
+  });
+}
+
+// Find the winning or highest bid for an ad unit
+function findWinningBid(adUnitCode) {
+  try {
+    const pbjs = getGlobal();
+    if (!pbjs?.getHighestCpmBids) return null;
+
+    const highestCpmBids = pbjs.getHighestCpmBids(adUnitCode);
+    if (!highestCpmBids?.length) {
+      logInfo(CONSTANTS.LOG_PRE_FIX, `No highest CPM bids found for ad unit: ${adUnitCode}`);
+      return null;
+    }
+
+    const highestCpmBid = highestCpmBids[0];
+    logInfo(CONSTANTS.LOG_PRE_FIX, `Found highest CPM bid using pbjs.getHighestCpmBids() for ad unit: ${adUnitCode}, CPM: ${highestCpmBid.cpm}`);
+    return highestCpmBid;
+  } catch (error) {
+    logError(CONSTANTS.LOG_PRE_FIX, `Error finding highest CPM bid: ${error}`);
+    return null;
+  }
+}
+
+// Find a bid with the minimum floor value
+function findBidWithFloor(bids) {
+  let bidWithMinFloor = null;
+  let minFloorValue = Infinity;
+
+  if (!bids || !bids.length) return null;
+
+  for (const bid of bids) {
+    if (bid.floorData?.floorValue &&
+        !isNaN(parseFloat(bid.floorData.floorValue)) &&
+        parseFloat(bid.floorData.floorValue) < minFloorValue) {
+      minFloorValue = parseFloat(bid.floorData.floorValue);
+      bidWithMinFloor = bid;
+    }
+  }
+
+  // Log the result for debugging
+  if (bidWithMinFloor) {
+    logInfo(CONSTANTS.LOG_PRE_FIX, `Found bid with minimum floor value: ${minFloorValue}`);
+  }
+
+  return bidWithMinFloor;
+}
+
+// Find floor value from bidder requests
+function findFloorValueFromBidderRequests(auction, code) {
+  if (!auction?.bidderRequests?.length) return 0;
+
+  // Find all bids in bidder requests for this ad unit
+  const bidsFromRequests = auction.bidderRequests
+    .flatMap(request => request.bids || [])
+    .filter(bid => bid.adUnitCode === code);
+
+  if (!bidsFromRequests.length) {
+    logInfo(CONSTANTS.LOG_PRE_FIX, `No bids found for ad unit: ${code}`);
+    return 0;
+  }
+
+  const bidWithGetFloor = bidsFromRequests.find(bid => bid.getFloor);
+  if (!bidWithGetFloor) {
+    logInfo(CONSTANTS.LOG_PRE_FIX, `No bid with getFloor method found for ad unit: ${code}`);
+    return 0;
+  }
+
+  // Helper function to extract sizes with their media types from a source object
+  const extractSizes = (source) => {
+    if (!source) return null;
+
+    const result = [];
+
+    // Extract banner sizes
+    if (source.mediaTypes?.banner?.sizes) {
+      source.mediaTypes.banner.sizes.forEach(size => {
+        result.push({
+          size,
+          mediaType: 'banner'
+        });
+      });
+    }
+
+    // Extract video sizes
+    if (source.mediaTypes?.video?.playerSize) {
+      const playerSize = source.mediaTypes.video.playerSize;
+      // Handle both formats: [[w, h]] and [w, h]
+      const videoSizes = Array.isArray(playerSize[0]) ? playerSize : [playerSize];
+
+      videoSizes.forEach(size => {
+        result.push({
+          size,
+          mediaType: 'video'
+        });
+      });
+    }
+
+    // Use general sizes as fallback if no specific media types found
+    if (result.length === 0 && source.sizes) {
+      source.sizes.forEach(size => {
+        result.push({
+          size,
+          mediaType: 'banner' // Default to banner for general sizes
+        });
+      });
+    }
+
+    return result.length > 0 ? result : null;
+  };
+
+  // Try to get sizes from different sources in order of preference
+  const adUnit = auction.adUnits?.find(unit => unit.code === code);
+  let sizes = extractSizes(adUnit) || extractSizes(bidWithGetFloor);
+
+  // Handle fallback to wildcard size if no sizes found
+  if (!sizes) {
+    sizes = [{ size: ['*', '*'], mediaType: 'banner' }];
+    logInfo(CONSTANTS.LOG_PRE_FIX, `No sizes found, using wildcard size for ad unit: ${code}`);
+  }
+
+  // Try to get floor values for each size
+  let minFloor = -1;
+
+  for (const sizeObj of sizes) {
+    // Extract size and mediaType from the object
+    const { size, mediaType } = sizeObj;
+
+    // Call getFloor with the appropriate media type
+    const floorInfo = bidWithGetFloor.getFloor({
+      currency: 'USD', // Default currency
+      mediaType: mediaType, // Use the media type we extracted
+      size: size
+    });
+
+    if (floorInfo?.floor && !isNaN(parseFloat(floorInfo.floor))) {
+      const floorValue = parseFloat(floorInfo.floor);
+      logInfo(CONSTANTS.LOG_PRE_FIX, `Floor value for ${mediaType} size ${size}: ${floorValue}`);
+
+      // Update minimum floor value
+      minFloor = minFloor === -1 ? floorValue : Math.min(minFloor, floorValue);
+    }
+  }
+
+  if (minFloor !== -1) {
+    logInfo(CONSTANTS.LOG_PRE_FIX, `Calculated minimum floor value ${minFloor} for ad unit: ${code}`);
+    return minFloor;
+  }
+
+  logInfo(CONSTANTS.LOG_PRE_FIX, `No floor data found for ad unit: ${code}`);
+  return 0;
+}
+
+// Select multiplier based on priority order: floors.json → config.json → default
+function selectMultiplier(multiplierKey, profileConfigs) {
+  // Define sources in priority order
+  const multiplierSources = [
+    {
+      name: 'config.json',
+      getValue: () => {
+        const configPath = profileConfigs?.plugins?.dynamicFloors?.pmTargetingKeys?.multiplier;
+        const lowerKey = multiplierKey.toLowerCase();
+        return configPath && lowerKey in configPath ? configPath[lowerKey] : null;
+      }
+    },
+    {
+      name: 'floor.json',
+      getValue: () => _multipliers && multiplierKey in _multipliers ? _multipliers[multiplierKey] : null
+    },
+    {
+      name: 'default',
+      getValue: () => CONSTANTS.MULTIPLIERS[multiplierKey]
+    }
+  ];
+
+  // Find the first source with a non-null value
+  for (const source of multiplierSources) {
+    const value = source.getValue();
+    if (value != null) {
+      return { value, source: source.name };
+    }
+  }
+
+  // Fallback (shouldn't happen due to default source)
+  return { value: CONSTANTS.MULTIPLIERS[multiplierKey], source: 'default' };
+}
+
+// Identify winning bid scenario and return scenario data
+function handleWinningBidScenario(winningBid, code) {
+  return {
+    scenario: 'winning',
+    bidStatus: CONSTANTS.BID_STATUS.WON,
+    baseValue: winningBid.cpm,
+    multiplierKey: 'WIN',
+    logMessage: `Bid won for ad unit: ${code}, CPM: ${winningBid.cpm}`
+  };
+}
+
+// Identify rejected floor bid scenario and return scenario data
+function handleRejectedFloorBidScenario(rejectedFloorBid, code) {
+  const baseValue = rejectedFloorBid.floorData?.floorValue || 0;
+  return {
+    scenario: 'rejected',
+    bidStatus: CONSTANTS.BID_STATUS.FLOORED,
+    baseValue,
+    multiplierKey: 'FLOORED',
+    logMessage: `Bid rejected due to price floor for ad unit: ${code}, Floor value: ${baseValue}, Bid CPM: ${rejectedFloorBid.cpm}`
+  };
+}
+
+// Identify floored bid scenario and return scenario data
+function handleFlooredBidScenario(bidWithFloor, code) {
+  const baseValue = bidWithFloor.floorData.floorValue;
+  return {
+    scenario: 'floored',
+    bidStatus: CONSTANTS.BID_STATUS.FLOORED,
+    baseValue,
+    multiplierKey: 'FLOORED',
+    logMessage: `Floored bid for ad unit: ${code}, Floor value: ${baseValue}`
+  };
+}
+
+// Identify no bid scenario and return scenario data
+function handleNoBidScenario(auction, code) {
+  const baseValue = findFloorValueFromBidderRequests(auction, code);
+  return {
+    scenario: 'nobid',
+    bidStatus: CONSTANTS.BID_STATUS.NOBID,
+    baseValue,
+    multiplierKey: 'NOBID',
+    logMessage: `No bids for ad unit: ${code}, Floor value: ${baseValue}`
+  };
+}
+
+// Determine which scenario applies based on bid conditions
+function determineScenario(winningBid, rejectedFloorBid, bidsForAdUnit, auction, code) {
+  if (winningBid) {
+    return handleWinningBidScenario(winningBid, code);
+  }
+
+  if (rejectedFloorBid) {
+    return handleRejectedFloorBidScenario(rejectedFloorBid, code);
+  }
+
+  const bidWithFloor = findBidWithFloor(bidsForAdUnit);
+  if (bidWithFloor?.floorData?.floorValue) {
+    return handleFlooredBidScenario(bidWithFloor, code);
+  }
+
+  return handleNoBidScenario(auction, code);
+}
+
+// Main function that determines bid status and calculates values
+function determineBidStatusAndValues(winningBid, rejectedFloorBid, bidsForAdUnit, auction, code) {
+  const profileConfigs = getProfileConfigs();
+
+  // Determine the scenario based on bid conditions
+  const { bidStatus, baseValue, multiplierKey, logMessage } =
+    determineScenario(winningBid, rejectedFloorBid, bidsForAdUnit, auction, code);
+
+  // Select the appropriate multiplier
+  const { value: multiplier, source } = selectMultiplier(multiplierKey, profileConfigs);
+  logInfo(CONSTANTS.LOG_PRE_FIX, logMessage + ` (Using ${source} multiplier: ${multiplier})`);
+
+  return { bidStatus, baseValue, multiplier };
+}
+
 // Getter Functions
 export const getOs = () => getOS().toString();
 export const getDeviceType = () => fetchDeviceType().toString();
@@ -181,7 +502,30 @@ export const fetchData = async (publisherId, profileId, type) => {
         _country = cc ? cc.split(',')?.map(code => code.trim())[0] : undefined;
       }
 
-      return await response.json();
+      const data = await response.json();
+
+      // Extract multipliers from floors.json if available
+      if (type === "FLOORS" && data && data.multiplier) {
+        // Map of source keys to destination keys
+        const multiplierKeys = {
+          'win': 'WIN',
+          'floored': 'FLOORED',
+          'nobid': 'NOBID'
+        };
+
+        // Initialize _multipliers and only add keys that exist in data.multiplier
+        _multipliers = Object.entries(multiplierKeys)
+          .reduce((acc, [srcKey, destKey]) => {
+            if (srcKey in data.multiplier) {
+              acc[destKey] = data.multiplier[srcKey];
+            }
+            return acc;
+          }, {});
+
+        logInfo(CONSTANTS.LOG_PRE_FIX, `Using multipliers from floors.json: ${JSON.stringify(_multipliers)}`);
+      }
+
+      return data;
     } catch (error) {
       logError(`${CONSTANTS.LOG_PRE_FIX} Error while fetching ${type}: ${error}`);
     }
@@ -224,6 +568,9 @@ const init = (config, _userConsent) => {
       const remainingTime = Math.max(maxWaitTime - elapsedTime, 0);
       const floorsData = await withTimeout(_fetchFloorRulesPromise, remainingTime);
 
+      // Store the profile configs globally
+      setProfileConfigs(profileConfigs);
+
       const floorsConfig = getFloorsConfig(floorsData, profileConfigs);
       floorsConfig && conf?.setConfig(floorsConfig);
       configMerged();
@@ -266,7 +613,73 @@ const getBidRequestData = (reqBidsConfigObj, callback) => {
     });
 }
 
-/** @type {RtdSubmodule} */
+/**
+ * Returns targeting data for ad units
+ * @param {string[]} adUnitCodes - Ad unit codes
+ * @param {Object} config - Module configuration
+ * @param {Object} userConsent - User consent data
+ * @param {Object} auction - Auction object
+ * @return {Object} - Targeting data for ad units
+ */
+export const getTargetingData = (adUnitCodes, config, userConsent, auction) => {
+  // Access the profile configs stored globally
+  const profileConfigs = getProfileConfigs();
+
+  // Return empty object if profileConfigs is undefined or pmTargetingKeys.enabled is explicitly set to false
+  if (!profileConfigs || profileConfigs?.plugins?.dynamicFloors?.pmTargetingKeys?.enabled === false) {
+    logInfo(`${CONSTANTS.LOG_PRE_FIX} pmTargetingKeys is disabled or profileConfigs is undefined`);
+    return {};
+  }
+
+  // Helper to check if RTD floor is applied to a bid
+  const isRtdFloorApplied = bid => bid.floorData?.floorProvider === "PM" && !bid.floorData.skipped;
+
+  // Check if any bid has RTD floor applied
+  const hasRtdFloorAppliedBid =
+    auction?.adUnits?.some(adUnit => adUnit.bids?.some(isRtdFloorApplied)) ||
+    auction?.bidsReceived?.some(isRtdFloorApplied);
+
+  // Only log when RTD floor is applied
+  if (hasRtdFloorAppliedBid) {
+    logInfo(CONSTANTS.LOG_PRE_FIX, 'Setting targeting via getTargetingData:');
+  }
+
+  // Process each ad unit code
+  const targeting = {};
+
+  adUnitCodes.forEach(code => {
+    targeting[code] = {};
+
+    // For non-RTD floor applied cases, only set pm_ym_flrs to 0
+    if (!hasRtdFloorAppliedBid) {
+      targeting[code][CONSTANTS.TARGETING_KEYS.PM_YM_FLRS] = 0;
+      return;
+    }
+
+    // Find bids and determine status for RTD floor applied cases
+    const bidsForAdUnit = findBidsForAdUnit(auction, code);
+    const rejectedBidsForAdUnit = findRejectedBidsForAdUnit(auction, code);
+    const rejectedFloorBid = findRejectedFloorBid(rejectedBidsForAdUnit);
+    const winningBid = findWinningBid(code);
+
+    // Determine bid status and values
+    const { bidStatus, baseValue, multiplier } = determineBidStatusAndValues(
+      winningBid,
+      rejectedFloorBid,
+      bidsForAdUnit,
+      auction,
+      code
+    );
+
+    // Set all targeting keys
+    targeting[code][CONSTANTS.TARGETING_KEYS.PM_YM_FLRS] = 1;
+    targeting[code][CONSTANTS.TARGETING_KEYS.PM_YM_FLRV] = (baseValue * multiplier).toFixed(2);
+    targeting[code][CONSTANTS.TARGETING_KEYS.PM_YM_BID_S] = bidStatus;
+  });
+
+  return targeting;
+};
+
 export const pubmaticSubmodule = {
   /**
    * used to link submodule with realTimeData
@@ -275,6 +688,7 @@ export const pubmaticSubmodule = {
   name: CONSTANTS.SUBMODULE_NAME,
   init,
   getBidRequestData,
+  getTargetingData
 };
 
 export const registerSubModule = () => {

package/modules/pubmaticRtdProvider.md

@@ -6,7 +6,7 @@
 
 ## Description
 
-The PubMatic RTD module fetches pricing floor data and updates the Price Floors Module based on user's context in real-time as per Price Floors Modules Floor Data Provider Interface guidelines [Dynamic Floor Data Provider](https://docs.prebid.org/dev-docs/modules/floors.html#floor-data-provider-interface).
+The PubMatic RTD module provides dynamic yield optimization by fetching real-time pricing floor data and generating targeting data for ad server integration and reporting. The module integrates with Prebid's Price Floors system as per [Dynamic Floor Data Provider](https://docs.prebid.org/dev-docs/modules/floors.html#floor-data-provider-interface) guidelines.
 
 ## Usage
 
@@ -66,7 +66,17 @@ pbjs.setConfig({
 | params.publisherId | String  | Publisher ID                                                   |                            |
 | params.profileId   | String  | Profile ID                                                     |                            |
 
+## Targeting Keys
+
+The module sets the following targeting keys for ad server integration and reporting:
+
+| Key | Description | Values |
+| :-- | :---------- | :----- |
+| pm_ym_flrs | Whether RTD floor was applied to the auction | 0 (not applied)/1 (applied) |
+| pm_ym_flrv | Floor value after applying dynamic multipliers | Decimal value (e.g., "1.25") |
+| pm_ym_bid_s | Bid outcome status | 0 (no bid), 1 (won), 2 (floored) |
+
 
 ## What Should Change in the Bid Request?
 
-There are no direct changes in the bid request due to our RTD module, but floor configuration will be set using the price floors module. These changes will be reflected in adunit bids or bidder requests as floor data.
+The RTD module applies dynamic floor configuration through the Price Floors module, which affects floor values in bid requests. Additionally, the module generates targeting data that is made available to the ad server.