@highfivve/ad-tag 5.8.18 → 5.8.21

package/lib/ads/modules/moli-analytics/eventTracker.js

@@ -0,0 +1,43 @@
+export const createEventTracker = (url, batchSize, batchDelay, logger) => {
+    let batch = [];
+    let timer = null;
+    const processBatch = () => {
+        const currentBatch = batch;
+        batch = [];
+        fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ events: currentBatch })
+        })
+            .then(response => {
+            if (response.ok) {
+                logger?.debug(`moli-analytics: Successfully sent analytics batch of ${currentBatch.length} events`);
+            }
+            else {
+                logger?.error(`moli-analytics: Failed to send analytics batch: ${response.statusText}`);
+            }
+        })
+            .catch(error => {
+            logger?.error(`moli-analytics: Failed to send analytics batch: ${error}`);
+        });
+    };
+    const track = (event) => {
+        logger?.debug('moli-analytics: event', event);
+        batch.push(event);
+        if (timer != null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        if (batch.length >= batchSize) {
+            processBatch();
+        }
+        else {
+            timer = setTimeout(processBatch, batchDelay);
+        }
+    };
+    return {
+        track
+    };
+};

package/lib/ads/modules/moli-analytics/events/gptSlotRenderEnded.js

@@ -0,0 +1,21 @@
+export const mapGPTSlotRenderEnded = (event, context, adContext) => {
+    const timestamp = Date.now();
+    return {
+        v: 1,
+        type: 'gpt.slotRenderEnded',
+        publisher: context.publisher,
+        pageViewId: context.pageViewId,
+        userId: adContext.window__.pbjs.getUserIds().pubcid,
+        timestamp,
+        analyticsLabels: context.analyticsLabels,
+        data: {
+            auctionId: context.auctionId,
+            gpid: context.gpid,
+            adUnitPath: event.slot.getAdUnitPath(),
+            adUnitName: context.adUnitName,
+            adUnitCode: event.slot.getSlotElementId(),
+            size: Array.isArray(event.size) ? event.size.join('x') : event.size,
+            isEmpty: event.isEmpty
+        }
+    };
+};

package/lib/ads/modules/moli-analytics/events/index.js

@@ -0,0 +1,16 @@
+import { mapPrebidAuctionEnd } from 'ad-tag/ads/modules/moli-analytics/events/prebidAuctionEnd';
+import { mapPrebidBidWon } from 'ad-tag/ads/modules/moli-analytics/events/prebidBidWon';
+import { mapGPTSlotRenderEnded } from 'ad-tag/ads/modules/moli-analytics/events/gptSlotRenderEnded';
+import { mapPageView } from 'ad-tag/ads/modules/moli-analytics/events/pageView';
+export const eventMapper = {
+    prebid: {
+        auctionEnd: mapPrebidAuctionEnd,
+        bidWon: mapPrebidBidWon
+    },
+    gpt: {
+        slotRenderEnded: mapGPTSlotRenderEnded
+    },
+    page: {
+        view: mapPageView
+    }
+};

package/lib/ads/modules/moli-analytics/events/pageView.js

@@ -0,0 +1,31 @@
+const parseUTM = (search) => {
+    const params = new URLSearchParams(search);
+    const v = (k) => params.get(k) || null;
+    return {
+        source: v('utm_source'),
+        medium: v('utm_medium'),
+        campaign: v('utm_campaign'),
+        content: v('utm_content'),
+        term: v('utm_term')
+    };
+};
+export const mapPageView = (context, adContext) => {
+    const timestamp = Date.now();
+    const userIds = adContext.window__.pbjs.getUserIds ? adContext.window__.pbjs.getUserIds() : {};
+    return {
+        v: 1,
+        type: 'page.view',
+        publisher: context.publisher,
+        pageViewId: context.pageViewId,
+        userId: userIds?.pubcid,
+        timestamp,
+        analyticsLabels: context.analyticsLabels,
+        data: {
+            sessionId: context.session.getId(),
+            device: adContext.labelConfigService__.getDeviceLabel(),
+            domain: adContext.window__.moli.resolveAdUnitPath('{domain}'),
+            ua: adContext.window__.navigator.userAgent,
+            utm: parseUTM(adContext.window__.location.search)
+        }
+    };
+};

package/lib/ads/modules/moli-analytics/events/prebidAuctionEnd.js

@@ -0,0 +1,39 @@
+export const mapPrebidAuctionEnd = (event, context, adContext) => {
+    const timestamp = Date.now();
+    return {
+        v: 1,
+        type: 'prebid.auctionEnd',
+        publisher: context.publisher,
+        pageViewId: context.pageViewId,
+        userId: adContext.window__.pbjs.getUserIds().pubcid,
+        timestamp,
+        analyticsLabels: context.analyticsLabels,
+        data: {
+            auctionId: event.auctionId,
+            adUnits: Array.from(new Map((event.adUnits || []).map(adUnit => [
+                adUnit.code,
+                {
+                    code: adUnit.code,
+                    adUnitName: adUnit.pubstack?.adUnitName || adUnit.code,
+                    gpid: adUnit.ortb2Imp?.ext?.gpid
+                }
+            ])).values()),
+            bidderRequests: (event.bidderRequests || []).map(request => {
+                return {
+                    bidderCode: request.bidderCode,
+                    bids: (request.bids || []).map(bid => ({
+                        adUnitCode: bid.adUnitCode
+                    }))
+                };
+            }),
+            bidsReceived: (event.bidsReceived || []).map(bid => ({
+                bidder: bid.bidder,
+                adUnitCode: bid.adUnitCode,
+                size: bid.size,
+                currency: bid.currency,
+                cpm: bid.cpm,
+                timeToRespond: bid.timeToRespond
+            }))
+        }
+    };
+};

package/lib/ads/modules/moli-analytics/events/prebidBidWon.js

@@ -0,0 +1,23 @@
+export const mapPrebidBidWon = (event, context, adContext) => {
+    const timestamp = Date.now();
+    return {
+        v: 1,
+        type: 'prebid.bidWon',
+        publisher: context.publisher,
+        pageViewId: context.pageViewId,
+        userId: adContext.window__.pbjs.getUserIds().pubcid,
+        timestamp,
+        analyticsLabels: context.analyticsLabels,
+        data: {
+            auctionId: event.auctionId,
+            gpid: context.gpid,
+            bidderCode: event.bidderCode,
+            adUnitCode: event.adUnitCode,
+            size: event.size,
+            currency: event.currency,
+            cpm: event.cpm,
+            status: event.status,
+            timeToRespond: event.timeToRespond
+        }
+    };
+};

package/lib/ads/modules/moli-analytics/index.js

@@ -0,0 +1,161 @@
+import { mkInitStep } from 'ad-tag/ads/adPipeline';
+import { uuidV4 } from 'ad-tag/util/uuid';
+import { createSession } from 'ad-tag/ads/modules/moli-analytics/session';
+import { createEventTracker } from 'ad-tag/ads/modules/moli-analytics/eventTracker';
+import { eventMapper } from 'ad-tag/ads/modules/moli-analytics/events';
+import { extractPubstackAbTestCohort } from '../pubstack/abTest';
+const SESSION_TTL_MIN = 30;
+export const DEFAULT_CONFIG = {
+    batchSize: 4,
+    batchDelay: 1000
+};
+export const MoliAnalytics = () => {
+    let config;
+    let eventContext;
+    let eventTracker;
+    let adUnitsMap = new Map();
+    const generatePageViewId = (adPipelineContext) => `pv-${uuidV4(adPipelineContext.window__)}`;
+    const handleAuctionEnd = (event, adPipelineContext) => {
+        const auctionEnd = eventMapper.prebid.auctionEnd(event, eventContext, adPipelineContext);
+        for (const adUnit of auctionEnd.data.adUnits) {
+            adUnitsMap.set(adUnit.code, {
+                auctionId: auctionEnd.data.auctionId,
+                adUnitName: adUnit.adUnitName,
+                gpid: adUnit.gpid
+            });
+        }
+        eventTracker.track(auctionEnd);
+    };
+    const handleBidWon = (event, adPipelineContext) => {
+        const adUnitData = adUnitsMap.get(event.adUnitCode);
+        eventTracker.track(eventMapper.prebid.bidWon(event, {
+            ...eventContext,
+            gpid: adUnitData?.gpid || ''
+        }, adPipelineContext));
+    };
+    const handleSlotRenderEnded = (event, adPipelineContext) => {
+        const adUnitCode = event.slot.getSlotElementId();
+        const adUnitData = adUnitsMap.get(adUnitCode);
+        eventTracker.track(eventMapper.gpt.slotRenderEnded(event, {
+            ...eventContext,
+            auctionId: adUnitData?.auctionId || '',
+            adUnitName: adUnitData?.adUnitName || adUnitCode,
+            gpid: adUnitData?.gpid || ''
+        }, adPipelineContext));
+    };
+    const handlePageView = (adPipelineContext) => {
+        eventContext.pageViewId = generatePageViewId(adPipelineContext);
+        eventTracker.track(eventMapper.page.view(eventContext, adPipelineContext));
+    };
+    const configValid = (config, logger) => {
+        if (!config) {
+            logger.error('moli-analytics: not configured');
+            return false;
+        }
+        if (!config.publisher) {
+            logger.error('moli-analytics: publisher is required');
+            return false;
+        }
+        if (!config.url) {
+            logger.error('moli-analytics: url is required');
+            return false;
+        }
+        if (!config.batchSize || config.batchSize < 1) {
+            logger.error('moli-analytics: batchSize must be greater than 0');
+            return false;
+        }
+        if (!config.batchDelay || config.batchDelay < 1) {
+            logger.error('moli-analytics: batchDelay must be greater than 0');
+            return false;
+        }
+        return true;
+    };
+    const initMoliAnalytics = async (adPipelineContext) => {
+        if (!configValid(config, adPipelineContext.logger__)) {
+            return Promise.reject('failed to initialize moli analytics: invalid configuration');
+        }
+        eventContext = {
+            publisher: config.publisher,
+            session: createSession(adPipelineContext.window__, SESSION_TTL_MIN),
+            pageViewId: generatePageViewId(adPipelineContext),
+            analyticsLabels: null
+        };
+        eventTracker = createEventTracker(config.url, config.batchSize, config.batchDelay, adPipelineContext.logger__);
+        if (adPipelineContext.config__.configVersion?.identifier ||
+            adPipelineContext.config__.configVersion?.versionVariant) {
+            eventContext.analyticsLabels = {
+                ab_test: adPipelineContext.config__.configVersion?.identifier || null,
+                variant: adPipelineContext.config__.configVersion?.versionVariant || null
+            };
+        }
+        if (adPipelineContext.config__.spa?.enabled) {
+            adPipelineContext.window__.moli.addEventListener('afterRequestAds', event => {
+                if (event.state === 'spa-finished' || event.state === 'finished') {
+                    handlePageView(adPipelineContext);
+                }
+            });
+        }
+        const setupPrebid = async () => {
+            if (typeof adPipelineContext.window__.pbjs.getUserIdsAsync === 'function') {
+                await adPipelineContext.window__.pbjs.getUserIdsAsync();
+            }
+            handlePageView(adPipelineContext);
+            adPipelineContext.window__.pbjs.onEvent('auctionEnd', (event) => handleAuctionEnd(event, adPipelineContext));
+            adPipelineContext.window__.pbjs.onEvent('bidWon', (event) => handleBidWon(event, adPipelineContext));
+        };
+        if (typeof adPipelineContext.window__.pbjs.onEvent === 'function') {
+            await setupPrebid();
+        }
+        else {
+            adPipelineContext.window__.pbjs.que.push(setupPrebid);
+        }
+        const setupGPT = () => {
+            adPipelineContext.window__.googletag
+                .pubads()
+                .addEventListener('slotRenderEnded', (event) => handleSlotRenderEnded(event, adPipelineContext));
+        };
+        if (typeof adPipelineContext.window__.googletag.pubads === 'function') {
+            setupGPT();
+        }
+        else {
+            adPipelineContext.window__.googletag.cmd.push(setupGPT);
+        }
+        return Promise.resolve();
+    };
+    const setAnalyticsLabels = (ctx) => {
+        const pubstackAbTestCohort = extractPubstackAbTestCohort(ctx);
+        const moliConfigVariant = ctx.config__.configVersion?.versionVariant;
+        ctx.window__.pbjs.que.push(() => ctx.window__.pbjs.mergeConfig({
+            analyticsLabels: {
+                pubstackAbCohort: pubstackAbTestCohort,
+                configVariant: moliConfigVariant
+            }
+        }));
+        return Promise.resolve();
+    };
+    return {
+        name: 'moli-analytics',
+        description: 'ad events tracking and analytics module',
+        moduleType: 'reporting',
+        config__() {
+            return config;
+        },
+        configure__(moduleConfig) {
+            if (moduleConfig?.moliAnalytics?.enabled) {
+                config = { ...DEFAULT_CONFIG, ...moduleConfig.moliAnalytics };
+            }
+        },
+        configureSteps__() {
+            return [];
+        },
+        initSteps__() {
+            return [
+                mkInitStep('moli-analytics-init', (context) => initMoliAnalytics(context)),
+                mkInitStep('set-analytics-labels', (context) => setAnalyticsLabels(context))
+            ];
+        },
+        prepareRequestAdsSteps__() {
+            return [];
+        }
+    };
+};

package/lib/ads/modules/moli-analytics/session.js

@@ -0,0 +1,60 @@
+import { UserActivityService } from 'ad-tag/ads/modules/ad-reload/userActivityService';
+import { BrowserStorageKeys } from 'ad-tag/util/browserStorageKeys';
+import { uuidV4 } from 'ad-tag/util/uuid';
+export const createSession = (window, ttl) => {
+    const userActivityService = new UserActivityService(window, {
+        level: 'strict'
+    });
+    const ttlMs = ttl * 60000;
+    const loadJSON = (k, d = null) => {
+        try {
+            return JSON.parse(window.localStorage.getItem(k) || '') ?? d;
+        }
+        catch {
+            return d;
+        }
+    };
+    const saveJSON = (k, v) => window.localStorage.setItem(k, JSON.stringify(v));
+    const getSession = () => {
+        const now = Date.now();
+        let session = loadJSON(BrowserStorageKeys.molyAnalyticsSession);
+        if (!session || !session.id || !session.createdAt || !session.lastActivityAt) {
+            session = createSession();
+        }
+        else {
+            const idleMs = now - session.lastActivityAt;
+            const isIdle = idleMs > ttlMs;
+            if (isIdle) {
+                session = createSession();
+            }
+        }
+        return session;
+    };
+    const createSession = () => {
+        const now = Date.now();
+        const session = {
+            id: `sess-${uuidV4(window)}`,
+            createdAt: now,
+            lastActivityAt: now
+        };
+        saveJSON(BrowserStorageKeys.molyAnalyticsSession, session);
+        return session;
+    };
+    const touchSession = () => {
+        const session = getSession();
+        session.lastActivityAt = Date.now();
+        saveJSON(BrowserStorageKeys.molyAnalyticsSession, session);
+    };
+    const getId = () => {
+        return getSession().id;
+    };
+    userActivityService.addUserActivityChangedListener((isActive) => {
+        if (isActive) {
+            touchSession();
+        }
+    });
+    getSession();
+    return {
+        getId
+    };
+};

package/lib/ads/modules/moli-analytics/types.js

@@ -0,0 +1 @@
+export {};

package/lib/ads/modules/pubstack/abTest.js

@@ -0,0 +1,11 @@
+export const extractPubstackAbTestCohort = (ctx) => {
+    const pubstackABTestValues = ['0', '1', '2', '3'];
+    if (ctx.env__ === 'test') {
+        return null;
+    }
+    const meta = ctx.window__.document.head.querySelector('meta[name="pbstck_context:pbstck_ab_test"]');
+    if (meta && meta.content && pubstackABTestValues.includes(meta.content)) {
+        return meta.content;
+    }
+    return null;
+};

package/lib/ads/modules/pubstack/index.js

@@ -1,5 +1,6 @@
 import { AssetLoadMethod } from 'ad-tag/util/assetLoaderService';
 import { mkConfigureStep, mkInitStep } from '../../adPipeline';
+import { extractPubstackAbTestCohort } from './abTest';
 export const createPubstack = () => {
     const name = 'pubstack';
     let pubstackConfig = null;
@@ -37,10 +38,9 @@ export const createPubstack = () => {
                     if (ctx.env__ === 'test') {
                         return Promise.resolve();
                     }
-                    const validABTestValues = ['0', '1', '2', '3'];
-                    const meta = ctx.window__.document.head.querySelector('meta[name="pbstck_context:pbstck_ab_test"]');
-                    if (meta && meta.content && validABTestValues.includes(meta.content)) {
-                        ctx.window__.googletag.pubads().setTargeting('pbstck_ab_test', meta.content);
+                    const pubstackAbTestCohort = extractPubstackAbTestCohort(ctx);
+                    if (pubstackAbTestCohort) {
+                        ctx.window__.googletag.pubads().setTargeting('pbstck_ab_test', pubstackAbTestCohort);
                     }
                     return Promise.resolve();
                 })

package/lib/bundle/moliAnalytics.js

@@ -0,0 +1,2 @@
+import { MoliAnalytics } from 'ad-tag/ads/modules/moli-analytics';
+window.moli.registerModule(MoliAnalytics());

package/lib/gen/packageJson.js

@@ -1,3 +1,3 @@
 export const packageJson = {
-    version: '5.8.18'
+    version: '5.8.21'
 };

package/lib/types/prebidjs.js

@@ -21,6 +21,7 @@ export var prebidjs;
     prebidjs.Pubstack = 'pubstack';
     prebidjs.Ogury = 'ogury';
     prebidjs.OneTag = 'onetag';
+    prebidjs.Oms = 'oms';
     prebidjs.OpenX = 'openx';
     prebidjs.SmartAdServer = 'smartadserver';
     prebidjs.Smartx = 'smartx';

package/lib/util/browserStorageKeys.js

@@ -2,6 +2,7 @@ export const BrowserStorageKeys = {
     moliEnv: 'moli-env',
     moliPubCode: 'moli-pub-code',
     moliVersion: 'moli-version',
+    molyAnalyticsSession: 'moli-analytics-session',
     testSlotSize: (id) => `moli-test-slot-size-${id}`,
     debugDelay: 'moli-debug-delay',
     abTest: 'moli-ab-test'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highfivve/ad-tag",
-  "version": "5.8.18",
+  "version": "5.8.21",
   "license": "Apache-2.0",
   "description": "An ad tag implementation called moli",
   "main": "./lib/index.js",