implement dynamic identify timestamps

Author: khushi1033

src/identityApiClient.ts

@@ -193,6 +193,11 @@ export default function IdentityAPIClient(
         mpid: MPID,
         knownIdentities: UserIdentities
     ) {
+        // START
+        const requestCounter = mpInstance._Store.getAndIncrementIdentityRequestCounter();
+        const startTimestamp = new Date().getTime();
+        const startEventType = `identity${requestCounter}RequestStart`;
+        mpInstance._TimingEventsClient.sendTimingEvent(startEventType, startTimestamp);
         const { invokeCallback } = mpInstance._Helpers;
         const { Logger } = mpInstance;
         Logger.verbose(Messages.InformationMessages.SendIdentityBegin);
@@ -289,6 +294,16 @@ export default function IdentityAPIClient(
             mpInstance._Store.identityCallInFlight = false;
 
             Logger.verbose(message);
+            
+            // END
+            const requestNumber = mpInstance._Store.currentIdentityRequestNumber;
+            if (requestNumber !== null) {
+                const endTimestamp = new Date().getTime();
+                const endEventType = `identity${requestNumber}RequestEnd`;
+                mpInstance._TimingEventsClient.sendTimingEvent(endEventType, endTimestamp);
+                mpInstance._Store.currentIdentityRequestNumber = null;
+            }
+            
             parseIdentityResponse(
                 identityResponse,
                 previousMPID,
@@ -301,6 +316,15 @@ export default function IdentityAPIClient(
         } catch (err) {
             mpInstance._Store.identityCallInFlight = false;
 
+            // END
+            const requestNumber = mpInstance._Store.currentIdentityRequestNumber;
+            if (requestNumber !== null) {
+                const endTimestamp = new Date().getTime();
+                const endEventType = `identity${requestNumber}RequestEnd`;
+                mpInstance._TimingEventsClient.sendTimingEvent(endEventType, endTimestamp);
+                mpInstance._Store.currentIdentityRequestNumber = null;
+            }
+            
             const errorMessage = (err as Error).message || err.toString();
 
             Logger.error('Error sending identity request to servers' + ' - ' + errorMessage);

src/mp-instance.ts

@@ -36,6 +36,7 @@ import Consent, { IConsent } from './consent';
 import KitBlocker from './kitBlocking';
 import ConfigAPIClient, { IKitConfigs } from './configAPIClient';
 import IdentityAPIClient from './identityApiClient';
+import TimingEventsClient, { ITimingEventsClient } from './timingEventsClient';
 import { isFunction, parseConfig, valueof, generateDeprecationMessage } from './utils';
 import { LocalStorageVault } from './vault';
 import { removeExpiredIdentityCacheDates } from './identity-utils';
@@ -80,6 +81,7 @@ export interface IMParticleWebSDKInstance extends MParticleWebSDK {
     _Helpers: SDKHelpersApi;
     _Identity: IIdentity;
     _IdentityAPIClient: typeof IdentityAPIClient;
+    _TimingEventsClient: ITimingEventsClient;
     _IntegrationCapture: IntegrationCapture;
     _NativeSdkHelpers: INativeSdkHelpers;
     _Persistence: IPersistence;
@@ -127,6 +129,7 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
     this._ForwardingStatsUploader = new ForwardingStatsUploader(this);
     this._Consent = new Consent(this);
     this._IdentityAPIClient = new IdentityAPIClient(this);
+    this._TimingEventsClient = new TimingEventsClient(this);
     this._preInit = {
         readyQueue: [],
         integrationDelays: {},
@@ -158,6 +161,7 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         }
     }
     this.init = function(apiKey, config) {
+        console.log("woohoo");
         if (!config) {
             console.warn(
                 'You did not pass a config object to init(). mParticle will not initialize properly'

src/store.ts

@@ -182,6 +182,8 @@ export interface IStore {
     context: Context | null;
     configurationLoaded: boolean;
     identityCallInFlight: boolean;
+    identityRequestCounter: number; 
+    currentIdentityRequestNumber: number | null; 
     SDKConfig: Partial<SDKConfig>;
     nonCurrentUserMPIDs: Record<MPID, Dictionary>;
     identifyCalled: boolean;
@@ -225,6 +227,7 @@ export interface IStore {
     addMpidToSessionHistory?(mpid: MPID, previousMpid?: MPID): void;
     hasInvalidIdentifyRequest?: () => boolean;
     nullifySession?: () => void;
+    getAndIncrementIdentityRequestCounter?: () => number;
     processConfig(config: SDKInitConfig): void;
     syncPersistenceData?: () => void;
 }
@@ -266,6 +269,8 @@ export default function Store(
         context: null,
         configurationLoaded: false,
         identityCallInFlight: false,
+        identityRequestCounter: 0,
+        currentIdentityRequestNumber: null,
         SDKConfig: {},
         nonCurrentUserMPIDs: {},
         identifyCalled: false,
@@ -682,13 +687,23 @@ export default function Store(
 
     this.nullifySession = (): void => {
         this.sessionId = null;
+        this.identityRequestCounter = 0;
+        this.currentIdentityRequestNumber = null;
         this.dateLastEventSent = null;
         this.sessionStartDate = null;
         this.sessionAttributes = {};
         this.localSessionAttributes = {};
         mpInstance._Persistence.update();
     };
 
+    this.getAndIncrementIdentityRequestCounter = (): number => {
+        if (this.identityRequestCounter < 99) {
+            this.identityRequestCounter++;
+        }
+        this.currentIdentityRequestNumber = this.identityRequestCounter;
+        return this.identityRequestCounter;
+    };
+
     this.processConfig = (config: SDKInitConfig) => {
         const { workspaceToken, requiredWebviewBridgeName } = config;
 

src/timingEventsClient.ts

@@ -0,0 +1,127 @@
+import { AsyncUploader, FetchUploader, XHRUploader, IFetchPayload } from './uploaders';
+import { IMParticleWebSDKInstance } from './mp-instance';
+import Constants from './constants';
+
+interface TimingEventsRequestPayload extends IFetchPayload {
+    headers: {
+        Accept: string;
+        'Content-Type': string;
+        [key: string]: string;
+    };
+}
+
+interface TimingEventsRequestBody {
+    timingMetrics: Array<{
+        name: string;
+        value: number;
+    }>;
+}
+
+export interface ITimingEventsClient {
+    sendTimingEvent: (eventType: string, timestamp: number) => Promise<void>;
+}
+
+export default function TimingEventsClient(
+    this: ITimingEventsClient,
+    mpInstance: IMParticleWebSDKInstance
+) {
+    const launcherInstanceGuidKey = Constants.Rokt.LauncherInstanceGuidKey;
+
+    const getLauncherInstanceGuid = (): string | undefined => {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        if (window[launcherInstanceGuidKey] && typeof window[launcherInstanceGuidKey] === 'string') {
+            return window[launcherInstanceGuidKey];
+        }
+        return undefined;
+    };
+
+    const getRoktTraceId = (): string | undefined => {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        const roktTraceIdKey = '__rokt_trace_id__';
+        if (window[roktTraceIdKey] && typeof window[roktTraceIdKey] === 'string') {
+            return window[roktTraceIdKey];
+        }
+        return undefined;
+    };
+
+    this.sendTimingEvent = async function(eventType: string, timestamp: number): Promise<void> {
+        if (!mpInstance._Store) {
+            return;
+        }
+
+        const launcherInstanceGuid = getLauncherInstanceGuid();
+        if (!launcherInstanceGuid) {
+            return;
+        }
+
+        const roktTraceId = getRoktTraceId();
+        if (!roktTraceId) {
+            return;
+        }
+
+        const { sessionId } = mpInstance._Store;
+
+        const headers: Record<string, string> = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        };
+
+        headers['rokt-launcher-instance-guid'] = launcherInstanceGuid;
+        headers['x-rokt-trace-id'] = roktTraceId;
+
+        if (sessionId) {
+            headers['rokt-session-id'] = sessionId;
+        }
+
+        if (Constants.sdkVersion) {
+            headers['rokt-sdk-version'] = Constants.sdkVersion;
+        }
+
+        headers['rokt-sdk-framework-type'] = 'integration-launcher';
+        headers['rokt-integration-type'] = 'wsdk';
+
+        if (mpInstance._Store.context) {
+            const context = mpInstance._Store.context as any;
+            if (context.partnerId) {
+                headers['rokt-tag-id'] = String(context.partnerId);
+            }
+            if (context.pageId) {
+                headers['rokt-page-id'] = context.pageId;
+            }
+            if (context.pageInstanceGuid) {
+                headers['rokt-page-instance-guid'] = context.pageInstanceGuid;
+            }
+        }
+
+        const timingMetricsBody: TimingEventsRequestBody = {
+            timingMetrics: [
+                {
+                    name: eventType,
+                    value: timestamp,
+                },
+            ],
+        };
+
+        
+        const uploadUrl = `/v1/timings/events`;
+
+        const uploader: AsyncUploader = (typeof window !== 'undefined' && window.fetch)
+            ? new FetchUploader(uploadUrl)
+            : new XHRUploader(uploadUrl);
+
+        const fetchPayload: TimingEventsRequestPayload = {
+            method: 'post',
+            headers: headers as TimingEventsRequestPayload['headers'],
+            body: JSON.stringify(timingMetricsBody),
+        };
+
+        try {
+            await uploader.upload(fetchPayload);
+        } catch (err) {
+        }
+    };
+}