@grafana/faro-react-native 1.3.1 → 1.4.0

package/src/instrumentations/session/sessionManager/sessionManagerUtils.test.ts

@@ -1,7 +1,10 @@
 import * as faroCore from '@grafana/faro-core';
-import { initializeFaro } from '@grafana/faro-core';
+import { initializeFaro, stringifyExternalJson } from '@grafana/faro-core';
+import type { Faro, MetaAttributes } from '@grafana/faro-core';
 import { mockConfig } from '@grafana/faro-test-utils';
 
+import { SessionActivityKind } from '../sessionActivity';
+
 import * as samplingModule from './sampling';
 import {
   addSessionMetadataToNextSession,
@@ -140,6 +143,13 @@ describe('sessionManagerUtils', () => {
       const isValid = isUserSessionValid(session);
       expect(isValid).toBe(true);
     });
+
+    it.each(['started', 'lastActivity'] as const)('returns false when %s is in the future', (timestamp) => {
+      const session = createUserSessionObject();
+      session[timestamp] = fakeSystemTime + 1;
+
+      expect(isUserSessionValid(session)).toBe(false);
+    });
   });
 
   describe('addSessionMetadataToNextSession', () => {
@@ -284,6 +294,24 @@ describe('sessionManagerUtils', () => {
   });
 
   describe('getUserSessionUpdater', () => {
+    it('uses an already fetched session without reading storage again', () => {
+      initializeFaro(mockConfig({}));
+      const existingSession: FaroUserSession = {
+        sessionId: mockSessionId,
+        started: fakeSystemTime,
+        lastActivity: fakeSystemTime - 1000,
+        isSampled: true,
+      };
+      const mockFetchUserSession = jest.fn();
+      const updateSession = getUserSessionUpdater({
+        fetchUserSession: mockFetchUserSession,
+        storeUserSession: jest.fn(),
+      });
+
+      expect(updateSession(SessionActivityKind.Passive, existingSession)).toBe(existingSession);
+      expect(mockFetchUserSession).not.toHaveBeenCalled();
+    });
+
     it('updates session when session is invalid', async () => {
       const mockOnSessionChange = jest.fn();
       const config = mockConfig({
@@ -295,8 +323,8 @@ describe('sessionManagerUtils', () => {
 
       const _faro = initializeFaro(config);
 
-      const mockFetchUserSession = jest.fn().mockResolvedValue(null);
-      const mockStoreUserSession = jest.fn().mockResolvedValue(undefined);
+      const mockFetchUserSession = jest.fn().mockReturnValue(null);
+      const mockStoreUserSession = jest.fn();
 
       const updateSession = getUserSessionUpdater({
         fetchUserSession: mockFetchUserSession,
@@ -306,7 +334,7 @@ describe('sessionManagerUtils', () => {
       jest.spyOn(faroCore, 'genShortID').mockReturnValueOnce(mockSessionId);
       jest.spyOn(samplingModule, 'isSampled').mockReturnValueOnce(true);
 
-      await updateSession();
+      updateSession(SessionActivityKind.Passive);
 
       expect(mockFetchUserSession).toHaveBeenCalledTimes(1);
       expect(mockStoreUserSession).toHaveBeenCalledTimes(1);
@@ -329,29 +357,52 @@ describe('sessionManagerUtils', () => {
         isSampled: true,
       };
 
-      const mockFetchUserSession = jest.fn().mockResolvedValue(existingSession);
-      const mockStoreUserSession = jest.fn().mockResolvedValue(undefined);
+      const mockFetchUserSession = jest.fn().mockReturnValue(existingSession);
+      const mockStoreUserSession = jest.fn();
 
       const updateSession = getUserSessionUpdater({
         fetchUserSession: mockFetchUserSession,
         storeUserSession: mockStoreUserSession,
       });
 
-      await updateSession();
+      updateSession(SessionActivityKind.Meaningful);
 
       expect(mockStoreUserSession).toHaveBeenCalledWith({
         ...existingSession,
         lastActivity: fakeSystemTime,
       });
     });
+
+    it('keeps the new session when onSessionChange throws', () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+      initializeFaro(
+        mockConfig({
+          sessionTracking: {
+            enabled: true,
+            onSessionChange: () => {
+              throw new Error('callback failed');
+            },
+          },
+        })
+      );
+      const mockStoreUserSession = jest.fn();
+      const updateSession = getUserSessionUpdater({
+        fetchUserSession: jest.fn().mockReturnValue(null),
+        storeUserSession: mockStoreUserSession,
+      });
+
+      expect(() => updateSession(SessionActivityKind.Passive)).not.toThrow();
+      expect(mockStoreUserSession).toHaveBeenCalledTimes(1);
+      expect(warnSpy).toHaveBeenCalledWith('The session change callback failed:', expect.any(Error));
+    });
   });
 
   describe('getSessionMetaUpdateHandler', () => {
     it('creates new session when session ID changes', async () => {
       initializeFaro(mockConfig({}));
 
-      const mockFetchUserSession = jest.fn().mockResolvedValue(null);
-      const mockStoreUserSession = jest.fn().mockResolvedValue(undefined);
+      const mockFetchUserSession = jest.fn().mockReturnValue(null);
+      const mockStoreUserSession = jest.fn();
 
       const handler = getSessionMetaUpdateHandler({
         fetchUserSession: mockFetchUserSession,
@@ -376,23 +427,36 @@ describe('sessionManagerUtils', () => {
     });
 
     it('updates attributes without creating new session', async () => {
-      const faro = initializeFaro(mockConfig({}));
+      const faro = initializeFaro(
+        mockConfig({
+          sessionTracking: {
+            session: {
+              attributes: {
+                configured: 'value',
+              },
+            },
+          },
+        })
+      );
+      const samplingSpy = jest.spyOn(samplingModule, 'isSampled');
 
       const storedSession: FaroUserSession = {
         sessionId: mockSessionId,
-        isSampled: true,
-        lastActivity: fakeSystemTime,
-        started: fakeSystemTime,
+        isSampled: false,
+        lastActivity: fakeSystemTime - 500,
+        started: fakeSystemTime - 1000,
         sessionMeta: {
           id: mockSessionId,
           attributes: {
-            isSampled: 'true',
+            isSampled: 'false',
+            previousSession: 'previous-session',
           },
+          overrides: { serviceName: 'stored-service' },
         },
       };
 
-      const mockFetchUserSession = jest.fn().mockResolvedValue(storedSession);
-      const mockStoreUserSession = jest.fn().mockResolvedValue(undefined);
+      const mockFetchUserSession = jest.fn().mockReturnValue(storedSession);
+      const mockStoreUserSession = jest.fn();
 
       const handler = getSessionMetaUpdateHandler({
         fetchUserSession: mockFetchUserSession,
@@ -412,13 +476,65 @@ describe('sessionManagerUtils', () => {
       expect(mockStoreUserSession).toHaveBeenCalledWith(
         expect.objectContaining({
           sessionId: mockSessionId,
+          isSampled: false,
+          started: fakeSystemTime - 1000,
+          lastActivity: fakeSystemTime - 500,
           sessionMeta: expect.objectContaining({
             attributes: expect.objectContaining({
               foo: 'bar',
+              isSampled: 'false',
+              previousSession: 'previous-session',
+              configured: 'value',
             }),
+            overrides: { serviceName: 'stored-service' },
           }),
         })
       );
+      expect(samplingSpy).not.toHaveBeenCalled();
+    });
+
+    it('restores internal attributes when the same session is set without metadata', async () => {
+      const faro = initializeFaro(mockConfig({}));
+      const storedSession: FaroUserSession = {
+        sessionId: mockSessionId,
+        isSampled: false,
+        lastActivity: fakeSystemTime - 500,
+        started: fakeSystemTime - 1000,
+        sessionMeta: {
+          id: mockSessionId,
+          attributes: {
+            isSampled: 'false',
+            previousSession: 'previous-session',
+          },
+        },
+      };
+      const mockStoreUserSession = jest.fn();
+      const handler = getSessionMetaUpdateHandler({
+        fetchUserSession: jest.fn().mockReturnValue(storedSession),
+        storeUserSession: mockStoreUserSession,
+      });
+
+      await handler({ session: { id: mockSessionId } });
+
+      expect(mockStoreUserSession).toHaveBeenCalledWith(
+        expect.objectContaining({
+          isSampled: false,
+          sessionMeta: {
+            id: mockSessionId,
+            attributes: {
+              isSampled: 'false',
+              previousSession: 'previous-session',
+            },
+          },
+        })
+      );
+      expect(faro.api.getSession()).toStrictEqual({
+        id: mockSessionId,
+        attributes: {
+          isSampled: 'false',
+          previousSession: 'previous-session',
+        },
+      });
     });
 
     it('sends service name override event when service name changes', async () => {
@@ -431,8 +547,8 @@ describe('sessionManagerUtils', () => {
         })
       );
 
-      const mockFetchUserSession = jest.fn().mockResolvedValue(null);
-      const mockStoreUserSession = jest.fn().mockResolvedValue(undefined);
+      const mockFetchUserSession = jest.fn().mockReturnValue(null);
+      const mockStoreUserSession = jest.fn();
 
       const handler = getSessionMetaUpdateHandler({
         fetchUserSession: mockFetchUserSession,
@@ -456,5 +572,127 @@ describe('sessionManagerUtils', () => {
         previousServiceName: 'my-app',
       });
     });
+
+    // Round-trips sessions through the same lossy serialization persistent
+    // storage uses: `stringifyExternalJson` drops keys whose value is
+    // `undefined`.
+    function createJsonBackedSessionStorage() {
+      let stored: string | null = null;
+
+      return {
+        storeUserSession: jest.fn((session: FaroUserSession) => {
+          stored = stringifyExternalJson(session);
+        }),
+        fetchUserSession: jest.fn((): FaroUserSession | null => (stored == null ? null : JSON.parse(stored))),
+      };
+    }
+
+    describe('settling', () => {
+      let faro: Faro;
+      let storage: ReturnType<typeof createJsonBackedSessionStorage>;
+      let handlers: Array<ReturnType<typeof getSessionMetaUpdateHandler>>;
+
+      function attachHandler(): void {
+        const handler = getSessionMetaUpdateHandler(storage);
+        faro.metas.addListener(handler);
+        handlers.push(handler);
+      }
+
+      beforeEach(() => {
+        faro = initializeFaro(mockConfig({}));
+        jest.spyOn(samplingModule, 'isSampled').mockReturnValue(true);
+        storage = createJsonBackedSessionStorage();
+        handlers = [];
+
+        // Stop propagating session updates past a sane number of calls, so a
+        // regression that reintroduces the sync loop fails on the write-count
+        // assertions below instead of exhausting the heap.
+        const setSession = faro.api.setSession.bind(faro.api);
+        const setSessionSpy = jest.spyOn(faro.api, 'setSession').mockImplementation((...args) => {
+          if (setSessionSpy.mock.calls.length <= 10) {
+            setSession(...args);
+          }
+        });
+      });
+
+      afterEach(() => {
+        handlers.forEach((handler) => faro.metas.removeListener(handler));
+      });
+
+      it('settles after applying its own update and still accepts later external changes', () => {
+        attachHandler();
+
+        // The handler applies the external change once; the `setSession()` it
+        // performs itself must not be picked up as another external change.
+        faro.api.setSession({ id: mockSessionId });
+        expect(storage.storeUserSession).toHaveBeenCalledTimes(1);
+
+        // A genuinely external change afterwards is still synced, so the guard
+        // did not leave the handler permanently disabled.
+        faro.api.setSession({ id: 'next-session-id' });
+        expect(storage.storeUserSession).toHaveBeenCalledTimes(2);
+        expect(storage.storeUserSession).toHaveBeenLastCalledWith(
+          expect.objectContaining({ sessionId: 'next-session-id' })
+        );
+      });
+
+      it('does not write the session again when an unrelated meta changes', () => {
+        attachHandler();
+
+        // An attribute whose value is `undefined` mirrors the optional device
+        // attributes (battery level, carrier, ...). Storage drops the key on
+        // write; the in-memory meta must converge to the same shape.
+        faro.api.setSession({
+          id: mockSessionId,
+          attributes: { device_battery_level: undefined } as unknown as MetaAttributes,
+        });
+        expect(storage.storeUserSession).toHaveBeenCalledTimes(1);
+
+        // Unrelated meta updates notify the handler with an unchanged session;
+        // none of them may write the session again.
+        faro.api.setView({ name: 'first-view' });
+        faro.api.setUser({ id: 'user-1' });
+
+        expect(storage.storeUserSession).toHaveBeenCalledTimes(1);
+      });
+
+      it('does not rewrite the session when overrides carry an undefined value', () => {
+        attachHandler();
+
+        // Overrides diverge from their own stored copy exactly like attributes
+        // do: the `undefined`-valued key survives in memory but not in storage.
+        faro.api.setSession({
+          id: mockSessionId,
+          overrides: { serviceName: 'my-service', geoLocationTrackingEnabled: undefined },
+        });
+        expect(storage.storeUserSession).toHaveBeenCalledTimes(1);
+
+        faro.api.setView({ name: 'first-view' });
+
+        expect(storage.storeUserSession).toHaveBeenCalledTimes(1);
+      });
+
+      it('settles when more than one handler is registered', () => {
+        // More than one handler can be registered over the same storage. They
+        // must not re-trigger one another through the echo notifications of
+        // their own writes.
+        attachHandler();
+        attachHandler();
+
+        faro.api.setSession({
+          id: mockSessionId,
+          attributes: { device_battery_level: undefined } as unknown as MetaAttributes,
+        });
+        // Both handlers may process the original notification, but the writes
+        // must settle instead of ping-ponging.
+        const writesAfterSettling = storage.storeUserSession.mock.calls.length;
+        expect(writesAfterSettling).toBeLessThanOrEqual(2);
+
+        // ...and a later unrelated meta change must not start writing again.
+        faro.api.setView({ name: 'first-view' });
+
+        expect(storage.storeUserSession.mock.calls.length).toBe(writesAfterSettling);
+      });
+    });
   });
 });

package/src/instrumentations/session/sessionManager/sessionManagerUtils.ts

@@ -1,5 +1,15 @@
-import { dateNow, deepEqual, EVENT_OVERRIDES_SERVICE_NAME, faro, genShortID, isEmpty } from '@grafana/faro-core';
-import type { Meta, MetaOverrides } from '@grafana/faro-core';
+import {
+  dateNow,
+  deepEqual,
+  EVENT_OVERRIDES_SERVICE_NAME,
+  faro,
+  genShortID,
+  isEmpty,
+  stringifyExternalJson,
+} from '@grafana/faro-core';
+import type { Meta, MetaOverrides, MetaSession } from '@grafana/faro-core';
+
+import { SessionActivityKind } from '../sessionActivity';
 
 import { isSampled } from './sampling';
 import { MAX_SESSION_PERSISTENCE_TIME } from './sessionConstants';
@@ -54,48 +64,126 @@ export function isUserSessionValid(session: FaroUserSession | null): boolean {
 
   const { sessionExpirationTime, inactivityTimeout } = getSessionTimeouts();
   const now = dateNow();
+  if (session.started > now || session.lastActivity > now) {
+    return false;
+  }
+
   const lifetimeValid = now - session.started < sessionExpirationTime;
 
   if (!lifetimeValid) {
     return false;
   }
 
+  // The session expires at the boundary, matching cold-start record cleanup.
   const inactivityPeriodValid = now - session.lastActivity < inactivityTimeout;
   return inactivityPeriodValid;
 }
 
 type GetUserSessionUpdaterParams = {
-  storeUserSession: (session: FaroUserSession) => void | Promise<void>;
-  fetchUserSession: () => FaroUserSession | null | Promise<FaroUserSession | null>;
+  storeUserSession: (session: FaroUserSession) => void;
+  fetchUserSession: () => FaroUserSession | null;
+  recordUserSessionActivity?: (session: FaroUserSession) => void;
 };
 
-export function getUserSessionUpdater({
-  fetchUserSession,
-  storeUserSession,
-}: GetUserSessionUpdaterParams): () => Promise<void> {
-  return async function updateSession(): Promise<void> {
-    if (!fetchUserSession || !storeUserSession) {
-      return;
-    }
+type GetUserSessionResetterParams = Pick<GetUserSessionUpdaterParams, 'fetchUserSession' | 'storeUserSession'>;
+
+function notifySessionChange(previousSession: FaroUserSession | null, newSession: FaroUserSession): void {
+  const newSessionMeta = newSession.sessionMeta;
+  if (newSessionMeta == null) {
+    return;
+  }
+
+  try {
+    faro.config.sessionTracking?.onSessionChange?.(previousSession?.sessionMeta ?? null, newSessionMeta);
+  } catch (error) {
+    faro.unpatchedConsole?.warn?.('The session change callback failed:', error);
+  }
+}
+
+function createNextUserSession(previousSession: FaroUserSession | null): FaroUserSession {
+  const nextSession = createUserSessionObject({ isSampled: isSampled() });
+
+  if (previousSession != null && nextSession.sessionId === previousSession.sessionId) {
+    faro.unpatchedConsole?.warn?.(
+      'The session ID generator returned the current session ID; using a generated fallback for the new session.'
+    );
+    nextSession.sessionId = genShortID();
+  }
+
+  return addSessionMetadataToNextSession(nextSession, previousSession);
+}
 
-    const sessionFromStorage = await fetchUserSession();
+function startNextUserSession(
+  previousSession: FaroUserSession | null,
+  storeUserSession: (session: FaroUserSession) => void
+): FaroUserSession {
+  const nextSession = createNextUserSession(previousSession);
 
-    if (isUserSessionValid(sessionFromStorage)) {
-      await storeUserSession({ ...sessionFromStorage!, lastActivity: dateNow() });
-    } else {
-      let newSession = addSessionMetadataToNextSession(
-        createUserSessionObject({ isSampled: isSampled() }),
-        sessionFromStorage
-      );
+  storeUserSession(nextSession);
+  // setSession synchronously emits session_start through the meta listener.
+  // The transport hook then resumes and attributes the triggering item to
+  // the newly stored session.
+  faro.api?.setSession(nextSession.sessionMeta);
+  notifySessionChange(previousSession, nextSession);
 
-      await storeUserSession(newSession);
+  return nextSession;
+}
+
+export function getUserSessionResetter({
+  fetchUserSession,
+  storeUserSession,
+}: GetUserSessionResetterParams): () => FaroUserSession {
+  return function resetSession(): FaroUserSession {
+    return startNextUserSession(fetchUserSession(), storeUserSession);
+  };
+}
 
-      faro.api?.setSession(newSession.sessionMeta);
-      faro.config.sessionTracking?.onSessionChange?.(sessionFromStorage?.sessionMeta ?? null, newSession.sessionMeta!);
+export function getUserSessionUpdater({
+  fetchUserSession,
+  recordUserSessionActivity,
+  storeUserSession,
+}: GetUserSessionUpdaterParams): (
+  activity: SessionActivityKind,
+  currentSession?: FaroUserSession | null
+) => FaroUserSession {
+  const persistActivity = recordUserSessionActivity ?? storeUserSession;
+
+  return function updateSession(
+    activity: SessionActivityKind,
+    currentSession?: FaroUserSession | null
+  ): FaroUserSession {
+    const sessionFromStorage = currentSession === undefined ? fetchUserSession() : currentSession;
+
+    if (sessionFromStorage != null && isUserSessionValid(sessionFromStorage)) {
+      if (activity === SessionActivityKind.Meaningful) {
+        const lastActivity = dateNow();
+        if (lastActivity === sessionFromStorage.lastActivity) {
+          return sessionFromStorage;
+        }
+
+        const refreshedSession = { ...sessionFromStorage, lastActivity };
+        persistActivity(refreshedSession);
+        return refreshedSession;
+      }
+
+      return sessionFromStorage;
     }
+
+    return startNextUserSession(sessionFromStorage, storeUserSession);
   };
 }
 
+/**
+ * Persistent storage serializes sessions with `stringifyExternalJson`, which
+ * drops keys whose value is `undefined`. A session meta carrying such a key
+ * never compares `deepEqual` to its own stored copy, so the sync handler would
+ * rewrite the session on every meta notification. Applying the same round-trip
+ * in memory keeps the two sides comparable, for attributes and overrides alike.
+ */
+export function toStorableSessionMeta(sessionMeta: MetaSession): MetaSession {
+  return JSON.parse(stringifyExternalJson(sessionMeta)) as MetaSession;
+}
+
 export function addSessionMetadataToNextSession(newSession: FaroUserSession, previousSession: FaroUserSession | null) {
   const sessionWithMeta: Required<FaroUserSession> = {
     ...newSession,
@@ -115,25 +203,51 @@ export function addSessionMetadataToNextSession(newSession: FaroUserSession, pre
   }
 
   const previousSessionId = previousSession?.sessionId;
-  if (previousSessionId != null) {
+  if (previousSessionId != null && previousSessionId !== newSession.sessionId) {
     sessionWithMeta.sessionMeta.attributes!['previousSession'] = previousSessionId;
   }
 
+  // Normalize to what storage can hold, so the meta this session propagates
+  // stays comparable to its own stored copy.
+  sessionWithMeta.sessionMeta = toStorableSessionMeta(sessionWithMeta.sessionMeta);
+
   return sessionWithMeta;
 }
 
 type GetUserSessionMetaUpdateHandlerParams = {
-  storeUserSession: (session: FaroUserSession) => void | Promise<void>;
-  fetchUserSession: () => FaroUserSession | null | Promise<FaroUserSession | null>;
+  storeUserSession: (session: FaroUserSession) => void;
+  fetchUserSession: () => FaroUserSession | null;
 };
 
+/**
+ * Set only while a handler applies its own session update.
+ *
+ * `setSession()` notifies meta listeners synchronously, so a handler is
+ * re-entered by its own write. This flag rejects that re-entry, and bounds any
+ * future divergence between the in-memory and the stored session to a single
+ * redundant write instead of an unbounded loop.
+ *
+ * Module scoped rather than per handler: more than one handler can be
+ * registered over the same storage, and per-handler flags would let them
+ * re-trigger one another through the echo notifications of their own writes.
+ */
+let isApplyingOwnUpdate = false;
+
 export function getSessionMetaUpdateHandler({
   fetchUserSession,
   storeUserSession,
 }: GetUserSessionMetaUpdateHandlerParams) {
-  return async function syncSessionIfChangedExternally(meta: Meta) {
-    const session = meta.session;
-    const sessionFromSessionStorage = await fetchUserSession();
+  return function syncSessionIfChangedExternally(meta: Meta): void {
+    // Checked before work begins so the synchronous re-entry triggered by
+    // `setSession()` below is rejected while the flag is still set.
+    if (isApplyingOwnUpdate) {
+      return;
+    }
+
+    // Compare in storable form, so keys that storage cannot hold do not read
+    // as a perpetual external change.
+    const session = meta.session && toStorableSessionMeta(meta.session);
+    const sessionFromSessionStorage = fetchUserSession();
 
     let sessionId = session?.id;
     const sessionAttributes = session?.attributes;
@@ -142,19 +256,46 @@ export function getSessionMetaUpdateHandler({
     const storedSessionMeta = sessionFromSessionStorage?.sessionMeta;
     const storedSessionMetaOverrides = storedSessionMeta?.overrides;
 
-    const hasSessionOverridesChanged = !!sessionOverrides && !deepEqual(sessionOverrides, storedSessionMetaOverrides);
-    const hasAttributesChanged = !!sessionAttributes && !deepEqual(sessionAttributes, storedSessionMeta?.attributes);
+    const hasSessionOverridesChanged =
+      sessionOverrides != null && !deepEqual(sessionOverrides, storedSessionMetaOverrides);
+    const hasSessionMetaChanged =
+      session != null &&
+      (!deepEqual(sessionAttributes, storedSessionMeta?.attributes) ||
+        !deepEqual(sessionOverrides, storedSessionMetaOverrides));
     const hasSessionIdChanged = !!session && sessionId !== sessionFromSessionStorage?.sessionId;
 
-    if (hasSessionIdChanged || hasAttributesChanged || hasSessionOverridesChanged) {
-      const userSession = addSessionMetadataToNextSession(
-        createUserSessionObject({ sessionId, isSampled: isSampled() }),
-        sessionFromSessionStorage
-      );
-
-      await storeUserSession(userSession);
+    if (hasSessionIdChanged || hasSessionMetaChanged) {
+      const storedPreviousSessionId = storedSessionMeta?.attributes?.['previousSession'];
+      const effectiveOverrides = sessionOverrides ?? storedSessionMetaOverrides;
+      const userSession =
+        sessionFromSessionStorage != null && !hasSessionIdChanged
+          ? {
+              ...sessionFromSessionStorage,
+              sessionMeta: toStorableSessionMeta({
+                id: sessionFromSessionStorage.sessionId,
+                attributes: {
+                  ...faro.config.sessionTracking?.session?.attributes,
+                  ...(sessionAttributes ?? storedSessionMeta?.attributes),
+                  ...(storedPreviousSessionId == null ? {} : { previousSession: storedPreviousSessionId }),
+                  isSampled: sessionFromSessionStorage.isSampled.toString(),
+                },
+                ...(isEmpty(effectiveOverrides) ? {} : { overrides: effectiveOverrides }),
+              }),
+            }
+          : addSessionMetadataToNextSession(
+              createUserSessionObject({ sessionId, isSampled: isSampled() }),
+              sessionFromSessionStorage
+            );
+
+      storeUserSession(userSession);
       sendOverrideEvent(hasSessionOverridesChanged, sessionOverrides, storedSessionMetaOverrides);
-      faro.api.setSession(userSession.sessionMeta);
+
+      isApplyingOwnUpdate = true;
+      try {
+        faro.api.setSession(userSession.sessionMeta);
+      } finally {
+        isApplyingOwnUpdate = false;
+      }
     }
   };
 }

package/src/instrumentations/session/sessionManager/types.ts

@@ -1,5 +1,7 @@
 import type { MetaSession } from '@grafana/faro-core';
 
+import type { SessionActivityKind } from '../sessionActivity';
+
 import type { MmkvPersistentSessionsManager } from './MmkvPersistentSessionsManager';
 import type { VolatileSessionsManager } from './VolatileSessionManager';
 
@@ -12,3 +14,9 @@ export interface FaroUserSession {
 }
 
 export type SessionManager = typeof VolatileSessionsManager | typeof MmkvPersistentSessionsManager;
+
+export interface SessionManagerInstance {
+  checkSession(activity: SessionActivityKind, currentSession?: FaroUserSession | null): FaroUserSession;
+  resetSession(): FaroUserSession;
+  unpatch(): void;
+}