Prebid Server adapter: fledge support

libraries/ortbConverter/converter.js

@@ -90,12 +90,13 @@ export function ortbConverter({
         req: Object.assign({bidRequests}, defaultContext, context),
         imp: {}
       }
+      ctx.req.impContext = ctx.imp;
       const imps = bidRequests.map(bidRequest => {
         const impContext = Object.assign({bidderRequest, reqContext: ctx.req}, defaultContext, context);
         const result = buildImp(bidRequest, impContext);
         if (result != null) {
           if (result.hasOwnProperty('id')) {
-            impContext.bidRequest = bidRequest;
+            Object.assign(impContext, {bidRequest, imp: result});
             ctx.imp[result.id] = impContext;
             return result;
           }
@@ -116,7 +117,7 @@ export function ortbConverter({
         throw new Error('ortbRequest passed to `fromORTB` must be the same object returned by `toORTB`')
       }
       function augmentContext(ctx, extraParams = {}) {
-        return Object.assign({ortbRequest: request}, extraParams, ctx);
+        return Object.assign(ctx, {ortbRequest: request}, extraParams, ctx);
       }
       const impsById = Object.fromEntries((request.imp || []).map(imp => [imp.id, imp]));
       const bidResponses = (response.seatbid || []).flatMap(seatbid =>

modules/fledgeForGpt.js

@@ -5,6 +5,7 @@
 import { config } from '../src/config.js';
 import { getHook } from '../src/hook.js';
 import { getGptSlotForAdUnitCode, logInfo, logWarn } from '../src/utils.js';
+import {IMP, PBS, registerOrtbProcessor, RESPONSE} from '../src/pbjsORTB.js';
 
 const MODULE = 'fledgeForGpt'
 
@@ -31,12 +32,10 @@ export function init(cfg) {
   }
 }
 
-export function addComponentAuctionHook(next, bidRequest, componentAuctionConfig) {
+export function addComponentAuctionHook(next, adUnitCode, componentAuctionConfig) {
   const seller = componentAuctionConfig.seller;
-  const adUnitCode = bidRequest.adUnitCode;
   const gptSlot = getGptSlotForAdUnitCode(adUnitCode);
   if (gptSlot && gptSlot.setConfig) {
-    delete componentAuctionConfig.bidId;
     gptSlot.setConfig({
       componentAuction: [{
         configKey: seller,
@@ -48,5 +47,50 @@ export function addComponentAuctionHook(next, bidRequest, componentAuctionConfig
     logWarn(MODULE, `unable to register component auction config for: ${adUnitCode} x ${seller}.`);
   }
 
-  next(bidRequest, componentAuctionConfig);
+  next(adUnitCode, componentAuctionConfig);
 }
+
+export function markBidsForFledge(next, bidderRequests) {
+  if (navigator.runAdAuction) {
+    bidderRequests.forEach((req) => {
+      req.fledgeEnabled = config.runWithBidder(req.bidderCode, () => config.getConfig('fledgeEnabled'))
+    })
+  }
+  next(bidderRequests);
+}
+getHook('makeBidRequests').after(markBidsForFledge);
+
+export function setImpExtAe(imp, bidRequest, context) {
+  if (!context.bidderRequest.fledgeEnabled) {
+    delete imp.ext?.ae;
+  }
+}
+registerOrtbProcessor({type: IMP, name: 'impExtAe', fn: setImpExtAe});
+
+// to make it easier to share code between the PBS adapter and adapters whose backend is PBS, break up
+// fledge response processing in two steps: first aggregate all the auction configs by their imp...
+
+export function parseExtPrebidFledge(response, ortbResponse, context) {
+  (ortbResponse.ext?.prebid?.fledge?.auctionconfigs || []).forEach((cfg) => {
+    const impCtx = context.impContext[cfg.impid];
+    if (!impCtx?.imp?.ext?.ae) {
+      logWarn('Received fledge auction configuration for an impression that was not in the request or did not ask for it', cfg, impCtx?.imp);
+    } else {
+      impCtx.fledgeConfigs = impCtx.fledgeConfigs || [];
+      impCtx.fledgeConfigs.push(cfg);
+    }
+  })
+}
+registerOrtbProcessor({type: RESPONSE, name: 'extPrebidFledge', fn: parseExtPrebidFledge, dialects: [PBS]});
+
+// ...then, make them available in the adapter's response. This is the client side version, for which the
+// interpretResponse api is {fledgeAuctionConfigs: [{bidId, config}]}
+
+export function setResponseFledgeConfigs(response, ortbResponse, context) {
+  const configs = Object.values(context.impContext)
+    .flatMap((impCtx) => (impCtx.fledgeConfigs || []).map(cfg => ({bidId: impCtx.bidRequest.bidId, config: cfg.config})));
+  if (configs.length > 0) {
+    response.fledgeAuctionConfigs = configs;
+  }
+}
+registerOrtbProcessor({type: RESPONSE, name: 'fledgeAuctionConfigs', priority: -1, fn: setResponseFledgeConfigs, dialects: [PBS]})

modules/openxOrtbBidAdapter.js

@@ -32,10 +32,6 @@ const converter = ortbConverter({
     if (bidRequest.mediaTypes[VIDEO]?.context === 'outstream') {
       imp.video.placement = imp.video.placement || 4;
     }
-    if (imp.ext?.ae && !context.bidderRequest.fledgeEnabled) {
-      // TODO: we may want to standardize this and move fledge logic to ortbConverter
-      delete imp.ext.ae;
-    }
     mergeDeep(imp, {
       tagid: bidRequest.params.unit,
       ext: {
@@ -106,10 +102,12 @@ const converter = ortbConverter({
     let fledgeAuctionConfigs = utils.deepAccess(ortbResponse, 'ext.fledge_auction_configs');
     if (fledgeAuctionConfigs) {
       fledgeAuctionConfigs = Object.entries(fledgeAuctionConfigs).map(([bidId, cfg]) => {
-        return Object.assign({
+        return {
           bidId,
-          auctionSignals: {}
-        }, cfg);
+          config: Object.assign({
+            auctionSignals: {},
+          }, cfg)
+        }
       });
       return {
         bids: response.bids,

modules/prebidServerBidAdapter/index.js

@@ -20,7 +20,7 @@ import {
 import CONSTANTS from '../../src/constants.json';
 import adapterManager from '../../src/adapterManager.js';
 import {config} from '../../src/config.js';
-import {isValid} from '../../src/adapters/bidderFactory.js';
+import {addComponentAuction, isValid} from '../../src/adapters/bidderFactory.js';
 import * as events from '../../src/events.js';
 import {includes} from '../../src/polyfill.js';
 import {S2S_VENDORS} from './config.js';
@@ -469,6 +469,9 @@ export function PrebidServer() {
               addBidResponse.reject(adUnit, bid, CONSTANTS.REJECTION_REASON.INVALID);
             }
           }
+        },
+        onFledge: ({adUnitCode, config}) => {
+          addComponentAuction(adUnitCode, config);
         }
       })
     }
@@ -494,7 +497,7 @@ export function PrebidServer() {
  * @param onError {function(String, {})} invoked on HTTP failure - with status message and XHR error
  * @param onBid {function({})} invoked once for each bid in the response - with the bid as returned by interpretResponse
  */
-export const processPBSRequest = hook('sync', function (s2sBidRequest, bidRequests, ajax, {onResponse, onError, onBid}) {
+export const processPBSRequest = hook('sync', function (s2sBidRequest, bidRequests, ajax, {onResponse, onError, onBid, onFledge}) {
   let { gdprConsent } = getConsentData(bidRequests);
   const adUnits = deepClone(s2sBidRequest.ad_units);
 
@@ -518,8 +521,11 @@ export const processPBSRequest = hook('sync', function (s2sBidRequest, bidReques
           let result;
           try {
             result = JSON.parse(response);
-            const bids = s2sBidRequest.metrics.measureTime('interpretResponse', () => interpretPBSResponse(result, request).bids);
+            const {bids, fledgeAuctionConfigs} = s2sBidRequest.metrics.measureTime('interpretResponse', () => interpretPBSResponse(result, request));
             bids.forEach(onBid);
+            if (fledgeAuctionConfigs) {
+              fledgeAuctionConfigs.forEach(onFledge);
+            }
           } catch (error) {
             logError(error);
           }

modules/prebidServerBidAdapter/ortbConverter.js

@@ -215,6 +215,13 @@ const PBS_CONVERTER = ortbConverter({
       serverSideStats(orig, response, ortbResponse, context) {
         // override to process each request
         context.actualBidderRequests.forEach(req => orig(response, ortbResponse, {...context, bidderRequest: req, bidRequests: req.bids}));
+      },
+      fledgeAuctionConfigs(orig, response, ortbResponse, context) {
+        const configs = Object.values(context.impContext)
+          .flatMap((impCtx) => (impCtx.fledgeConfigs || []).map(cfg => ({adUnitCode: impCtx.adUnit.code, config: cfg.config})));
+        if (configs.length > 0) {
+          response.fledgeAuctionConfigs = configs;
+        }
       }
     }
   },
@@ -247,11 +254,14 @@ export function buildPBSRequest(s2sBidRequest, bidderRequests, adUnits, requeste
     proxyBidRequests.push({
       ...adUnit,
       ...getDefinedParams(actualBidRequests.values().next().value || {}, ['userId', 'userIdAsEids', 'schain']),
-      pbsData: {impId, actualBidRequests, adUnit}
+      pbsData: {impId, actualBidRequests, adUnit},
     });
   });
 
-  const proxyBidderRequest = Object.fromEntries(Object.entries(bidderRequests[0]).filter(([k]) => !BIDDER_SPECIFIC_REQUEST_PROPS.has(k)))
+  const proxyBidderRequest = {
+    ...Object.fromEntries(Object.entries(bidderRequests[0]).filter(([k]) => !BIDDER_SPECIFIC_REQUEST_PROPS.has(k))),
+    fledgeEnabled: bidderRequests.some(req => req.fledgeEnabled)
+  }
 
   return PBS_CONVERTER.toORTB({
     bidderRequest: proxyBidderRequest,

modules/rtbhouseBidAdapter.js

@@ -171,10 +171,12 @@ export const spec = {
 
     if (fledgeAuctionConfigs) {
       fledgeAuctionConfigs = Object.entries(fledgeAuctionConfigs).map(([bidId, cfg]) => {
-        return Object.assign({
+        return {
           bidId,
-          auctionSignals: {}
-        }, cfg);
+          config: Object.assign({
+            auctionSignals: {}
+          }, cfg)
+        }
       });
       logInfo('Response with FLEDGE:', { bids, fledgeAuctionConfigs });
       return {

src/adapterManager.js

@@ -321,13 +321,6 @@ adapterManager.makeBidRequests = hook('sync', function (adUnits, auctionStart, a
     });
   }
 
-  bidRequests.forEach(bidRequest => {
-    config.runWithBidder(bidRequest.bidderCode, () => {
-      const fledgeEnabledFromConfig = config.getConfig('fledgeEnabled');
-      bidRequest['fledgeEnabled'] = navigator.runAdAuction && fledgeEnabledFromConfig
-    });
-  });
-
   return bidRequests;
 }, 'makeBidRequests');
 

src/adapters/bidderFactory.js

@@ -1,20 +1,32 @@
 import Adapter from '../adapter.js';
 import adapterManager from '../adapterManager.js';
-import { config } from '../config.js';
-import { createBid } from '../bidfactory.js';
-import { userSync } from '../userSync.js';
-import { nativeBidIsValid } from '../native.js';
-import { isValidVideoBid } from '../video.js';
+import {config} from '../config.js';
+import {createBid} from '../bidfactory.js';
+import {userSync} from '../userSync.js';
+import {nativeBidIsValid} from '../native.js';
+import {isValidVideoBid} from '../video.js';
 import CONSTANTS from '../constants.json';
 import * as events from '../events.js';
 import {includes} from '../polyfill.js';
-import { ajax } from '../ajax.js';
-import { logWarn, logInfo, logError, parseQueryStringParameters, delayExecution, parseSizesInput, flatten, uniques, timestamp, deepAccess, isArray, isPlainObject } from '../utils.js';
-import { ADPOD } from '../mediaTypes.js';
-import { getHook, hook } from '../hook.js';
-import { getCoreStorageManager } from '../storageManager.js';
+import {ajax} from '../ajax.js';
+import {
+  deepAccess,
+  delayExecution,
+  flatten,
+  isArray,
+  isPlainObject,
+  logError,
+  logWarn,
+  parseQueryStringParameters,
+  parseSizesInput,
+  timestamp,
+  uniques
+} from '../utils.js';
+import {ADPOD} from '../mediaTypes.js';
+import {getHook, hook} from '../hook.js';
+import {getCoreStorageManager} from '../storageManager.js';
 import {auctionManager} from '../auctionManager.js';
-import { bidderSettings } from '../bidderSettings.js';
+import {bidderSettings} from '../bidderSettings.js';
 import {useMetrics} from '../utils/perfMetrics.js';
 
 export const storage = getCoreStorageManager('bidderFactory');
@@ -247,7 +259,7 @@ export function newBidder(spec) {
           fledgeAuctionConfigs.forEach((fledgeAuctionConfig) => {
             const bidRequest = bidRequestMap[fledgeAuctionConfig.bidId];
             if (bidRequest) {
-              addComponentAuction(bidRequest, fledgeAuctionConfig);
+              addComponentAuction(bidRequest.adUnitCode, fledgeAuctionConfig.config);
             }
           });
         },
@@ -467,9 +479,8 @@ export const registerSyncInner = hook('async', function(spec, responses, gdprCon
   }
 }, 'registerSyncs')
 
-export const addComponentAuction = hook('sync', (_bidRequest, fledgeAuctionConfig) => {
-  logInfo(`bidderFactory.addComponentAuction`, fledgeAuctionConfig);
-}, 'addComponentAuction')
+export const addComponentAuction = hook('sync', (adUnitCode, fledgeAuctionConfig) => {
+}, 'addComponentAuction');
 
 export function preloadBidderMappingFile(fn, adUnits) {
   if (!config.getConfig('adpod.brandCategoryExclusion')) {