diff --git a/integrationExamples/gpt/haloRtdProvider_example.html b/integrationExamples/gpt/haloRtdProvider_example.html
index 7f9a34e55ee..14debbd2698 100644
--- a/integrationExamples/gpt/haloRtdProvider_example.html
+++ b/integrationExamples/gpt/haloRtdProvider_example.html
@@ -40,27 +40,6 @@
             googletag.pubads().disableInitialLoad();
         });
 
-        var appnexusSegmentHandler = function(bid, segments) {
-            if (!bid.params) {
-                bid.params = {};
-            }
-            if (!bid.params.user) {
-                bid.params.user = {};
-            }
-
-            if (!Array.isArray(bid.params.user.segments)) {
-                 bid.params.user.segments = [];
-            }
-
-            var appnexusSegments = [];
-            for (var i = 0; i < segments.length; i++) {
-                var segment = segments[i];
-                let appnexusSegment = {'id': segment.id, 'value': segment.value};
-                appnexusSegments.push(appnexusSegment);
-            }
-            bid.params.user.segments = bid.params.user.segments.concat(appnexusSegments);
-        };
-
         pbjs.que.push(function() {
             pbjs.setConfig({
                 debug: true,
@@ -71,9 +50,6 @@
                             name: "halo",
                             waitForIt: true,
                             params: {
-                                mapSegments: {
-                                    appnexus: appnexusSegmentHandler // pass true to use the builtin handler.  here, we will demo overriding the handler with a function
-                                },
                                 segmentCache: false,
                                 requestParams: {
                                     publisherId: 0
@@ -89,7 +65,7 @@
         });
 
         function sendAdserverRequest() {
-            document.getElementById('audigent_segments').innerHTML = JSON.stringify(adUnits[0].bids[0].params.user.segments);
+            document.getElementById('audigent_segments').innerHTML = window.localStorage.getItem('auHaloRtd');
             document.getElementById('halo_id').innerHTML = testHaloId;
 
             if (pbjs.adserverRequestSent) return;
@@ -130,7 +106,7 @@
 </head>
 
 <body>
-<h2>Audigent Segments Prebid</h2>
+<h2>Halo RTD Prebid</h2>
 
 <div id='test-div'>
     <script>
@@ -142,7 +118,7 @@ <h2>Audigent Segments Prebid</h2>
 <div id='halo_id'>
 </div>
 
-Audigent Segments (Appnexus):
+Halo Real-Time Data:
 <div id='audigent_segments'>
 </div>
 </body>
diff --git a/modules/haloIdSystem.js b/modules/haloIdSystem.js
index d0eb79d4ac2..926e6945436 100644
--- a/modules/haloIdSystem.js
+++ b/modules/haloIdSystem.js
@@ -5,11 +5,15 @@
  * @requires module:modules/userId
  */
 
-import * as utils from '../src/utils.js';
 import {ajax} from '../src/ajax.js';
+import {getStorageManager} from '../src/storageManager.js';
 import {submodule} from '../src/hook.js';
+import * as utils from '../src/utils.js';
 
 const MODULE_NAME = 'haloId';
+const AU_GVLID = 561;
+
+export const storage = getStorageManager(AU_GVLID, 'halo');
 
 /** @type {Submodule} */
 export const haloIdSubmodule = {
@@ -37,24 +41,30 @@ export const haloIdSubmodule = {
     const url = `https://id.halo.ad.gt/api/v1/pbhid`;
 
     const resp = function (callback) {
-      const callbacks = {
-        success: response => {
-          let responseObj;
-          if (response) {
-            try {
-              responseObj = JSON.parse(response);
-            } catch (error) {
-              utils.logError(error);
+      let haloId = storage.getDataFromLocalStorage('auHaloId');
+      if (utils.isStr(haloId)) {
+        const responseObj = {haloId: haloId};
+        callback(responseObj);
+      } else {
+        const callbacks = {
+          success: response => {
+            let responseObj;
+            if (response) {
+              try {
+                responseObj = JSON.parse(response);
+              } catch (error) {
+                utils.logError(error);
+              }
             }
+            callback(responseObj);
+          },
+          error: error => {
+            utils.logError(`${MODULE_NAME}: ID fetch encountered an error`, error);
+            callback();
           }
-          callback(responseObj);
-        },
-        error: error => {
-          utils.logError(`${MODULE_NAME}: ID fetch encountered an error`, error);
-          callback();
-        }
-      };
-      ajax(url, callbacks, undefined, {method: 'GET'});
+        };
+        ajax(url, callbacks, undefined, {method: 'GET'});
+      }
     };
     return {callback: resp};
   }
diff --git a/modules/haloRtdProvider.js b/modules/haloRtdProvider.js
index 1ce44ca6004..055b40c9d09 100644
--- a/modules/haloRtdProvider.js
+++ b/modules/haloRtdProvider.js
@@ -1,25 +1,31 @@
 /**
- * This module adds audigent provider to the real time data module
+ * This module adds the Audigent Halo provider to the real time data module
  * The {@link module:modules/realTimeData} module is required
- * The module will fetch segments from audigent server
- * @module modules/audigentRtdProvider
+ * The module will fetch real-time data from Audigent
+ * @module modules/haloRtdProvider
  * @requires module:modules/realTimeData
  */
+import {ajax} from '../src/ajax.js';
+import {config} from '../src/config.js';
 import {getGlobal} from '../src/prebidGlobal.js';
-import * as utils from '../src/utils.js';
+import {getStorageManager} from '../src/storageManager.js';
 import {submodule} from '../src/hook.js';
-import {ajax} from '../src/ajax.js';
-import { getStorageManager } from '../src/storageManager.js';
+import {isFn, isStr, isPlainObject, mergeDeep, logError} from '../src/utils.js';
 
-export const storage = getStorageManager();
-
-/** @type {string} */
 const MODULE_NAME = 'realTimeData';
 const SUBMODULE_NAME = 'halo';
+const AU_GVLID = 561;
 
 export const HALOID_LOCAL_NAME = 'auHaloId';
-export const SEG_LOCAL_NAME = '__adgntseg';
+export const RTD_LOCAL_NAME = 'auHaloRtd';
+export const storage = getStorageManager(AU_GVLID, SUBMODULE_NAME);
 
+/**
+ * Deep set an object unless value present.
+ * @param {Object} obj
+ * @param {String} path
+ * @param {Object} val
+ */
 const set = (obj, path, val) => {
   const keys = path.split('.');
   const lastKey = keys.pop();
@@ -27,83 +33,67 @@ const set = (obj, path, val) => {
   lastObj[lastKey] = lastObj[lastKey] || val;
 };
 
-/** bid adapter format segment augmentation functions */
-const segmentMappers = {
-  appnexus: function(bid, segments) {
-    set(bid, 'params.user.segments', []);
-    let appnexusSegments = [];
-    segments.forEach(segment => {
-      if (typeof segment.id != 'undefined' && segment.id != null) {
-        appnexusSegments.push(parseInt(segment.id));
-      }
-    })
-    bid.params.user.segments = bid.params.user.segments.concat(appnexusSegments);
-  },
-  generic: function(bid, segments) {
-    bid.segments = bid.segments || [];
-    if (Array.isArray(bid.segments)) {
-      bid.segments = bid.segments.concat(segments);
-    }
+/**
+ * Lazy merge objects.
+ * @param {String} target
+ * @param {String} source
+ */
+function mergeLazy(target, source) {
+  if (!isPlainObject(target)) {
+    target = {};
+  }
+  if (!isPlainObject(source)) {
+    source = {};
   }
+  return mergeDeep(target, source);
 }
 
 /**
- * decorate adUnits with segment data
- * @param {adUnit[]} adUnits
- * @param {Object} data
+ * Param or default.
+ * @param {String} param
+ * @param {String} defaultVal
  */
-export function addSegmentData(adUnits, segmentData, config) {
-  adUnits.forEach(adUnit => {
-    if (adUnit.hasOwnProperty('bids')) {
-      adUnit.bids.forEach(bid => {
-        try {
-          set(bid, 'fpd.user.data', []);
-          if (Array.isArray(bid.fpd.user.data)) {
-            bid.fpd.user.data.forEach(fpdData => {
-              let segments = segmentData[fpdData.id] || segmentData[fpdData.name] || [];
-              fpdData.segment = (fpdData.segment || []).concat(segments);
-            });
-          }
-        } catch (err) {
-          utils.logError(err.message);
-        }
+function paramOrDefault(param, defaultVal) {
+  if (isFn(param)) {
+    return param();
+  } else if (isStr(param)) {
+    return param;
+  }
+  return defaultVal;
+}
 
-        try {
-          if (config.params.mapSegments && config.params.mapSegments[bid.bidder] && segmentData[bid.bidder]) {
-            if (typeof config.params.mapSegments[bid.bidder] == 'function') {
-              config.params.mapSegments[bid.bidder](bid, segmentData[bid.bidder]);
-            } else if (segmentMappers[bid.bidder]) {
-              segmentMappers[bid.bidder](bid, segmentData[bid.bidder]);
-            }
-          }
-        } catch (err) {
-          utils.logError(err.message);
-        }
-      });
-    }
-  });
+/**
+ * Add real-time data & merge segments.
+ * @param {Object} bidConfig
+ * @param {Object} rtd
+ * @param {Object} rtdConfig
+ */
+export function addRealTimeData(bidConfig, rtd, rtdConfig) {
+  let ortb2 = config.getConfig('ortb2') || {};
 
-  return adUnits;
+  if (rtdConfig.params && rtdConfig.params.handleRtd) {
+    rtdConfig.params.handleRtd(bidConfig, rtd, rtdConfig, config);
+  } else if (rtd.ortb2) {
+    config.setConfig({ortb2: mergeLazy(ortb2, rtd.ortb2)});
+  }
 }
 
 /**
- * segment retrieval from audigent's backends
+ * Real-time data retrieval from Audigent
  * @param {Object} reqBidsConfigObj
  * @param {function} onDone
- * @param {Object} config
+ * @param {Object} rtdConfig
  * @param {Object} userConsent
  */
-export function getSegments(reqBidsConfigObj, onDone, config, userConsent) {
-  const adUnits = reqBidsConfigObj.adUnits || getGlobal().adUnits;
-
-  if (config.params.segmentCache) {
-    let jsonData = storage.getDataFromLocalStorage(SEG_LOCAL_NAME);
+export function getRealTimeData(bidConfig, onDone, rtdConfig, userConsent) {
+  if (rtdConfig && isPlainObject(rtdConfig.params) && rtdConfig.params.segmentCache) {
+    let jsonData = storage.getDataFromLocalStorage(RTD_LOCAL_NAME);
 
     if (jsonData) {
       let data = JSON.parse(jsonData);
 
-      if (data.audigent_segments) {
-        addSegmentData(adUnits, data.audigent_segments, config);
+      if (data.rtd) {
+        addRealTimeData(bidConfig, data.rtd, rtdConfig);
         onDone();
         return;
       }
@@ -113,53 +103,54 @@ export function getSegments(reqBidsConfigObj, onDone, config, userConsent) {
   const userIds = (getGlobal()).getUserIds();
 
   let haloId = storage.getDataFromLocalStorage(HALOID_LOCAL_NAME);
-  if (haloId) {
+  if (isStr(haloId)) {
     userIds.haloId = haloId;
-    getSegmentsAsync(adUnits, onDone, config, userConsent, userIds);
+    getRealTimeDataAsync(bidConfig, onDone, rtdConfig, userConsent, userIds);
   } else {
     var script = document.createElement('script')
     script.type = 'text/javascript';
 
-    script.onload = function() {
-      userIds.haloId = storage.getDataFromLocalStorage(HALOID_LOCAL_NAME);
-      getSegmentsAsync(adUnits, onDone, config, userConsent, userIds);
+    window.pubHaloCb = (haloId) => {
+      userIds.haloId = haloId;
+      getRealTimeDataAsync(bidConfig, onDone, rtdConfig, userConsent, userIds);
     }
 
-    script.src = 'https://id.halo.ad.gt/api/v1/haloid';
+    const haloIdUrl = rtdConfig.params && rtdConfig.params.haloIdUrl;
+    script.src = paramOrDefault(haloIdUrl, 'https://id.halo.ad.gt/api/v1/haloid');
     document.getElementsByTagName('head')[0].appendChild(script);
   }
 }
 
 /**
- * async segment retrieval from audigent's backends
- * @param {adUnit[]} adUnits
+ * Async rtd retrieval from Audigent
  * @param {function} onDone
- * @param {Object} config
+ * @param {Object} rtdConfig
  * @param {Object} userConsent
  * @param {Object} userIds
  */
-export function getSegmentsAsync(adUnits, onDone, config, userConsent, userIds) {
+export function getRealTimeDataAsync(bidConfig, onDone, rtdConfig, userConsent, userIds) {
   let reqParams = {};
-  if (typeof config == 'object' && config != null) {
-    set(config, 'params.requestParams', {});
-    reqParams = config.params.requestParams;
+
+  if (isPlainObject(rtdConfig)) {
+    set(rtdConfig, 'params.requestParams.ortb2', config.getConfig('ortb2'));
+    reqParams = rtdConfig.params.requestParams;
   }
 
-  const url = `https://seg.halo.ad.gt/api/v1/rtb_segments`;
+  const url = `https://seg.halo.ad.gt/api/v1/rtd`;
   ajax(url, {
     success: function (response, req) {
       if (req.status === 200) {
         try {
           const data = JSON.parse(response);
-          if (data && data.audigent_segments) {
-            addSegmentData(adUnits, data.audigent_segments, config);
+          if (data && data.rtd) {
+            addRealTimeData(bidConfig, data.rtd, rtdConfig);
             onDone();
-            storage.setDataInLocalStorage(SEG_LOCAL_NAME, JSON.stringify(data));
+            storage.setDataInLocalStorage(RTD_LOCAL_NAME, JSON.stringify(data));
           } else {
             onDone();
           }
         } catch (err) {
-          utils.logError('unable to parse audigent segment data');
+          logError('unable to parse audigent segment data');
           onDone();
         }
       } else if (req.status === 204) {
@@ -169,7 +160,7 @@ export function getSegmentsAsync(adUnits, onDone, config, userConsent, userIds)
     },
     error: function () {
       onDone();
-      utils.logError('unable to get audigent segment data');
+      logError('unable to get audigent segment data');
     }
   },
   JSON.stringify({'userIds': userIds, 'config': reqParams}),
@@ -178,7 +169,7 @@ export function getSegmentsAsync(adUnits, onDone, config, userConsent, userIds)
 }
 
 /**
- * module init
+ * Module init
  * @param {Object} provider
  * @param {Objkect} userConsent
  * @return {boolean}
@@ -190,7 +181,7 @@ function init(provider, userConsent) {
 /** @type {RtdSubmodule} */
 export const haloSubmodule = {
   name: SUBMODULE_NAME,
-  getBidRequestData: getSegments,
+  getBidRequestData: getRealTimeData,
   init: init
 };
 
diff --git a/modules/haloRtdProvider.md b/modules/haloRtdProvider.md
index 2897a5917fa..02dc6577e49 100644
--- a/modules/haloRtdProvider.md
+++ b/modules/haloRtdProvider.md
@@ -4,13 +4,13 @@ Audigent is a next-generation data management platform and a first-of-a-kind
 "data agency" containing some of the most exclusive content-consuming audiences
 across desktop, mobile and social platforms.
 
-This real-time data module provides quality user segmentation that can be
-attached to bid request objects destined for different SSPs in order to optimize
+This real-time data module provides quality segmentation that can be
+provided to bid request objects destined for different SSPs in order to optimize
 targeting. Audigent maintains a large database of first-party Tradedesk Unified
 ID, Audigent Halo ID and other id provider mappings to various third-party
 segment types that are utilizable across different SSPs.  With this module,
-these segments can be retrieved and supplied to the SSP in real-time during
-the bid request cycle.
+these segments and other data can be retrieved and supplied to your pages
+and the bidstream in real-time during the bid request cycle.
 
 ### Publisher Usage
 
@@ -18,15 +18,12 @@ Compile the Halo RTD module into your Prebid build:
 
 `gulp build --modules=userId,unifiedIdSystem,rtdModule,audigentRtdProvider,appnexusBidAdapter`
 
-Add the Halo RTD provider to your Prebid config.  For any adapters
-that you would like to retrieve segments for, add a mapping in the 'mapSegments'
-parameter.  In this example we will configure publisher 1234 to retrieve
-appnexus segments from Audigent. See the "Parameter Descriptions" below for
-more detailed information of the configuration parameters. Currently,
-OpenRTB compatible fpd data will be added for any bid adapter in the
-"mapSegments" objects. Automated bid augmentation exists for some bidders.
-Please work with your Audigent Prebid support team (prebid@audigent.com) on
-which version of Prebid.js supports which bidders automatically.
+Add the Halo RTD provider to your Prebid config. In this example we will configure
+publisher 1234 to retrieve segments from Audigent. See the
+"Parameter Descriptions" below for more detailed information of the
+configuration parameters. Please work with your Audigent Prebid support team
+(prebid@audigent.com) on which version of Prebid.js supports different bidder
+and segment configurations.
 
 ```
 pbjs.setConfig(
@@ -38,9 +35,6 @@ pbjs.setConfig(
                 name: "halo",
                 waitForIt: true,
                 params: {
-                    mapSegments: {
-                        appnexus: true,
-                    },
                     segmentCache: false,
                     requestParams: {
                         publisherId: 1234
@@ -53,28 +47,27 @@ pbjs.setConfig(
 }
 ```
 
-### Parameter Descriptions for the Halo `dataProviders` Configuration Section
+### Parameter Descriptions for the Halo Configuration Section
 
 | Name  |Type | Description   | Notes  |
 | :------------ | :------------ | :------------ |:------------ |
 | name | String | Real time data module name | Always 'halo' |
 | waitForIt | Boolean | Required to ensure that the auction is delayed until prefetch is complete | Optional. Defaults to false |
 | params | Object | | |
-| params.mapSegments | Boolean | Dictionary of bidders you would like to supply Audigent segments for. Maps to boolean values, but also allows functions for custom mapping logic. The function signature is (bid, segments) => {}. | Required |
+| params.handleRtd | Function | A passable RTD handler that allows custom adunit and ortb2 logic to be configured. The function signature is (bidConfig, rtd, rtdConfig, pbConfig) => {}. | Optional |
 | params.segmentCache | Boolean | This parameter tells the Halo RTD module to attempt reading segments from a local storage cache instead of always requesting them from the Audigent server. | Optional. Defaults to false. |
 | params.requestParams | Object | Publisher partner specific configuration options, such as optional publisher id and other segment query related metadata to be submitted to Audigent's backend with each request.  Contact prebid@audigent.com for more information. | Optional |
+| params.haloIdUrl | String | Parameter to specify alternate haloid endpoint url. | Optional |
 
-### Overriding & Adding Segment Mappers
+### Publisher Customized RTD Handling
 As indicated above, it is possible to provide your own bid augmentation
-functions.  This is useful if you know a bid adapter's API supports segment
-fields which aren't specifically being added to request objects in the Prebid
-bid adapter.  You can also override segment mappers by passing a function
-instead of a boolean to the Halo RTD segment module.  This might be useful
-if you'd like to use custom logic to determine which segments are sent
-to a specific backend.
+functions rather than simply merging supplied data.  This is useful if you
+want to perform custom bid augmentation and logic with Halo real-time data
+prior to the bid request being sent. Simply add your custom logic to the
+optional handleRtd parameter and provide your custom RTD handling logic there.
 
 Please see the following example, which provides a function to modify bids for
-a bid adapter called adBuzz and overrides the appnexus segment mapper.
+a bid adapter called adBuzz and perform custom logic on bidder parameters.
 
 ```
 pbjs.setConfig(
@@ -86,19 +79,14 @@ pbjs.setConfig(
                 name: "halo",
                 waitForIt: true,
                 params: {
-                    mapSegments: {
-                        // adding an adBuzz segment mapper
-                        adBuzz: function(bid, segments) {
-                            bid.params.adBuzzCustomSegments = [];
-                            for (var i = 0; i < segments.length; i++) {
-                                bid.params.adBuzzCustomSegments.push(segments[i].id);
-                            }
-                        },
-                        // overriding the appnexus segment mapper to exclude certain segments
-                        appnexus: function(bid, segments) {
-                            for (var i = 0; i < segments.length; i++) {
-                                if (segments[i].id != 'exclude_segment') {
-                                    bid.params.user.segments.push(segments[i].id);
+                    handleRtd: function(bidConfig, rtd, rtdConfig, pbConfig) {
+                        var adUnits = bidConfig.adUnits;
+                        for (var i = 0; i < adUnits.length; i++) {
+                            var adUnit = adUnits[i];
+                            for (var j = 0; j < adUnit.bids.length; j++) {
+                                var bid = adUnit.bids[j];
+                                if (bid.bidder == 'adBuzz' && rtd['adBuzz'][0].value != 'excludeSeg') {
+                                    bid.params.adBuzzCustomSegments.push(rtd['adBuzz'][0].id);
                                 }
                             }
                         }
@@ -115,7 +103,10 @@ pbjs.setConfig(
 }
 ```
 
-More examples can be viewed in the haloRtdAdapter_spec.js tests.
+The handleRtd function can also be used to configure custom ortb2 data
+processing. Please see the examples available in the haloRtdProvider_spec.js
+tests and work with your Audigent Prebid integration team (prebid@audigent.com)
+on how to best configure your own Halo RTD & Open RTB data handlers.
 
 ### Testing
 
diff --git a/test/spec/modules/haloIdSystem_spec.js b/test/spec/modules/haloIdSystem_spec.js
new file mode 100644
index 00000000000..240a83c3c83
--- /dev/null
+++ b/test/spec/modules/haloIdSystem_spec.js
@@ -0,0 +1,31 @@
+import { haloIdSubmodule, storage } from 'modules/haloIdSystem.js';
+import { server } from 'test/mocks/xhr.js';
+import * as utils from 'src/utils.js';
+
+describe('HaloIdSystem', function () {
+  describe('getId', function() {
+    it('gets a haloId', function() {
+      const config = {
+        params: {}
+      };
+      const callbackSpy = sinon.spy();
+      const callback = haloIdSubmodule.getId(config).callback;
+      callback(callbackSpy);
+      const request = server.requests[0];
+      expect(request.url).to.eq(`https://id.halo.ad.gt/api/v1/pbhid`);
+      request.respond(200, { 'Content-Type': 'application/json' }, JSON.stringify({ haloId: 'testHaloId1' }));
+      expect(callbackSpy.lastCall.lastArg).to.deep.equal({haloId: 'testHaloId1'});
+    });
+
+    it('gets a cached haloid', function() {
+      const config = {
+        params: {}
+      };
+      storage.setDataInLocalStorage('auHaloId', 'tstCachedHaloId1');
+      const callbackSpy = sinon.spy();
+      const callback = haloIdSubmodule.getId(config).callback;
+      callback(callbackSpy);
+      expect(callbackSpy.lastCall.lastArg).to.deep.equal({haloId: 'tstCachedHaloId1'});
+    });
+  });
+});
diff --git a/test/spec/modules/haloRtdProvider_spec.js b/test/spec/modules/haloRtdProvider_spec.js
index 69ea4bc997c..3052441a00d 100644
--- a/test/spec/modules/haloRtdProvider_spec.js
+++ b/test/spec/modules/haloRtdProvider_spec.js
@@ -1,220 +1,374 @@
-import { HALOID_LOCAL_NAME, SEG_LOCAL_NAME, addSegmentData, getSegments, haloSubmodule, storage } from 'modules/haloRtdProvider.js';
-import { server } from 'test/mocks/xhr.js';
+import {config} from 'src/config.js';
+import {HALOID_LOCAL_NAME, RTD_LOCAL_NAME, addRealTimeData, getRealTimeData, haloSubmodule, storage} from 'modules/haloRtdProvider.js';
+import {server} from 'test/mocks/xhr.js';
 
 const responseHeader = {'Content-Type': 'application/json'};
 
 describe('haloRtdProvider', function() {
+  let getDataFromLocalStorageStub;
+
+  beforeEach(function() {
+    config.resetConfig();
+    getDataFromLocalStorageStub = sinon.stub(storage, 'getDataFromLocalStorage');
+  });
+
+  afterEach(function () {
+    getDataFromLocalStorageStub.restore();
+  });
+
   describe('haloSubmodule', function() {
     it('successfully instantiates', function () {
-		      expect(haloSubmodule.init()).to.equal(true);
+		  expect(haloSubmodule.init()).to.equal(true);
     });
   });
 
-  describe('Add Segment Data', function() {
-    it('adds segment data', function() {
-      const config = {
-        params: {
-          mapSegments: {
-            'appnexus': true,
-            'generic': true
-          }
-        }
+  describe('Add Real-Time Data', function() {
+    it('merges ortb2 data', function() {
+      let rtdConfig = {};
+      let bidConfig = {};
+
+      const setConfigUserObj1 = {
+        name: 'www.dataprovider1.com',
+        ext: { taxonomyname: 'iab_audience_taxonomy' },
+        segment: [{
+          id: '1776'
+        }]
       };
 
-      let adUnits = [
-        {
-          bids: [
-            // bid with existing segment data in bid obj and fpd
-            {
-              bidder: 'appnexus',
-              fpd: {
-                user: {
-                  data: [
-                    {
-                      id: 'appnexus',
-                      segment: [
-                        {
-                          id: '0'
-                        }
-                      ]
-                    }
-                  ]
-                }
-              },
-              params: {
-                user: {
-                  segments: [0]
-                }
-              }
-            }
-          ]
+      const setConfigUserObj2 = {
+        name: 'www.dataprovider2.com',
+        ext: { taxonomyname: 'iab_audience_taxonomy' },
+        segment: [{
+          id: '1914'
+        }]
+      };
+
+      const setConfigSiteObj1 = {
+        name: 'www.dataprovider3.com',
+        ext: {
+          taxonomyname: 'iab_audience_taxonomy'
         },
+        segment: [
+          {
+            id: '1812'
+          },
+          {
+            id: '1955'
+          }
+        ]
+      }
 
-        // bids with fpd data definitions but without existing segment data
-        {
-          bids: [
-            {
-              bidder: 'appnexus',
-              fpd: {
-                user: {
-                  data: [
-                    {
-                      id: 'appnexus'
-                    }
-                  ]
-                }
-              }
-            },
-            {
-              bidder: 'generic',
-              fpd: {
-                user: {
-                  data: [
-                    {
-                      id: 'generic'
-                    }
-                  ]
-                }
-              }
+      config.setConfig({
+        ortb2: {
+          user: {
+            data: [setConfigUserObj1, setConfigUserObj2]
+          },
+          site: {
+            content: {
+              data: [setConfigSiteObj1]
             }
-          ]
+          }
         }
-      ];
+      });
 
-      const data = {
-        appnexus: [{id: '1'}, {id: '2'}, {id: '3'}],
-        generic: [{id: 'seg1'}, {id: 'seg2'}, {id: 'seg3'}]
+      const rtdUserObj1 = {
+        name: 'www.dataprovider4.com',
+        ext: {
+          taxonomyname: 'iab_audience_taxonomy'
+        },
+        segment: [
+          {
+            id: '1918'
+          },
+          {
+            id: '1939'
+          }
+        ]
       };
 
-    	addSegmentData(adUnits, data, config);
+      const rtdSiteObj1 = {
+        name: 'www.dataprovider5.com',
+        ext: {
+          taxonomyname: 'iab_audience_taxonomy'
+        },
+        segment: [
+          {
+            id: '1945'
+          },
+          {
+            id: '2003'
+          }
+        ]
+      };
 
-      expect(adUnits[0].bids[0].fpd.user.data[0].segment[0]).to.have.deep.property('id', '0');
-      expect(adUnits[0].bids[0].fpd.user.data[0].segment[1]).to.have.deep.property('id', '1');
-      expect(adUnits[0].bids[0].fpd.user.data[0].segment[2]).to.have.deep.property('id', '2');
-      expect(adUnits[0].bids[0].fpd.user.data[0].segment[3]).to.have.deep.property('id', '3');
-      expect(adUnits[0].bids[0].params.user).to.have.deep.property('segments', [0, 1, 2, 3]);
+      const rtd = {
+        ortb2: {
+          user: {
+            data: [rtdUserObj1]
+          },
+          site: {
+            content: {
+              data: [rtdSiteObj1]
+            }
+          }
+        }
+      };
+
+      let pbConfig = config.getConfig();
+      addRealTimeData(bidConfig, rtd, rtdConfig);
 
-      expect(adUnits[1].bids[0].fpd.user.data[0].segment[0]).to.have.deep.property('id', '1');
-      expect(adUnits[1].bids[0].fpd.user.data[0].segment[1]).to.have.deep.property('id', '2');
-      expect(adUnits[1].bids[0].fpd.user.data[0].segment[2]).to.have.deep.property('id', '3');
-      expect(adUnits[1].bids[0].params.user).to.have.deep.property('segments', [1, 2, 3]);
+      let ortb2Config = config.getConfig().ortb2;
 
-      expect(adUnits[1].bids[1].fpd.user.data[0].segment[0]).to.have.deep.property('id', 'seg1');
-      expect(adUnits[1].bids[1].fpd.user.data[0].segment[1]).to.have.deep.property('id', 'seg2');
-      expect(adUnits[1].bids[1].fpd.user.data[0].segment[2]).to.have.deep.property('id', 'seg3');
-      expect(adUnits[1].bids[1].segments[0]).to.have.deep.property('id', 'seg1');
-      expect(adUnits[1].bids[1].segments[1]).to.have.deep.property('id', 'seg2');
-      expect(adUnits[1].bids[1].segments[2]).to.have.deep.property('id', 'seg3');
+      expect(ortb2Config.user.data).to.deep.include.members([setConfigUserObj1, setConfigUserObj2, rtdUserObj1]);
+      expect(ortb2Config.site.content.data).to.deep.include.members([setConfigSiteObj1, rtdSiteObj1]);
     });
 
-    it('allows mapper extensions and overrides', function() {
-      const config = {
+    it('allows publisher defined rtd ortb2 logic', function() {
+      const rtdConfig = {
         params: {
-          mapSegments: {
-            generic: (bid, segments) => {
-              bid.overrideSegments = segments;
-            },
-            newBidder: (bid, segments) => {
-              bid.newBidderSegments = segments;
+          handleRtd: function(bidConfig, rtd, rtdConfig, pbConfig) {
+            if (rtd.ortb2.user.data[0].segment[0].id == '1776') {
+              pbConfig.setConfig({ortb2: rtd.ortb2});
+            } else {
+              pbConfig.setConfig({ortb2: {}});
             }
           }
         }
       };
 
-      let adUnits = [
-        {
-          bids: [ {bidder: 'newBidder'}, {bidder: 'generic'} ]
+      let bidConfig = {};
+
+      const rtdUserObj1 = {
+        name: 'www.dataprovider.com',
+        ext: { taxonomyname: 'iab_audience_taxonomy' },
+        segment: [{
+          id: '1776'
+        }]
+      };
+
+      let rtd = {
+        ortb2: {
+          user: {
+            data: [rtdUserObj1]
+          }
         }
-      ];
+      };
 
-      const data = {
-        newBidder: [{id: 'nbseg1', name: 'New Bidder Segment 1'}, {id: 'nbseg2', name: 'New Bidder Segment 2'}, {id: 'nbseg3', name: 'New Bidder Segment 3'}],
-        generic: [{id: 'seg1'}, {id: 'seg2'}, {id: 'seg3'}]
+      config.resetConfig();
+
+      let pbConfig = config.getConfig();
+      addRealTimeData(bidConfig, rtd, rtdConfig);
+      expect(config.getConfig().ortb2.user.data).to.deep.include.members([rtdUserObj1]);
+
+      const rtdUserObj2 = {
+        name: 'www.audigent.com',
+        ext: {
+          segtax: '1',
+          taxprovider: '1'
+        },
+        segment: [{
+          id: 'pubseg1'
+        }]
       };
 
-      addSegmentData(adUnits, data, config);
+      rtd = {
+        ortb2: {
+          user: {
+            data: [rtdUserObj2]
+          }
+        }
+      };
 
-      expect(adUnits[0].bids[0].newBidderSegments[0]).to.have.deep.property('id', 'nbseg1');
-      expect(adUnits[0].bids[0].newBidderSegments[0]).to.have.deep.property('name', 'New Bidder Segment 1');
-      expect(adUnits[0].bids[0].newBidderSegments[1]).to.have.deep.property('id', 'nbseg2');
-      expect(adUnits[0].bids[0].newBidderSegments[1]).to.have.deep.property('name', 'New Bidder Segment 2');
-      expect(adUnits[0].bids[0].newBidderSegments[2]).to.have.deep.property('id', 'nbseg3');
-      expect(adUnits[0].bids[0].newBidderSegments[2]).to.have.deep.property('name', 'New Bidder Segment 3');
+      config.resetConfig();
 
-      expect(adUnits[0].bids[1].overrideSegments[0]).to.have.deep.property('id', 'seg1');
-      expect(adUnits[0].bids[1].overrideSegments[1]).to.have.deep.property('id', 'seg2');
-      expect(adUnits[0].bids[1].overrideSegments[2]).to.have.deep.property('id', 'seg3');
+      pbConfig = config.getConfig();
+      addRealTimeData(bidConfig, rtd, rtdConfig);
+      expect(config.getConfig().ortb2).to.deep.equal({});
     });
-  });
 
-  describe('Get Segments', function() {
-    it('gets segment data from local storage cache', function() {
-      const config = {
+    it('allows publisher defined adunit logic', function() {
+      const rtdConfig = {
         params: {
-          segmentCache: true,
-          mapSegments: {
-            'generic': true
+          handleRtd: function(bidConfig, rtd, rtdConfig, pbConfig) {
+            var adUnits = bidConfig.adUnits;
+            for (var i = 0; i < adUnits.length; i++) {
+              var adUnit = adUnits[i];
+              for (var j = 0; j < adUnit.bids.length; j++) {
+                var bid = adUnit.bids[j];
+                if (bid.bidder == 'adBuzz') {
+                  for (var k = 0; k < rtd.adBuzz.length; k++) {
+                    bid.adBuzzData.segments.adBuzz.push(rtd.adBuzz[k]);
+                  }
+                } else if (bid.bidder == 'trueBid') {
+                  for (var k = 0; k < rtd.trueBid.length; k++) {
+                    bid.trueBidSegments.push(rtd.trueBid[k]);
+                  }
+                }
+              }
+            }
           }
         }
       };
 
-      let reqBidsConfigObj = {
+      let bidConfig = {
         adUnits: [
           {
-            bids: [{bidder: 'generic'}]
+            bids: [
+              {
+                bidder: 'adBuzz',
+                adBuzzData: {
+                  segments: {
+                    adBuzz: [
+                      {
+                        id: 'adBuzzSeg1'
+                      }
+                    ]
+                  }
+                }
+              },
+              {
+                bidder: 'trueBid',
+                trueBidSegments: []
+              }
+            ]
           }
         ]
       };
 
-      const data = {
-        audigent_segments: {
-          generic: [{id: 'seg1'}]
+      const rtd = {
+        adBuzz: [{id: 'adBuzzSeg2'}, {id: 'adBuzzSeg3'}],
+        trueBid: [{id: 'truebidSeg1'}, {id: 'truebidSeg2'}, {id: 'truebidSeg3'}]
+      };
+
+      addRealTimeData(bidConfig, rtd, rtdConfig);
+
+      expect(bidConfig.adUnits[0].bids[0].adBuzzData.segments.adBuzz[0].id).to.equal('adBuzzSeg1');
+      expect(bidConfig.adUnits[0].bids[0].adBuzzData.segments.adBuzz[1].id).to.equal('adBuzzSeg2');
+      expect(bidConfig.adUnits[0].bids[0].adBuzzData.segments.adBuzz[2].id).to.equal('adBuzzSeg3');
+      expect(bidConfig.adUnits[0].bids[1].trueBidSegments[0].id).to.equal('truebidSeg1');
+      expect(bidConfig.adUnits[0].bids[1].trueBidSegments[1].id).to.equal('truebidSeg2');
+      expect(bidConfig.adUnits[0].bids[1].trueBidSegments[2].id).to.equal('truebidSeg3');
+    });
+  });
+
+  describe('Get Real-Time Data', function() {
+    it('gets rtd from local storage cache', function() {
+      const rtdConfig = {
+        params: {
+          segmentCache: true
         }
       };
 
-      storage.setDataInLocalStorage(SEG_LOCAL_NAME, JSON.stringify(data));
+      const bidConfig = {};
 
-      getSegments(reqBidsConfigObj, () => {}, config, {});
+      const rtdUserObj1 = {
+        name: 'www.dataprovider3.com',
+        ext: {
+          taxonomyname: 'iab_audience_taxonomy'
+        },
+        segment: [
+          {
+            id: '1918'
+          },
+          {
+            id: '1939'
+          }
+        ]
+      };
 
-      expect(reqBidsConfigObj.adUnits[0].bids[0].segments[0]).to.have.deep.property('id', 'seg1');
+      const cachedRtd = {
+        rtd: {
+          ortb2: {
+            user: {
+              data: [rtdUserObj1]
+            }
+          }
+        }
+      };
+
+      getDataFromLocalStorageStub.withArgs(RTD_LOCAL_NAME).returns(JSON.stringify(cachedRtd));
+
+      expect(config.getConfig().ortb2).to.be.undefined;
+      getRealTimeData(bidConfig, () => {}, rtdConfig, {});
+      expect(config.getConfig().ortb2.user.data).to.deep.include.members([rtdUserObj1]);
     });
 
-    it('gets segment data via async request', function() {
-      const config = {
+    it('gets real-time data via async request', function() {
+      const setConfigSiteObj1 = {
+        name: 'www.audigent.com',
+        ext: {
+          segtax: '1',
+          taxprovider: '1'
+        },
+        segment: [
+          {
+            id: 'pubseg1'
+          },
+          {
+            id: 'pubseg2'
+          }
+        ]
+      }
+
+      config.setConfig({
+        ortb2: {
+          site: {
+            content: {
+              data: [setConfigSiteObj1]
+            }
+          }
+        }
+      });
+
+      const rtdConfig = {
         params: {
           segmentCache: false,
-          mapSegments: {
-            'generic': true
-          },
+          usePubHalo: true,
           requestParams: {
-            'publisherId': 1234
+            publisherId: 'testPub1'
           }
         }
       };
 
-      let reqBidsConfigObj = {
-        adUnits: [
+      let bidConfig = {};
+
+      const rtdUserObj1 = {
+        name: 'www.audigent.com',
+        ext: {
+          segtax: '1',
+          taxprovider: '1'
+        },
+        segment: [
+          {
+            id: 'pubseg1'
+          },
           {
-            bids: [{bidder: 'generic'}]
+            id: 'pubseg2'
           }
         ]
       };
+
       const data = {
-        audigent_segments: {
-          generic: [{id: 'seg1'}]
+        rtd: {
+          ortb2: {
+            user: {
+              data: [rtdUserObj1]
+            }
+          }
         }
       };
 
-      storage.setDataInLocalStorage(HALOID_LOCAL_NAME, 'haloid');
-      getSegments(reqBidsConfigObj, () => {}, config, {});
+      getDataFromLocalStorageStub.withArgs(HALOID_LOCAL_NAME).returns('testHaloId1');
+      getRealTimeData(bidConfig, () => {}, rtdConfig, {});
 
       let request = server.requests[0];
       let postData = JSON.parse(request.requestBody);
-      expect(postData.config).to.have.deep.property('publisherId', 1234);
+      expect(postData.config).to.have.deep.property('publisherId', 'testPub1');
+      expect(postData.userIds).to.have.deep.property('haloId', 'testHaloId1');
 
       request.respond(200, responseHeader, JSON.stringify(data));
 
-      expect(reqBidsConfigObj.adUnits[0].bids[0].segments[0]).to.have.deep.property('id', 'seg1');
+      expect(config.getConfig().ortb2.user.data).to.deep.include.members([rtdUserObj1]);
     });
   });
 });
