chore: merge update and get session functions

Author: Joozty

packages/web/src/SplunkSpanAttributesProcessor.ts

@@ -18,7 +18,9 @@
 
 import { Attributes } from '@opentelemetry/api'
 import { Span, SpanProcessor } from '@opentelemetry/sdk-trace-base'
-import { getRumSessionId } from './session'
+import { getOrCreateSessionIdAndUpdateExpirationIfNecessary } from './session'
+import { suppressTracing } from '@opentelemetry/core'
+import { context } from '@opentelemetry/api'
 
 export class SplunkSpanAttributesProcessor implements SpanProcessor {
 	private readonly _globalAttributes: Attributes
@@ -43,13 +45,18 @@ export class SplunkSpanAttributesProcessor implements SpanProcessor {
 	}
 
 	onStart(span: Span): void {
-		span.setAttribute('location.href', location.href)
-		span.setAttributes(this._globalAttributes)
-		span.setAttribute(
-			'splunk.rumSessionId',
-			getRumSessionId({ useLocalStorage: this.useLocalStorageForSessionMetadata }),
-		)
-		span.setAttribute('browser.instance.visibility_state', document.visibilityState)
+		context.with(suppressTracing(context.active()), () => {
+			span.setAttribute('location.href', location.href)
+			span.setAttributes(this._globalAttributes)
+			span.setAttribute(
+				'splunk.rumSessionId',
+				getOrCreateSessionIdAndUpdateExpirationIfNecessary({
+					useLocalStorage: this.useLocalStorageForSessionMetadata,
+					forceStore: true,
+				}),
+			)
+			span.setAttribute('browser.instance.visibility_state', document.visibilityState)
+		})
 	}
 
 	setGlobalAttributes(attributes?: Attributes): void {

packages/web/src/index.ts

@@ -43,7 +43,7 @@ import { SplunkExporterConfig } from './exporters/common'
 import { SplunkZipkinExporter } from './exporters/zipkin'
 import { ERROR_INSTRUMENTATION_NAME, SplunkErrorInstrumentation } from './SplunkErrorInstrumentation'
 import { generateId, getPluginConfig } from './utils'
-import { getRumSessionId, initSessionTracking, updateSessionStatus } from './session'
+import { getOrCreateSessionIdAndUpdateExpirationIfNecessary, getRumSessionId, initSessionTracking } from './session'
 import { SplunkWebSocketInstrumentation } from './SplunkWebSocketInstrumentation'
 import { initWebVitals } from './webvitals'
 import { SplunkLongTaskInstrumentation } from './SplunkLongTaskInstrumentation'
@@ -387,7 +387,6 @@ export const SplunkRum: SplunkOtelWebType = {
 		// TODO
 		_deinitSessionTracking = initSessionTracking(
 			provider,
-			instanceId,
 			eventTarget,
 			processedOptions.cookieDomain,
 			!!options._experimental_allSpansExtendSession,
@@ -560,7 +559,7 @@ export const SplunkRum: SplunkOtelWebType = {
 			return
 		}
 
-		updateSessionStatus({
+		getOrCreateSessionIdAndUpdateExpirationIfNecessary({
 			forceStore: false,
 			useLocalStorage: this._processedOptions.persistence === 'localStorage',
 			forceActivity: this._processedOptions._experimental_allSpansExtendSession,

packages/web/src/session/session.ts

@@ -23,8 +23,6 @@ import { parseCookieToSessionState, renewCookieTimeout } from './cookie-session'
 import { SessionState, SessionId } from './types'
 import { getSessionStateFromLocalStorage, setSessionStateToLocalStorage } from './local-storage-session'
 import { SESSION_INACTIVITY_TIMEOUT_MS } from './constants'
-import { suppressTracing } from '@opentelemetry/core'
-import { context } from '@opentelemetry/api'
 
 /*
     The basic idea is to let the browser expire cookies for us "naturally" once
@@ -71,15 +69,22 @@ export function getCurrentSessionState({ useLocalStorage = false, forceStoreRead
 // 1) Check if the cookie has been expired by the browser; if so, create a new one
 // 2) If activity has occurred since the last periodic invocation, renew the cookie timeout
 // (Only exported for testing purposes.)
-export function updateSessionStatus({
-	forceStore,
-	useLocalStorage = false,
-	forceActivity,
-}: {
-	forceActivity?: boolean
-	forceStore: boolean
-	useLocalStorage: boolean
-}): void {
+export function getOrCreateSessionIdAndUpdateExpirationIfNecessary(
+	{
+		forceStore,
+		useLocalStorage,
+		forceActivity,
+	}: {
+		forceActivity?: boolean
+		forceStore: boolean
+		useLocalStorage: boolean
+	},
+	level = 0,
+): string {
+	if (hasNativeSessionId()) {
+		return window['SplunkRumNative'].getNativeSessionId()
+	}
+
 	let sessionState = getCurrentSessionState({ useLocalStorage, forceStoreRead: forceStore })
 	let shouldForceWrite = false
 	if (!sessionState) {
@@ -104,6 +109,29 @@ export function updateSessionStatus({
 	}
 
 	recentActivity = false
+
+	// New session created, check if another tab has created a new session at the same time
+	if (shouldForceWrite && level < 1) {
+		return getOrCreateSessionIdAndUpdateExpirationIfNecessary(
+			{
+				forceStore: true,
+				useLocalStorage,
+			},
+			level + 1,
+		)
+	}
+
+	return sessionState.id
+}
+
+export function getCurrentSessionId({
+	forceStore,
+	useLocalStorage,
+}: {
+	forceStore: boolean
+	useLocalStorage: boolean
+}): string | undefined {
+	return getCurrentSessionState({ useLocalStorage, forceStoreRead: forceStore })?.id
 }
 
 function hasNativeSessionId(): boolean {
@@ -128,13 +156,6 @@ class SessionSpanProcessor implements SpanProcessor {
 		if (this.options.allSpansAreActivity) {
 			markActivity()
 		}
-
-		context.with(suppressTracing(context.active()), () => {
-			updateSessionStatus({
-				forceStore: false,
-				useLocalStorage: this.options.useLocalStorage,
-			})
-		})
 	}
 
 	shutdown(): Promise<void> {
@@ -146,7 +167,6 @@ const ACTIVITY_EVENTS = ['click', 'scroll', 'mousedown', 'keydown', 'touchend',
 
 export function initSessionTracking(
 	provider: WebTracerProvider,
-	instanceId: SessionId,
 	newEventTarget: InternalEventTarget,
 	domain?: string,
 	allSpansAreActivity = false,
@@ -169,8 +189,6 @@ export function initSessionTracking(
 	ACTIVITY_EVENTS.forEach((type) => document.addEventListener(type, markActivity, { capture: true, passive: true }))
 	provider.addSpanProcessor(new SessionSpanProcessor({ allSpansAreActivity, useLocalStorage }))
 
-	updateSessionStatus({ useLocalStorage, forceStore: true })
-
 	return {
 		deinit: () => {
 			ACTIVITY_EVENTS.forEach((type) => document.removeEventListener(type, markActivity))
@@ -184,5 +202,5 @@ export function getRumSessionId({ useLocalStorage }: { useLocalStorage: boolean
 		return window['SplunkRumNative'].getNativeSessionId()
 	}
 
-	return getCurrentSessionState({ useLocalStorage, forceStoreRead: true })?.id
+	return getCurrentSessionId({ useLocalStorage, forceStore: true })
 }

packages/web/test/SessionBasedSampler.test.ts

@@ -19,7 +19,7 @@
 import * as assert from 'assert'
 import { InternalEventTarget } from '../src/EventTarget'
 import { SessionBasedSampler } from '../src/SessionBasedSampler'
-import { initSessionTracking, updateSessionStatus } from '../src/session/session'
+import { initSessionTracking, getOrCreateSessionIdAndUpdateExpirationIfNecessary } from '../src/session'
 import { context, SamplingDecision } from '@opentelemetry/api'
 import { SplunkWebTracerProvider } from '../src'
 import { SESSION_INACTIVITY_TIMEOUT_MS, SESSION_STORAGE_KEY } from '../src/session/constants'
@@ -37,7 +37,7 @@ describe('Session based sampler', () => {
 		)
 		document.cookie = SESSION_STORAGE_KEY + '=' + lowCookieValue + '; path=/; max-age=' + 10
 		const provider = new SplunkWebTracerProvider()
-		initSessionTracking(provider, lowSessionId, new InternalEventTarget())
+		initSessionTracking(provider, new InternalEventTarget())
 
 		const sampler = new SessionBasedSampler({ ratio: 0.5 })
 		assert.strictEqual(
@@ -56,7 +56,7 @@ describe('Session based sampler', () => {
 			}),
 		)
 		document.cookie = SESSION_STORAGE_KEY + '=' + highCookieValue + '; path=/; max-age=' + 10
-		updateSessionStatus({
+		getOrCreateSessionIdAndUpdateExpirationIfNecessary({
 			forceStore: true,
 			useLocalStorage: false,
 		})

packages/web/test/SplunkOtelWeb.test.ts

@@ -19,7 +19,7 @@
 import { SpanAttributes } from '@opentelemetry/api'
 import { expect } from 'chai'
 import SplunkRum from '../src'
-import { updateSessionStatus } from '../src/session/session'
+import { getOrCreateSessionIdAndUpdateExpirationIfNecessary } from '../src/session'
 
 describe('SplunkOtelWeb', () => {
 	afterEach(() => {
@@ -124,7 +124,7 @@ describe('SplunkOtelWeb', () => {
 			})
 
 			document.body.click()
-			updateSessionStatus({ forceStore: false, useLocalStorage: false })
+			getOrCreateSessionIdAndUpdateExpirationIfNecessary({ forceStore: false, useLocalStorage: false })
 
 			// Wait for promise chain to resolve
 			await Promise.resolve()

packages/web/test/session.test.ts

@@ -18,7 +18,11 @@
 
 import * as assert from 'assert'
 import { InternalEventTarget } from '../src/EventTarget'
-import { initSessionTracking, getRumSessionId, updateSessionStatus } from '../src/session/session'
+import {
+	initSessionTracking,
+	getRumSessionId,
+	getOrCreateSessionIdAndUpdateExpirationIfNecessary,
+} from '../src/session'
 import { SplunkWebTracerProvider } from '../src'
 import sinon from 'sinon'
 import { SESSION_STORAGE_KEY, SESSION_INACTIVITY_TIMEOUT_MS } from '../src/session/constants'
@@ -37,11 +41,11 @@ describe('Session tracking', () => {
 	it('should correctly handle expiry, garbage values, (in)activity, etc.', (done) => {
 		// the init tests have possibly already started the setInterval for updateSessionStatus.  Try to accomodate this.
 		const provider = new SplunkWebTracerProvider()
-		const trackingHandle = initSessionTracking(provider, '1234', new InternalEventTarget())
+		const trackingHandle = initSessionTracking(provider, new InternalEventTarget())
 		const firstSessionId = getRumSessionId({ useLocalStorage: false })
 		assert.strictEqual(firstSessionId.length, 32)
 		// no marked activity, should keep same state
-		updateSessionStatus({ forceStore: false, useLocalStorage: false })
+		getOrCreateSessionIdAndUpdateExpirationIfNecessary({ forceStore: false, useLocalStorage: false })
 		assert.strictEqual(firstSessionId, getRumSessionId({ useLocalStorage: false }))
 		// set cookie to expire in 2 seconds, mark activity, and then updateSessionStatus.
 		// Wait 4 seconds and cookie should still be there (having been renewed)
@@ -54,7 +58,7 @@ describe('Session tracking', () => {
 		)
 		document.cookie = SESSION_STORAGE_KEY + '=' + cookieValue + '; path=/; max-age=' + 2
 		document.body.dispatchEvent(new Event('click'))
-		updateSessionStatus({ forceStore: false, useLocalStorage: false })
+		getOrCreateSessionIdAndUpdateExpirationIfNecessary({ forceStore: false, useLocalStorage: false })
 		setTimeout(() => {
 			// because of activity, same session should be there
 			assert.ok(document.cookie.includes(SESSION_STORAGE_KEY))
@@ -72,7 +76,7 @@ describe('Session tracking', () => {
 			)
 			document.cookie = SESSION_STORAGE_KEY + '=' + tooOldCookieValue + '; path=/; max-age=' + 4
 
-			updateSessionStatus({ forceStore: true, useLocalStorage: false })
+			getOrCreateSessionIdAndUpdateExpirationIfNecessary({ forceStore: true, useLocalStorage: false })
 			assert.ok(document.cookie.includes(SESSION_STORAGE_KEY))
 			const newSessionId = getRumSessionId({ useLocalStorage: false })
 			assert.strictEqual(newSessionId.length, 32)
@@ -90,11 +94,10 @@ describe('Session tracking', () => {
 
 		function subject(allSpansAreActivity = false) {
 			const provider = new SplunkWebTracerProvider()
-			const firstSessionId = getRumSessionId({ useLocalStorage: false })
-			initSessionTracking(provider, firstSessionId, new InternalEventTarget(), undefined, allSpansAreActivity)
+			initSessionTracking(provider, new InternalEventTarget(), undefined, allSpansAreActivity)
 
 			provider.getTracer('tracer').startSpan('any-span').end()
-			updateSessionStatus({ forceStore: false, useLocalStorage: false })
+			getOrCreateSessionIdAndUpdateExpirationIfNecessary({ forceStore: false, useLocalStorage: false })
 		}
 
 		it('non-activity spans do not trigger a new session', (done) => {
@@ -131,16 +134,14 @@ describe('Session tracking - localStorage', () => {
 		const provider = new SplunkWebTracerProvider()
 		const trackingHandle = initSessionTracking(
 			provider,
-			'1234',
 			new InternalEventTarget(),
 			undefined,
 			undefined,
 			useLocalStorage,
 		)
 
-		const firstSessionId = getRumSessionId({ useLocalStorage })
-		updateSessionStatus({ forceStore: true, useLocalStorage })
-		assert.strictEqual(firstSessionId, getRumSessionId({ useLocalStorage }))
+		const sessionId = getOrCreateSessionIdAndUpdateExpirationIfNecessary({ forceStore: true, useLocalStorage })
+		assert.strictEqual(sessionId, getRumSessionId({ useLocalStorage }))
 
 		trackingHandle.deinit()
 	})