chore: Only set credentials for sampled sessions (#487)

Author: limhjgrace

src/event-cache/EventCache.ts

@@ -80,6 +80,13 @@ export class EventCache {
         }
     };
 
+    /**
+     * Returns true if the session is sampled, false otherwise.
+     */
+    public isSessionSampled(): boolean {
+        return this.sessionManager.isSampled();
+    }
+
     /**
      * Add an event to the cache and reset the session timer.
      *

src/event-cache/__tests__/EventCache.integ.test.ts

@@ -116,4 +116,31 @@ describe('EventCache tests', () => {
             expect(JSON.parse(event.metadata)).toMatchObject(expectedMetaData);
         });
     });
+
+    test('when a session is not sampled then return false', async () => {
+        // Init
+        const config = {
+            ...DEFAULT_CONFIG,
+            ...{
+                sessionSampleRate: 0
+            }
+        };
+
+        const eventCache: EventCache = Utils.createEventCache(config);
+
+        // Assert
+        expect(eventCache.isSessionSampled()).toBeFalsy();
+    });
+
+    test('when a session is sampled then return true', async () => {
+        // Init
+        const config = {
+            ...DEFAULT_CONFIG
+        };
+
+        const eventCache: EventCache = Utils.createEventCache(config);
+
+        // Assert
+        expect(eventCache.isSessionSampled()).toBeTruthy();
+    });
 });

src/event-cache/__tests__/EventCache.test.ts

@@ -18,13 +18,16 @@ const getUserId = jest.fn(() => 'b');
 const getAttributes = jest.fn();
 const incrementSessionEventCount = jest.fn();
 const addSessionAttributes = jest.fn();
+let samplingDecision = true;
+const isSampled = jest.fn().mockImplementation(() => samplingDecision);
 jest.mock('../../sessions/SessionManager', () => ({
     SessionManager: jest.fn().mockImplementation(() => ({
         getSession,
         getUserId,
         getAttributes,
         incrementSessionEventCount,
-        addSessionAttributes
+        addSessionAttributes,
+        isSampled
     }))
 }));
 
@@ -408,6 +411,41 @@ describe('EventCache tests', () => {
         expect(eventBatch).toEqual(expect.arrayContaining(expectedEvents));
     });
 
+    test('when a session is not sampled then return false', async () => {
+        // Init
+        samplingDecision = false;
+
+        const config = {
+            ...DEFAULT_CONFIG,
+            ...{
+                sessionSampleRate: 0
+            }
+        };
+
+        const eventCache: EventCache = Utils.createEventCache(config);
+
+        // Assert
+        expect(eventCache.isSessionSampled()).toBeFalsy();
+
+        // Reset
+        samplingDecision = true;
+    });
+
+    test('when a session is sampled then return true', async () => {
+        // Init
+        const config = {
+            ...DEFAULT_CONFIG,
+            ...{
+                sessionSampleRate: 1
+            }
+        };
+
+        const eventCache: EventCache = Utils.createEventCache(config);
+
+        // Assert
+        expect(eventCache.isSessionSampled()).toBeTruthy();
+    });
+
     test('when session.record is false then event is not recorded', async () => {
         // Init
         const getSession = jest.fn(() => ({ sessionId: 'a', record: true }));

src/orchestration/Orchestration.ts

@@ -415,6 +415,13 @@ export class Orchestration {
             this.config
         );
 
+        // Only retrieves and sets credentials if the session is sampled.
+        // The nil session created during initialization will have the same sampling decision as
+        // the new session created when the first event is recorded.
+        if (!this.eventCache.isSessionSampled()) {
+            return dispatch;
+        }
+
         if (this.config.identityPoolId && this.config.guestRoleArn) {
             dispatch.setAwsCredentials(
                 new Authentication(this.config)

src/orchestration/__tests__/Orchestration.test.ts

@@ -13,11 +13,13 @@ global.fetch = jest.fn();
 
 const enableDispatch = jest.fn();
 const disableDispatch = jest.fn();
+const setAwsCredentials = jest.fn();
 
 jest.mock('../../dispatch/Dispatch', () => ({
     Dispatch: jest.fn().mockImplementation(() => ({
         enable: enableDispatch,
-        disable: disableDispatch
+        disable: disableDispatch,
+        setAwsCredentials
     }))
 }));
 
@@ -36,13 +38,16 @@ const recordPageView = jest.fn();
 const addSessionAttributes = jest.fn();
 const recordEvent = jest.fn();
 
+let samplingDecision = true;
+const isSessionSampled = jest.fn().mockImplementation(() => samplingDecision);
 jest.mock('../../event-cache/EventCache', () => ({
     EventCache: jest.fn().mockImplementation(() => ({
         enable: enableEventCache,
         disable: disableEventCache,
         recordPageView,
         addSessionAttributes,
-        recordEvent
+        recordEvent,
+        isSessionSampled
     }))
 }));
 
@@ -513,4 +518,32 @@ describe('Orchestration tests', () => {
             INSTALL_SCRIPT
         );
     });
+
+    test('when session is not recorded then credentials are not set', async () => {
+        samplingDecision = false;
+        // Init
+        const orchestration = new Orchestration('a', 'c', 'us-east-1', {
+            telemetries: [],
+            identityPoolId: 'dummyPoolId',
+            guestRoleArn: 'dummyRoleArn'
+        });
+
+        // Assert
+        expect(setAwsCredentials).toHaveBeenCalledTimes(0);
+
+        // Reset
+        samplingDecision = true;
+    });
+
+    test('when session is recorded then credentials are set', async () => {
+        // Init
+        const orchestration = new Orchestration('a', 'c', 'us-east-1', {
+            telemetries: [],
+            identityPoolId: 'dummyPoolId',
+            guestRoleArn: 'dummyRoleArn'
+        });
+
+        // Assert
+        expect(setAwsCredentials).toHaveBeenCalledTimes(1);
+    });
 });

src/sessions/SessionManager.ts

@@ -101,12 +101,21 @@ export class SessionManager {
         this.getSessionFromCookie();
     }
 
+    /**
+     * Returns true if the session is sampled, false otherwise.
+     */
+    public isSampled(): boolean {
+        return this.session.record;
+    }
+
     /**
      * Returns the session ID. If no session ID exists, one will be created.
      */
     public getSession(): Session {
         if (this.session.sessionId === NIL_UUID) {
             // The session does not exist. Create a new one.
+            // If it is created before the page view is recorded, the session start event metadata will
+            // not have page attributes as the page does not exist yet.
             this.createSession();
         } else if (
             this.session.sessionId !== NIL_UUID &&
@@ -219,9 +228,15 @@ export class SessionManager {
     }
 
     private createSession() {
+        // The semantics of the nil session (created during initialization) are that there is no session.
+        // We ensure the nil session and new session created right after initialization have the same sampling decision.
+        // Otherwise, we will always reevaluate the sample decision.
         this.session = {
             sessionId: v4(),
-            record: this.sample(),
+            record:
+                this.session.sessionId === NIL_UUID
+                    ? this.session.record
+                    : this.sample(),
             eventCount: 0
         };
         this.session.page = this.pageManager.getPage();

src/sessions/__tests__/SessionManager.test.ts

@@ -22,6 +22,7 @@ import {
     DEFAULT_CONFIG,
     mockFetch
 } from '../../test-utils/test-utils';
+import { advanceTo } from 'jest-date-mock';
 
 global.fetch = mockFetch;
 const NAVIGATION = 'navigation';
@@ -469,6 +470,7 @@ describe('SessionManager tests', () => {
 
         // Assert
         expect(session.record).toBeTruthy();
+        expect(sessionManager.isSampled()).toBeTruthy();
     });
 
     test('when sessionSampleRate is zero then session.record is false', async () => {
@@ -482,6 +484,53 @@ describe('SessionManager tests', () => {
 
         // Assert
         expect(session.record).toBeFalsy();
+        expect(sessionManager.isSampled()).toBeFalsy();
+    });
+
+    test('when sessionId is nil then create new session with same sampling decision', async () => {
+        mockRandom([0.01]);
+        // Init
+        const sessionManager = defaultSessionManager({
+            ...DEFAULT_CONFIG,
+            ...{ sessionSampleRate: 0.5, allowCookies: true }
+        });
+
+        // Ensure isSampled() returns a different value
+        mockRandom([0.99]);
+        const session = sessionManager.getSession();
+
+        // Assert
+        expect(session.record).toBeTruthy();
+        expect(sessionManager.isSampled()).toBeTruthy();
+    });
+
+    test('when sessionId is not nil then create new session with different sampling decision', async () => {
+        const dateNow = new Date();
+        mockRandom([0.01]);
+        // Init
+        const sessionManager = defaultSessionManager({
+            ...DEFAULT_CONFIG,
+            ...{ sessionSampleRate: 0.5 }
+        });
+
+        // create new session
+        // new session should have same sampling decision as nil session
+        let session = sessionManager.getSession();
+        expect(session.sessionId).not.toEqual(NIL_UUID);
+        expect(session.record).toBeTruthy();
+        expect(sessionManager.isSampled()).toBeTruthy();
+
+        // create new session after previous has expired
+        jest.useFakeTimers();
+        jest.setSystemTime(new Date(dateNow.getTime() + 86400000)); // set to 24 hours from current date
+
+        // new session should have different sampling decision as previous session
+        mockRandom([0.99]);
+        session = sessionManager.getSession();
+
+        // Assert
+        expect(session.record).toBeFalsy();
+        expect(sessionManager.isSampled()).toBeFalsy();
     });
 
     test('when random value equals sessionSampleRate then session.record is false', async () => {