@kubesense/kubesense-browser-rum-core 1.0.0

package/esm/domain/rumSessionManager.js

@@ -0,0 +1,72 @@
+import { Observable, SESSION_NOT_TRACKED, bridgeSupports, noop, performDraw, startSessionManager, } from '@kubesense/kubesense-browser-core';
+export const RUM_SESSION_KEY = 'rum';
+export function startRumSessionManager(configuration, lifeCycle, trackingConsentState) {
+    const sessionManager = startSessionManager(configuration, RUM_SESSION_KEY, (rawTrackingType) => computeTrackingType(configuration, rawTrackingType), trackingConsentState);
+    sessionManager.expireObservable.subscribe(() => {
+        lifeCycle.notify(9 /* LifeCycleEventType.SESSION_EXPIRED */);
+    });
+    sessionManager.renewObservable.subscribe(() => {
+        lifeCycle.notify(10 /* LifeCycleEventType.SESSION_RENEWED */);
+    });
+    sessionManager.sessionStateUpdateObservable.subscribe(({ previousState, newState }) => {
+        if (!previousState.forcedReplay && newState.forcedReplay) {
+            const sessionEntity = sessionManager.findSession();
+            if (sessionEntity) {
+                sessionEntity.isReplayForced = true;
+            }
+        }
+    });
+    return {
+        findTrackedSession: (startTime) => {
+            const session = sessionManager.findSession(startTime);
+            if (!session || session.trackingType === "0" /* RumTrackingType.NOT_TRACKED */) {
+                return;
+            }
+            return {
+                id: session.id,
+                sessionReplay: session.trackingType === "1" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */
+                    ? 1 /* SessionReplayState.SAMPLED */
+                    : session.isReplayForced
+                        ? 2 /* SessionReplayState.FORCED */
+                        : 0 /* SessionReplayState.OFF */,
+                anonymousId: session.anonymousId,
+            };
+        },
+        expire: sessionManager.expire,
+        expireObservable: sessionManager.expireObservable,
+        setForcedReplay: () => sessionManager.updateSessionState({ forcedReplay: '1' }),
+    };
+}
+/**
+ * Start a tracked replay session stub
+ */
+export function startRumSessionManagerStub() {
+    const session = {
+        id: '00000000-aaaa-0000-aaaa-000000000000',
+        sessionReplay: bridgeSupports("records" /* BridgeCapability.RECORDS */) ? 1 /* SessionReplayState.SAMPLED */ : 0 /* SessionReplayState.OFF */,
+    };
+    return {
+        findTrackedSession: () => session,
+        expire: noop,
+        expireObservable: new Observable(),
+        setForcedReplay: noop,
+    };
+}
+function computeTrackingType(configuration, rawTrackingType) {
+    if (hasValidRumSession(rawTrackingType)) {
+        return rawTrackingType;
+    }
+    if (!performDraw(configuration.sessionSampleRate)) {
+        return "0" /* RumTrackingType.NOT_TRACKED */;
+    }
+    if (!performDraw(configuration.sessionReplaySampleRate)) {
+        return "2" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */;
+    }
+    return "1" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */;
+}
+function hasValidRumSession(trackingType) {
+    return (trackingType === "0" /* RumTrackingType.NOT_TRACKED */ ||
+        trackingType === "1" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */ ||
+        trackingType === "2" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */);
+}
+//# sourceMappingURL=rumSessionManager.js.map

package/esm/domain/rumSessionManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rumSessionManager.js","sourceRoot":"","sources":["../../src/domain/rumSessionManager.ts"],"names":[],"mappings":"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"}

package/esm/domain/sampler/sampler.d.ts

@@ -0,0 +1,10 @@
+export declare function isSampled(sessionId: string, sampleRate: number): boolean;
+export declare function resetSampleDecisionCache(): void;
+/**
+ * Perform sampling using the Knuth factor method. This method offer consistent sampling result
+ * based on the provided identifier.
+ *
+ * @param identifier - The identifier to use for sampling.
+ * @param sampleRate - The sample rate in percentage between 0 and 100.
+ */
+export declare function sampleUsingKnuthFactor(identifier: bigint, sampleRate: number): boolean;

package/esm/domain/sampler/sampler.js

@@ -0,0 +1,58 @@
+import { performDraw } from '@kubesense/kubesense-browser-core';
+const sampleDecisionCache = new Map();
+export function isSampled(sessionId, sampleRate) {
+    // Shortcuts for common cases. This is not strictly necessary, but it makes the code faster for
+    // customers willing to ingest all traces.
+    if (sampleRate === 100) {
+        return true;
+    }
+    if (sampleRate === 0) {
+        return false;
+    }
+    const cachedDecision = sampleDecisionCache.get(sampleRate);
+    if (cachedDecision && sessionId === cachedDecision.sessionId) {
+        return cachedDecision.decision;
+    }
+    let decision;
+    // @ts-expect-error BigInt might not be defined in every browser we support
+    if (window.BigInt) {
+        decision = sampleUsingKnuthFactor(BigInt(`0x${sessionId.split('-')[4]}`), sampleRate);
+    }
+    else {
+        // For simplicity, we don't use consistent sampling for browser without BigInt support
+        // TODO: remove this when all browser we support have BigInt support
+        decision = performDraw(sampleRate);
+    }
+    sampleDecisionCache.set(sampleRate, { sessionId, decision });
+    return decision;
+}
+// Exported for tests
+export function resetSampleDecisionCache() {
+    sampleDecisionCache.clear();
+}
+/**
+ * Perform sampling using the Knuth factor method. This method offer consistent sampling result
+ * based on the provided identifier.
+ *
+ * @param identifier - The identifier to use for sampling.
+ * @param sampleRate - The sample rate in percentage between 0 and 100.
+ */
+export function sampleUsingKnuthFactor(identifier, sampleRate) {
+    // The formula is:
+    //
+    //   (identifier * knuthFactor) % 2^64 < sampleRate * 2^64
+    //
+    // Because JavaScript numbers are 64-bit floats, we can't represent 64-bit integers, and the
+    // modulo would be incorrect. Thus, we are using BigInts here.
+    //
+    // Note: All implementations have slight variations. Some of them use '<=' instead of '<', and
+    // use `sampleRate * 2^64 - 1` instead of `sampleRate * 2^64`. The following implementation
+    // should adhere to the spec and is a bit simpler than using a 2^64-1 limit as there are less
+    // BigInt arithmetic to write. In practice this does not matter, as we are using floating point
+    // numbers in the end, and Number(2n**64n-1n) === Number(2n**64n).
+    const knuthFactor = BigInt('1111111111111111111');
+    const twoPow64 = BigInt('0x10000000000000000'); // 2n ** 64n
+    const hash = (identifier * knuthFactor) % twoPow64;
+    return Number(hash) <= (sampleRate / 100) * Number(twoPow64);
+}
+//# sourceMappingURL=sampler.js.map

package/esm/domain/sampler/sampler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler.js","sourceRoot":"","sources":["../../../src/domain/sampler/sampler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAE/D,MAAM,mBAAmB,GAA0D,IAAI,GAAG,EAAE,CAAA;AAE5F,MAAM,UAAU,SAAS,CAAC,SAAiB,EAAE,UAAkB;IAC7D,+FAA+F;IAC/F,0CAA0C;IAC1C,IAAI,UAAU,KAAK,GAAG,EAAE,CAAC;QACvB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO,KAAK,CAAA;IACd,CAAC;IAED,MAAM,cAAc,GAAG,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAC1D,IAAI,cAAc,IAAI,SAAS,KAAK,cAAc,CAAC,SAAS,EAAE,CAAC;QAC7D,OAAO,cAAc,CAAC,QAAQ,CAAA;IAChC,CAAC;IAED,IAAI,QAAiB,CAAA;IACrB,2EAA2E;IAC3E,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAClB,QAAQ,GAAG,sBAAsB,CAAC,MAAM,CAAC,KAAK,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAA;IACvF,CAAC;SAAM,CAAC;QACN,sFAAsF;QACtF,oEAAoE;QACpE,QAAQ,GAAG,WAAW,CAAC,UAAU,CAAC,CAAA;IACpC,CAAC;IACD,mBAAmB,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAA;IAC5D,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED,qBAAqB;AACrB,MAAM,UAAU,wBAAwB;IACtC,mBAAmB,CAAC,KAAK,EAAE,CAAA;AAC7B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CAAC,UAAkB,EAAE,UAAkB;IAC3E,kBAAkB;IAClB,EAAE;IACF,0DAA0D;IAC1D,EAAE;IACF,4FAA4F;IAC5F,8DAA8D;IAC9D,EAAE;IACF,8FAA8F;IAC9F,2FAA2F;IAC3F,6FAA6F;IAC7F,+FAA+F;IAC/F,kEAAkE;IAClE,MAAM,WAAW,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAA;IACjD,MAAM,QAAQ,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAA,CAAC,YAAY;IAC3D,MAAM,IAAI,GAAG,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,QAAQ,CAAA;IAClD,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;AAC9D,CAAC"}

package/esm/domain/startCustomerDataTelemetry.d.ts

@@ -0,0 +1,4 @@
+import type { FlushEvent, Observable, Telemetry } from '@kubesense/kubesense-browser-core';
+import type { LifeCycle } from './lifeCycle';
+export declare const MEASURES_PERIOD_DURATION: number;
+export declare function startCustomerDataTelemetry(telemetry: Telemetry, lifeCycle: LifeCycle, batchFlushObservable: Observable<FlushEvent>): void;

package/esm/domain/startCustomerDataTelemetry.js

@@ -0,0 +1,52 @@
+import { ONE_SECOND, addTelemetryMetrics, setInterval } from '@kubesense/kubesense-browser-core';
+export const MEASURES_PERIOD_DURATION = 10 * ONE_SECOND;
+let currentPeriodMeasures;
+let batchHasRumEvent;
+export function startCustomerDataTelemetry(telemetry, lifeCycle, batchFlushObservable) {
+    if (!telemetry.metricsEnabled) {
+        return;
+    }
+    initCurrentPeriodMeasures();
+    batchHasRumEvent = false;
+    // We measure the data of every view updates even if there could only be one per batch due to the upsert
+    // It means that contexts bytes count sums can be higher than it really is
+    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, () => {
+        batchHasRumEvent = true;
+    });
+    batchFlushObservable.subscribe(({ bytesCount, messagesCount }) => {
+        // Don't measure batch that only contains telemetry events to avoid batch sending loop
+        // It could happen because after each batch we are adding a customer data measures telemetry event to the next one
+        if (!batchHasRumEvent) {
+            return;
+        }
+        batchHasRumEvent = false;
+        currentPeriodMeasures.batchCount += 1;
+        updateMeasure(currentPeriodMeasures.batchBytesCount, bytesCount);
+        updateMeasure(currentPeriodMeasures.batchMessagesCount, messagesCount);
+    });
+    setInterval(sendCurrentPeriodMeasures, MEASURES_PERIOD_DURATION);
+}
+function sendCurrentPeriodMeasures() {
+    if (currentPeriodMeasures.batchCount === 0) {
+        return;
+    }
+    // monitor-until: forever
+    addTelemetryMetrics("Customer data measures" /* TelemetryMetrics.CUSTOMER_DATA_METRIC_NAME */, currentPeriodMeasures);
+    initCurrentPeriodMeasures();
+}
+function createMeasure() {
+    return { min: Infinity, max: 0, sum: 0 };
+}
+function updateMeasure(measure, value) {
+    measure.sum += value;
+    measure.min = Math.min(measure.min, value);
+    measure.max = Math.max(measure.max, value);
+}
+function initCurrentPeriodMeasures() {
+    currentPeriodMeasures = {
+        batchCount: 0,
+        batchBytesCount: createMeasure(),
+        batchMessagesCount: createMeasure(),
+    };
+}
+//# sourceMappingURL=startCustomerDataTelemetry.js.map

package/esm/domain/startCustomerDataTelemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startCustomerDataTelemetry.js","sourceRoot":"","sources":["../../src/domain/startCustomerDataTelemetry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,WAAW,EAAoB,MAAM,mCAAmC,CAAA;AAKlH,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,GAAG,UAAU,CAAA;AAcvD,IAAI,qBAA4C,CAAA;AAChD,IAAI,gBAAyB,CAAA;AAE7B,MAAM,UAAU,0BAA0B,CACxC,SAAoB,EACpB,SAAoB,EACpB,oBAA4C;IAE5C,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;QAC9B,OAAM;IACR,CAAC;IAED,yBAAyB,EAAE,CAAA;IAC3B,gBAAgB,GAAG,KAAK,CAAA;IACxB,wGAAwG;IACxG,0EAA0E;IAC1E,SAAS,CAAC,SAAS,kDAAyC,GAAG,EAAE;QAC/D,gBAAgB,GAAG,IAAI,CAAA;IACzB,CAAC,CAAC,CAAA;IAEF,oBAAoB,CAAC,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,aAAa,EAAE,EAAE,EAAE;QAC/D,sFAAsF;QACtF,kHAAkH;QAClH,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,OAAM;QACR,CAAC;QACD,gBAAgB,GAAG,KAAK,CAAA;QAExB,qBAAqB,CAAC,UAAU,IAAI,CAAC,CAAA;QACrC,aAAa,CAAC,qBAAqB,CAAC,eAAe,EAAE,UAAU,CAAC,CAAA;QAChE,aAAa,CAAC,qBAAqB,CAAC,kBAAkB,EAAE,aAAa,CAAC,CAAA;IACxE,CAAC,CAAC,CAAA;IAEF,WAAW,CAAC,yBAAyB,EAAE,wBAAwB,CAAC,CAAA;AAClE,CAAC;AAED,SAAS,yBAAyB;IAChC,IAAI,qBAAqB,CAAC,UAAU,KAAK,CAAC,EAAE,CAAC;QAC3C,OAAM;IACR,CAAC;IAED,yBAAyB;IACzB,mBAAmB,4EAA6C,qBAAqB,CAAC,CAAA;IACtF,yBAAyB,EAAE,CAAA;AAC7B,CAAC;AAED,SAAS,aAAa;IACpB,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAA;AAC1C,CAAC;AAED,SAAS,aAAa,CAAC,OAAgB,EAAE,KAAa;IACpD,OAAO,CAAC,GAAG,IAAI,KAAK,CAAA;IACpB,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IAC1C,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;AAC5C,CAAC;AAED,SAAS,yBAAyB;IAChC,qBAAqB,GAAG;QACtB,UAAU,EAAE,CAAC;QACb,eAAe,EAAE,aAAa,EAAE;QAChC,kBAAkB,EAAE,aAAa,EAAE;KACpC,CAAA;AACH,CAAC"}

package/esm/domain/tracing/getDocumentTraceId.d.ts

@@ -0,0 +1,12 @@
+import type { TimeStamp } from '@kubesense/kubesense-browser-core';
+interface DocumentTraceData {
+    traceId: string;
+    traceTime: TimeStamp;
+}
+export declare const INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD: number;
+export declare function getDocumentTraceId(document: Document): string | undefined;
+export declare function getDocumentTraceDataFromMeta(document: Document): DocumentTraceData | undefined;
+export declare function getDocumentTraceDataFromComment(document: Document): DocumentTraceData | undefined;
+export declare function createDocumentTraceData(traceId: string | undefined | null, rawTraceTime: string | undefined | null): DocumentTraceData | undefined;
+export declare function findTraceComment(document: Document): string | undefined;
+export {};

package/esm/domain/tracing/getDocumentTraceId.js

@@ -0,0 +1,68 @@
+import { dateNow, findCommaSeparatedValue, ONE_MINUTE } from '@kubesense/kubesense-browser-core';
+import { isCommentNode, isTextNode } from '../../browser/htmlDomUtils';
+export const INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD = 2 * ONE_MINUTE;
+export function getDocumentTraceId(document) {
+    const data = getDocumentTraceDataFromMeta(document) || getDocumentTraceDataFromComment(document);
+    if (!data || data.traceTime <= dateNow() - INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD) {
+        return undefined;
+    }
+    return data.traceId;
+}
+export function getDocumentTraceDataFromMeta(document) {
+    const traceIdMeta = document.querySelector('meta[name=kubesense-trace-id]');
+    const traceTimeMeta = document.querySelector('meta[name=kubesense-trace-time]');
+    return createDocumentTraceData(traceIdMeta && traceIdMeta.content, traceTimeMeta && traceTimeMeta.content);
+}
+export function getDocumentTraceDataFromComment(document) {
+    const comment = findTraceComment(document);
+    if (!comment) {
+        return undefined;
+    }
+    return createDocumentTraceData(findCommaSeparatedValue(comment, 'trace-id'), findCommaSeparatedValue(comment, 'trace-time'));
+}
+export function createDocumentTraceData(traceId, rawTraceTime) {
+    const traceTime = rawTraceTime && Number(rawTraceTime);
+    if (!traceId || !traceTime) {
+        return undefined;
+    }
+    return {
+        traceId,
+        traceTime,
+    };
+}
+export function findTraceComment(document) {
+    // 1. Try to find the comment as a direct child of the document
+    // Note: TSLint advises to use a 'for of', but TS doesn't allow to use 'for of' if the iterated
+    // value is not an array or string (here, a NodeList).
+    for (let i = 0; i < document.childNodes.length; i += 1) {
+        const comment = getTraceCommentFromNode(document.childNodes[i]);
+        if (comment) {
+            return comment;
+        }
+    }
+    // 2. If the comment is placed after the </html> tag, but have some space or new lines before or
+    // after, the DOM parser will lift it (and the surrounding text) at the end of the <body> tag.
+    // Try to look for the comment at the end of the <body> by by iterating over its child nodes in
+    // reverse order, stopping if we come across a non-text node.
+    if (document.body) {
+        for (let i = document.body.childNodes.length - 1; i >= 0; i -= 1) {
+            const node = document.body.childNodes[i];
+            const comment = getTraceCommentFromNode(node);
+            if (comment) {
+                return comment;
+            }
+            if (!isTextNode(node)) {
+                break;
+            }
+        }
+    }
+}
+function getTraceCommentFromNode(node) {
+    if (node && isCommentNode(node)) {
+        const match = /^\s*KUBESENSE;(.*?)\s*$/.exec(node.data);
+        if (match) {
+            return match[1];
+        }
+    }
+}
+//# sourceMappingURL=getDocumentTraceId.js.map

package/esm/domain/tracing/getDocumentTraceId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDocumentTraceId.js","sourceRoot":"","sources":["../../../src/domain/tracing/getDocumentTraceId.ts"],"names":[],"mappings":"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"}

package/esm/domain/tracing/identifier.d.ts

@@ -0,0 +1,13 @@
+interface BaseIdentifier {
+    toString(radix?: number): string;
+}
+export interface TraceIdentifier extends BaseIdentifier {
+    __brand: 'traceIdentifier';
+}
+export interface SpanIdentifier extends BaseIdentifier {
+    __brand: 'spanIdentifier';
+}
+export declare function createTraceIdentifier(): TraceIdentifier;
+export declare function createSpanIdentifier(): SpanIdentifier;
+export declare function toPaddedHexadecimalString(id: BaseIdentifier): string;
+export {};

package/esm/domain/tracing/identifier.js

@@ -0,0 +1,50 @@
+export function createTraceIdentifier() {
+    return createIdentifier(64);
+}
+export function createSpanIdentifier() {
+    return createIdentifier(63);
+}
+function createIdentifier(bits) {
+    const buffer = crypto.getRandomValues(new Uint32Array(2));
+    if (bits === 63) {
+        // eslint-disable-next-line no-bitwise
+        buffer[buffer.length - 1] >>>= 1; // force 63-bit
+    }
+    // The `.toString` function is intentionally similar to Number and BigInt `.toString` method.
+    //
+    // JavaScript numbers can represent integers up to 48 bits, this is why we need two of them to
+    // represent a 64 bits identifier. But BigInts don't have this limitation and can represent larger
+    // integer values.
+    //
+    // In the future, when we drop browsers without BigInts support, we could use BigInts directly
+    // represent identifiers by simply returning a BigInt from this function (as all we need is a
+    // value with a `.toString` method).
+    //
+    // Examples:
+    //   const buffer = getCrypto().getRandomValues(new Uint32Array(2))
+    //   return BigInt(buffer[0]) + BigInt(buffer[1]) << 32n
+    //
+    //   // Alternative with BigUint64Array (different Browser support than plain bigints!):
+    //   return crypto.getRandomValues(new BigUint64Array(1))[0]
+    //
+    // For now, let's keep using two plain numbers as having two different implementations (one for
+    // browsers with BigInt support and one for older browsers) don't bring much value.
+    return {
+        toString(radix = 10) {
+            let high = buffer[1];
+            let low = buffer[0];
+            let str = '';
+            do {
+                const mod = (high % radix) * 4294967296 + low;
+                high = Math.floor(high / radix);
+                low = Math.floor(mod / radix);
+                str = (mod % radix).toString(radix) + str;
+            } while (high || low);
+            return str;
+        },
+    };
+}
+export function toPaddedHexadecimalString(id) {
+    return id.toString(16).padStart(16, '0');
+}
+//# sourceMappingURL=identifier.js.map

package/esm/domain/tracing/identifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifier.js","sourceRoot":"","sources":["../../../src/domain/tracing/identifier.ts"],"names":[],"mappings":"AAcA,MAAM,UAAU,qBAAqB;IACnC,OAAO,gBAAgB,CAAC,EAAE,CAAoB,CAAA;AAChD,CAAC;AAED,MAAM,UAAU,oBAAoB;IAClC,OAAO,gBAAgB,CAAC,EAAE,CAAmB,CAAA;AAC/C,CAAC;AAED,SAAS,gBAAgB,CAAC,IAAa;IACrC,MAAM,MAAM,GAAG,MAAM,CAAC,eAAe,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;IACzD,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,sCAAsC;QACtC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAA,CAAC,eAAe;IAClD,CAAC;IAED,6FAA6F;IAC7F,EAAE;IACF,8FAA8F;IAC9F,kGAAkG;IAClG,kBAAkB;IAClB,EAAE;IACF,8FAA8F;IAC9F,6FAA6F;IAC7F,oCAAoC;IACpC,EAAE;IACF,YAAY;IACZ,mEAAmE;IACnE,wDAAwD;IACxD,EAAE;IACF,wFAAwF;IACxF,4DAA4D;IAC5D,EAAE;IACF,+FAA+F;IAC/F,mFAAmF;IACnF,OAAO;QACL,QAAQ,CAAC,KAAK,GAAG,EAAE;YACjB,IAAI,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;YACpB,IAAI,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;YACnB,IAAI,GAAG,GAAG,EAAE,CAAA;YAEZ,GAAG,CAAC;gBACF,MAAM,GAAG,GAAG,CAAC,IAAI,GAAG,KAAK,CAAC,GAAG,UAAU,GAAG,GAAG,CAAA;gBAC7C,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,CAAA;gBAC/B,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,CAAA;gBAC7B,GAAG,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,GAAG,CAAA;YAC3C,CAAC,QAAQ,IAAI,IAAI,GAAG,EAAC;YAErB,OAAO,GAAG,CAAA;QACZ,CAAC;KACF,CAAA;AACH,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,EAAkB;IAC1D,OAAO,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAA;AAC1C,CAAC"}

package/esm/domain/tracing/sampler.d.ts

@@ -0,0 +1,10 @@
+export declare function isTraceSampled(sessionId: string, sampleRate: number): boolean;
+export declare function resetSampleDecisionCache(): void;
+/**
+ * Perform sampling using the Knuth factor method. This method offer consistent sampling result
+ * based on the provided identifier.
+ *
+ * @param identifier The identifier to use for sampling.
+ * @param sampleRate The sample rate in percentage between 0 and 100.
+ */
+export declare function sampleUsingKnuthFactor(identifier: bigint, sampleRate: number): boolean;

package/esm/domain/tracing/sampler.js

@@ -0,0 +1,64 @@
+import { performDraw } from '@kubesense/kubesense-browser-core';
+let sampleDecisionCache;
+export function isTraceSampled(sessionId, sampleRate) {
+    // Shortcuts for common cases. This is not strictly necessary, but it makes the code faster for
+    // customers willing to ingest all traces.
+    if (sampleRate === 100) {
+        return true;
+    }
+    if (sampleRate === 0) {
+        return false;
+    }
+    if (sampleDecisionCache && sessionId === sampleDecisionCache.sessionId) {
+        return sampleDecisionCache.decision;
+    }
+    let decision;
+    // @ts-expect-error BigInt might not be defined in every browser we support
+    if (window.BigInt) {
+        decision = sampleUsingKnuthFactor(BigInt(`0x${sessionId.split('-')[4]}`), sampleRate);
+    }
+    else {
+        // For simplicity, we don't use consistent sampling for browser without BigInt support
+        // TODO: remove this when all browser we support have BigInt support
+        decision = performDraw(sampleRate);
+    }
+    sampleDecisionCache = { sessionId, decision };
+    return decision;
+}
+// Exported for tests
+export function resetSampleDecisionCache() {
+    sampleDecisionCache = undefined;
+}
+/**
+ * Perform sampling using the Knuth factor method. This method offer consistent sampling result
+ * based on the provided identifier.
+ *
+ * @param identifier The identifier to use for sampling.
+ * @param sampleRate The sample rate in percentage between 0 and 100.
+ */
+export function sampleUsingKnuthFactor(identifier, sampleRate) {
+    // The formula is:
+    //
+    //   (identifier * knuthFactor) % 2^64 < sampleRate * 2^64
+    //
+    // Because JavaScript numbers are 64-bit floats, we can't represent 64-bit integers, and the
+    // modulo would be incorrect. Thus, we are using BigInts here.
+    //
+    // Implementation in other languages:
+    // * Go     https://github.com/DataDog/kubesense-trace-go/blob/ec6fbb1f2d517b7b8e69961052adf7136f3af773/ddtrace/tracer/sampler.go#L86-L91
+    // * Python https://github.com/DataDog/kubesense-trace-py/blob/0cee2f066fb6e79aa15947c1514c0f406dea47c5/ddtrace/sampling_rule.py#L197
+    // * Ruby   https://github.com/DataDog/kubesense-trace-rb/blob/1a6e255cdcb7e7e22235ea5955f90f6dfa91045d/lib/kubesense/tracing/sampling/rate_sampler.rb#L42
+    // * C++    https://github.com/DataDog/kubesense-trace-cpp/blob/159629edc438ae45f2bb318eb7bd51abd05e94b5/src/kubesense/trace_sampler.cpp#L58
+    // * Java   https://github.com/DataDog/kubesense-trace-java/blob/896dd6b380533216e0bdee59614606c8272d313e/kubesense-trace-core/src/main/java/kubesense/trace/common/sampling/DeterministicSampler.java#L48
+    //
+    // Note: All implementations have slight variations. Some of them use '<=' instead of '<', and
+    // use `sampleRate * 2^64 - 1` instead of `sampleRate * 2^64`. The following implementation
+    // should adhere to the spec and is a bit simpler than using a 2^64-1 limit as there are less
+    // BigInt arithmetic to write. In practice this does not matter, as we are using floating point
+    // numbers in the end, and Number(2n**64n-1n) === Number(2n**64n).
+    const knuthFactor = BigInt('1111111111111111111');
+    const twoPow64 = BigInt('0x10000000000000000'); // 2n ** 64n
+    const hash = (identifier * knuthFactor) % twoPow64;
+    return Number(hash) <= (sampleRate / 100) * Number(twoPow64);
+}
+//# sourceMappingURL=sampler.js.map

package/esm/domain/tracing/sampler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler.js","sourceRoot":"","sources":["../../../src/domain/tracing/sampler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAE/D,IAAI,mBAAyE,CAAA;AAE7E,MAAM,UAAU,cAAc,CAAC,SAAiB,EAAE,UAAkB;IAClE,+FAA+F;IAC/F,0CAA0C;IAC1C,IAAI,UAAU,KAAK,GAAG,EAAE,CAAC;QACvB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,mBAAmB,IAAI,SAAS,KAAK,mBAAmB,CAAC,SAAS,EAAE,CAAC;QACvE,OAAO,mBAAmB,CAAC,QAAQ,CAAA;IACrC,CAAC;IAED,IAAI,QAAiB,CAAA;IACrB,2EAA2E;IAC3E,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAClB,QAAQ,GAAG,sBAAsB,CAAC,MAAM,CAAC,KAAK,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAA;IACvF,CAAC;SAAM,CAAC;QACN,sFAAsF;QACtF,oEAAoE;QACpE,QAAQ,GAAG,WAAW,CAAC,UAAU,CAAC,CAAA;IACpC,CAAC;IACD,mBAAmB,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAA;IAC7C,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED,qBAAqB;AACrB,MAAM,UAAU,wBAAwB;IACtC,mBAAmB,GAAG,SAAS,CAAA;AACjC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CAAC,UAAkB,EAAE,UAAkB;IAC3E,kBAAkB;IAClB,EAAE;IACF,0DAA0D;IAC1D,EAAE;IACF,4FAA4F;IAC5F,8DAA8D;IAC9D,EAAE;IACF,qCAAqC;IACrC,yIAAyI;IACzI,qIAAqI;IACrI,0JAA0J;IAC1J,4IAA4I;IAC5I,0MAA0M;IAC1M,EAAE;IACF,8FAA8F;IAC9F,2FAA2F;IAC3F,6FAA6F;IAC7F,+FAA+F;IAC/F,kEAAkE;IAClE,MAAM,WAAW,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAA;IACjD,MAAM,QAAQ,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAA,CAAC,YAAY;IAC3D,MAAM,IAAI,GAAG,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,QAAQ,CAAA;IAClD,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;AAC9D,CAAC"}

package/esm/domain/tracing/tracer.d.ts

@@ -0,0 +1,30 @@
+import type { ContextManager } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../configuration';
+import type { RumFetchResolveContext, RumFetchStartContext, RumXhrCompleteContext, RumXhrStartContext } from '../requestCollection';
+import type { RumSessionManager } from '../rumSessionManager';
+import type { TracingOption } from './tracer.types';
+export interface Tracer {
+    traceFetch: (context: Partial<RumFetchStartContext>) => void;
+    traceXhr: (context: Partial<RumXhrStartContext>, xhr: XMLHttpRequest) => void;
+    clearTracingIfNeeded: (context: RumFetchResolveContext | RumXhrCompleteContext) => void;
+}
+export declare function isTracingOption(item: unknown): item is TracingOption;
+/**
+ * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the
+ * request did not reach the server, but the browser does not expose this. So, we clear tracing
+ * information if the request ended with status 0 without being aborted by the application.
+ *
+ * Reasoning:
+ *
+ * * Applications are usually aborting requests after a bit of time, for example when the user is
+ * typing (autocompletion) or navigating away (in a SPA). With a performant device and good
+ * network conditions, the request is likely to reach the server before being canceled.
+ *
+ * * Requests aborted otherwise (ex: lack of internet, CORS issue, blocked by a privacy extension)
+ * are likely to finish quickly and without reaching the server.
+ *
+ * Of course, it might not be the case every time, but it should limit having incomplete traces a
+ * bit.
+ * */
+export declare function clearTracingIfNeeded(context: RumFetchResolveContext | RumXhrCompleteContext): void;
+export declare function startTracer(configuration: RumConfiguration, sessionManager: RumSessionManager, userContext: ContextManager, accountContext: ContextManager): Tracer;

package/esm/domain/tracing/tracer.js

@@ -0,0 +1,156 @@
+import { objectEntries, shallowClone, getType, isMatchOption, matchList, TraceContextInjection, } from '@kubesense/kubesense-browser-core';
+import { isSampled } from '../sampler/sampler';
+import { createSpanIdentifier, createTraceIdentifier, toPaddedHexadecimalString } from './identifier';
+export function isTracingOption(item) {
+    const expectedItem = item;
+    return (getType(expectedItem) === 'object' &&
+        isMatchOption(expectedItem.match) &&
+        Array.isArray(expectedItem.propagatorTypes));
+}
+/**
+ * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the
+ * request did not reach the server, but the browser does not expose this. So, we clear tracing
+ * information if the request ended with status 0 without being aborted by the application.
+ *
+ * Reasoning:
+ *
+ * * Applications are usually aborting requests after a bit of time, for example when the user is
+ * typing (autocompletion) or navigating away (in a SPA). With a performant device and good
+ * network conditions, the request is likely to reach the server before being canceled.
+ *
+ * * Requests aborted otherwise (ex: lack of internet, CORS issue, blocked by a privacy extension)
+ * are likely to finish quickly and without reaching the server.
+ *
+ * Of course, it might not be the case every time, but it should limit having incomplete traces a
+ * bit.
+ * */
+export function clearTracingIfNeeded(context) {
+    if (context.status === 0 && !context.isAborted) {
+        context.traceId = undefined;
+        context.spanId = undefined;
+        context.traceSampled = undefined;
+    }
+}
+export function startTracer(configuration, sessionManager, userContext, accountContext) {
+    return {
+        clearTracingIfNeeded,
+        traceFetch: (context) => injectHeadersIfTracingAllowed(configuration, context, sessionManager, userContext, accountContext, (tracingHeaders) => {
+            var _a;
+            if (context.input instanceof Request && !((_a = context.init) === null || _a === void 0 ? void 0 : _a.headers)) {
+                context.input = new Request(context.input);
+                Object.keys(tracingHeaders).forEach((key) => {
+                    ;
+                    context.input.headers.append(key, tracingHeaders[key]);
+                });
+            }
+            else {
+                context.init = shallowClone(context.init);
+                const headers = [];
+                if (context.init.headers instanceof Headers) {
+                    context.init.headers.forEach((value, key) => {
+                        headers.push([key, value]);
+                    });
+                }
+                else if (Array.isArray(context.init.headers)) {
+                    context.init.headers.forEach((header) => {
+                        headers.push(header);
+                    });
+                }
+                else if (context.init.headers) {
+                    Object.keys(context.init.headers).forEach((key) => {
+                        headers.push([key, context.init.headers[key]]);
+                    });
+                }
+                context.init.headers = headers.concat(objectEntries(tracingHeaders));
+            }
+        }),
+        traceXhr: (context, xhr) => injectHeadersIfTracingAllowed(configuration, context, sessionManager, userContext, accountContext, (tracingHeaders) => {
+            Object.keys(tracingHeaders).forEach((name) => {
+                xhr.setRequestHeader(name, tracingHeaders[name]);
+            });
+        }),
+    };
+}
+function injectHeadersIfTracingAllowed(configuration, context, sessionManager, userContext, accountContext, inject) {
+    const session = sessionManager.findTrackedSession();
+    if (!session) {
+        return;
+    }
+    const tracingOption = configuration.allowedTracingUrls.find((tracingOption) => matchList([tracingOption.match], context.url, true));
+    if (!tracingOption) {
+        return;
+    }
+    const traceSampled = isSampled(session.id, configuration.traceSampleRate);
+    const shouldInjectHeaders = traceSampled || configuration.traceContextInjection === TraceContextInjection.ALL;
+    if (!shouldInjectHeaders) {
+        return;
+    }
+    context.traceSampled = traceSampled;
+    context.traceId = createTraceIdentifier();
+    context.spanId = createSpanIdentifier();
+    inject(makeTracingHeaders(context.traceId, context.spanId, context.traceSampled, session.id, tracingOption.propagatorTypes, userContext, accountContext, configuration));
+}
+/**
+ * When trace is not sampled, set priority to '0' instead of not adding the tracing headers
+ * to prepare the implementation for sampling delegation.
+ */
+function makeTracingHeaders(traceId, spanId, traceSampled, sessionId, propagatorTypes, userContext, accountContext, configuration) {
+    const tracingHeaders = {};
+    propagatorTypes.forEach((propagatorType) => {
+        switch (propagatorType) {
+            case 'kubesense': {
+                Object.assign(tracingHeaders, {
+                    'x-kubesense-origin': 'rum',
+                    'x-kubesense-parent-id': spanId.toString(),
+                    'x-kubesense-sampling-priority': traceSampled ? '1' : '0',
+                    'x-kubesense-trace-id': traceId.toString(),
+                });
+                break;
+            }
+            // https://www.w3.org/TR/trace-context/
+            case 'tracecontext': {
+                Object.assign(tracingHeaders, {
+                    traceparent: `00-0000000000000000${toPaddedHexadecimalString(traceId)}-${toPaddedHexadecimalString(spanId)}-0${traceSampled ? '1' : '0'}`,
+                    tracestate: `dd=s:${traceSampled ? '1' : '0'};o:rum`,
+                });
+                break;
+            }
+            // https://github.com/openzipkin/b3-propagation
+            case 'b3': {
+                Object.assign(tracingHeaders, {
+                    b3: `${toPaddedHexadecimalString(traceId)}-${toPaddedHexadecimalString(spanId)}-${traceSampled ? '1' : '0'}`,
+                });
+                break;
+            }
+            case 'b3multi': {
+                Object.assign(tracingHeaders, {
+                    'X-B3-TraceId': toPaddedHexadecimalString(traceId),
+                    'X-B3-SpanId': toPaddedHexadecimalString(spanId),
+                    'X-B3-Sampled': traceSampled ? '1' : '0',
+                });
+                break;
+            }
+        }
+    });
+    if (configuration.propagateTraceBaggage) {
+        const baggageItems = {
+            'session.id': sessionId,
+        };
+        const userId = userContext.getContext().id;
+        if (typeof userId === 'string') {
+            baggageItems['user.id'] = userId;
+        }
+        const accountId = accountContext.getContext().id;
+        if (typeof accountId === 'string') {
+            baggageItems['account.id'] = accountId;
+        }
+        const baggageHeader = Object.entries(baggageItems)
+            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+            .join(',');
+        if (baggageHeader) {
+            tracingHeaders['baggage'] = baggageHeader;
+        }
+    }
+    return tracingHeaders;
+}
+//# sourceMappingURL=tracer.js.map