@dynatrace/rum-javascript-sdk 1.329.2

package/dist/api/type-guards/is-valid-agent.js

@@ -0,0 +1,4 @@
+export function isValidAgent(agent) {
+    return typeof agent === "object" && !!agent && "sendEvent" in agent;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtdmFsaWQtYWdlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zb3VyY2UvYXBpL3R5cGUtZ3VhcmRzL2lzLXZhbGlkLWFnZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSxZQUFZLENBQUMsS0FBYztJQUN2QyxPQUFPLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxDQUFDLENBQUMsS0FBSyxJQUFJLFdBQVcsSUFBSSxLQUFLLENBQUM7QUFDeEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgZHluYXRyYWNlIGFzIER0QXBpIH0gZnJvbSBcIi4uLy4uL3R5cGVzL2FwaS9keW5hdHJhY2UtYXBpLXR5cGVzLmpzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBpc1ZhbGlkQWdlbnQoYWdlbnQ6IHVua25vd24pOiBhZ2VudCBpcyB0eXBlb2YgRHRBcGkge1xuICAgIHJldHVybiB0eXBlb2YgYWdlbnQgPT09IFwib2JqZWN0XCIgJiYgISFhZ2VudCAmJiBcInNlbmRFdmVudFwiIGluIGFnZW50O1xufVxuIl19

package/dist/api/user-actions.d.ts

@@ -0,0 +1,62 @@
+import type { UserActionStartOptions, UserActionTracker } from "../types/index.js";
+/**
+ * Safe wrapper for {@link dynatrace.userActions.create} which reverts to a noop if RUM JavaScript or the user actions module is not available.
+ *
+ * @param options An optional options object to configure the user action.
+ * @returns       A `UserActionTracker` object that can be started and finished, or `undefined` if the user actions module is not enabled.
+ *
+ * @example
+ * ```typescript
+ * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
+ * const userAction = userActions.create({ autoClose: false });
+ * // perform work
+ * userAction?.finish();
+ * ```
+ */
+export declare function create(options?: UserActionStartOptions): UserActionTracker | undefined;
+/**
+ * Safe wrapper for {@link dynatrace.userActions.subscribe} which reverts to a noop if RUM JavaScript or the user actions module is not available.
+ *
+ * @param subscriber A callback function that is called whenever Dynatrace creates a new user action.
+ * @returns          An unsubscriber function to remove the subscription, or undefined if the user actions module is not enabled.
+ *
+ * @example
+ * ```typescript
+ * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
+ * const unsubscribe = userActions.subscribe((userAction) => {
+ *     console.log('New user action created');
+ *     userAction.autoClose = false;
+ * });
+ * // later
+ * unsubscribe?.();
+ * ```
+ */
+export declare function subscribe(subscriber: (userAction: UserActionTracker) => void): (() => void) | undefined;
+/**
+ * Safe wrapper for {@link dynatrace.userActions.setAutomaticDetection} which reverts to a noop if RUM JavaScript or the user actions module is not available.
+ *
+ * @param automaticDetection If false, disables automatic user action detection, otherwise enables it.
+ *
+ * @example
+ * ```typescript
+ * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
+ * userActions.setAutomaticDetection(false);
+ * // manual user action handling
+ * ```
+ */
+export declare function setAutomaticDetection(automaticDetection: boolean): void;
+/**
+ * Safe wrapper for {@link dynatrace.userActions.current} which returns undefined if RUM JavaScript or the user actions module is not available.
+ *
+ * @returns The current user action, or `undefined` if no user action is in progress or the user actions module is not enabled.
+ *
+ * @example
+ * ```typescript
+ * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
+ * const currentAction = userActions.getCurrent();
+ * if (currentAction) {
+ *     currentAction.autoClose = false;
+ * }
+ * ```
+ */
+export declare function getCurrent(): UserActionTracker | undefined;

package/dist/api/user-actions.js

@@ -0,0 +1,99 @@
+import { getGlobal } from "./global-adapter.js";
+import { isValidAgent } from "./type-guards/is-valid-agent.js";
+import { log } from "./logging.js";
+/**
+ * Safe wrapper for {@link dynatrace.userActions.create} which reverts to a noop if RUM JavaScript or the user actions module is not available.
+ *
+ * @param options An optional options object to configure the user action.
+ * @returns       A `UserActionTracker` object that can be started and finished, or `undefined` if the user actions module is not enabled.
+ *
+ * @example
+ * ```typescript
+ * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
+ * const userAction = userActions.create({ autoClose: false });
+ * // perform work
+ * userAction?.finish();
+ * ```
+ */
+export function create(options) {
+    return guardUserActions((userActions) => {
+        return userActions.create(options);
+    });
+}
+/**
+ * Safe wrapper for {@link dynatrace.userActions.subscribe} which reverts to a noop if RUM JavaScript or the user actions module is not available.
+ *
+ * @param subscriber A callback function that is called whenever Dynatrace creates a new user action.
+ * @returns          An unsubscriber function to remove the subscription, or undefined if the user actions module is not enabled.
+ *
+ * @example
+ * ```typescript
+ * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
+ * const unsubscribe = userActions.subscribe((userAction) => {
+ *     console.log('New user action created');
+ *     userAction.autoClose = false;
+ * });
+ * // later
+ * unsubscribe?.();
+ * ```
+ */
+export function subscribe(subscriber) {
+    return guardUserActions((userActions) => {
+        return userActions.subscribe(subscriber);
+    });
+}
+/**
+ * Safe wrapper for {@link dynatrace.userActions.setAutomaticDetection} which reverts to a noop if RUM JavaScript or the user actions module is not available.
+ *
+ * @param automaticDetection If false, disables automatic user action detection, otherwise enables it.
+ *
+ * @example
+ * ```typescript
+ * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
+ * userActions.setAutomaticDetection(false);
+ * // manual user action handling
+ * ```
+ */
+export function setAutomaticDetection(automaticDetection) {
+    guardUserActions((userActions) => {
+        userActions.setAutomaticDetection(automaticDetection);
+    });
+}
+/**
+ * Safe wrapper for {@link dynatrace.userActions.current} which returns undefined if RUM JavaScript or the user actions module is not available.
+ *
+ * @returns The current user action, or `undefined` if no user action is in progress or the user actions module is not enabled.
+ *
+ * @example
+ * ```typescript
+ * import * as userActions from "@dynatrace/rum-javascript-sdk/api/user-actions";
+ * const currentAction = userActions.getCurrent();
+ * if (currentAction) {
+ *     currentAction.autoClose = false;
+ * }
+ * ```
+ */
+export function getCurrent() {
+    return guardUserActions((userActions) => {
+        return userActions.current;
+    });
+}
+/**
+ * Safe wrapper for various user actions API functions which reverts to a noop if RUM JavaScript or the user actions module is not available.
+ *
+ * @param fn The function to be executed if the user actions module is available.
+ * @returns  The result of the provided function call if the user actions module is available, otherwise undefined.
+ */
+function guardUserActions(fn) {
+    const globalDt = getGlobal("dynatrace");
+    if (!isValidAgent(globalDt)) {
+        log("dynatrace is not available");
+        return void 0;
+    }
+    if (!globalDt.userActions) {
+        log("dynatrace.userActions module is not available");
+        return void 0;
+    }
+    return fn(globalDt.userActions);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/testing/install.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Fetches the RUM JavaScript from the given environment.
+ *
+ * @param endpointUrl The location to fetch the script from, e.g. "https://{your-environment-id}.live.dynatrace.com" or "https://{your-activegate-domain}:9999/e/{your-environment-id}".
+ * @param appId       The RUM application ID to fetch the configuration.
+ * @param token       The authentication token to access the API.
+ * @returns           A promise that resolves with an HTML string containing the RUM JavaScript for insertion into a page.
+ *
+ * @example
+ * const rumJavaScriptHtml = await fetchRumJavaScript("https://myenv.live.dynatrace.com","APPLICATION-EA7C4B59F27D43EB", "dt0c01.abcd.efghijk");
+ * // use the result to write your javascript, e.g. with cheerio:
+ * const $ = cheerio.load(myHtml);
+ * $("head").append(rumJavaScriptHtml);
+ */
+export declare function fetchRumJavaScript(endpointUrl: string, appId: string, token: string): Promise<string>;

package/dist/testing/install.js

@@ -0,0 +1,19 @@
+/**
+ * Fetches the RUM JavaScript from the given environment.
+ *
+ * @param endpointUrl The location to fetch the script from, e.g. "https://{your-environment-id}.live.dynatrace.com" or "https://{your-activegate-domain}:9999/e/{your-environment-id}".
+ * @param appId       The RUM application ID to fetch the configuration.
+ * @param token       The authentication token to access the API.
+ * @returns           A promise that resolves with an HTML string containing the RUM JavaScript for insertion into a page.
+ *
+ * @example
+ * const rumJavaScriptHtml = await fetchRumJavaScript("https://myenv.live.dynatrace.com","APPLICATION-EA7C4B59F27D43EB", "dt0c01.abcd.efghijk");
+ * // use the result to write your javascript, e.g. with cheerio:
+ * const $ = cheerio.load(myHtml);
+ * $("head").append(rumJavaScriptHtml);
+ */
+export async function fetchRumJavaScript(endpointUrl, appId, token) {
+    const response = await fetch(`${endpointUrl}/api/v2/rum/javaScriptTag/${appId}`, { headers: { Authorization: `Api-Token ${token}` } });
+    return response.text();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/testing/test.d.ts

@@ -0,0 +1,111 @@
+export interface WaitForBeaconsOptions {
+    /**
+     * The minimum number of beacon requests to wait for
+     */
+    minCount?: number;
+    /**
+     * The maximum time to wait for beacon requests, in milliseconds - Default: 5_000
+     */
+    timeout?: number;
+}
+export interface ExpectOptions {
+    /**
+     * The maximum time to wait for the event to be sent, in milliseconds - Default: 5_000
+     */
+    timeout?: number;
+}
+export interface DynatraceTesting {
+    /**
+     * Waits for a specified number of beacon requests or until a timeout occurs.
+     *
+     * @param options Configuration options for waiting for beacons
+     * @returns       A promise that resolves with an array of beacon requests
+     */
+    waitForBeacons(options?: WaitForBeaconsOptions): Promise<BeaconRequest[]>;
+    /**
+     * Verifies that a specific event has been sent, optionally within a timeout period.
+     *
+     * @param event   The event to check, represented as a key-value pair object. This uses Playwrights expect(event).toMatchObject.
+     * @param options Configuration options for the verification
+     * @returns       A promise that resolves when the event is confirmed to have been sent
+     */
+    expectToHaveSentEvent(event: Record<string, unknown>, options?: ExpectOptions): Promise<void>;
+    /**
+     * Verifies that a specific event has been sent a specified number of times, optionally within a timeout period.
+     *
+     * @param event   The event to check, represented as a key-value pair object. This uses Playwrights expect(event).toMatchObject.
+     * @param times   The exact number of times the event is expected to have been sent
+     * @param options Configuration options for the verification
+     * @returns       A promise that resolves when the event is confirmed to have been sent the specified number of times
+     */
+    expectToHaveSentEventTimes(event: Record<string, unknown>, times: number, options?: ExpectOptions): Promise<void>;
+    /**
+     * Clears all events and beacons, allowing for subsequent expectations to ignore events that have been sent
+     * in the past. Example:
+     * ```
+     * sendFooEvent();
+     * await dynatraceTesting.expectToHaveSentEventTimes({ foo: "bar" }, 1);
+     * dynatraceTesting.clearEvents();
+     * await dynatraceTesting.expectToHaveSentEventTimes({ foo: "bar" }, 1);
+     * ```
+     */
+    clearEvents(): void;
+}
+export interface BeaconRequest {
+    url: string;
+    body: Record<string, unknown>;
+}
+export interface DynatraceTestingFixture {
+    /**
+     * The testing API providing expect methods.
+     */
+    dynatraceTesting: DynatraceTesting;
+    /**
+     * Configuration to enable Dynatrace testing with a given environment.
+     */
+    dynatraceConfig: DynatraceConfig;
+}
+export interface DynatraceConfig {
+    /**
+     * The URL of the Dynatrace API endpoint to connect to, see
+     * [RUM manual insertion tags API](https://docs.dynatrace.com/docs/discover-dynatrace/references/dynatrace-api/environment-api/rum/rum-manual-insertion-tags)
+     * for details. Example: https://{your-environment-id}.live.dynatrace.com or
+     * https://{your-activegate-domain}/e/{your-environment-id}
+     */
+    endpointUrl: string;
+    /**
+     * The application ID to identify the correct RUM JavaScript to fetch. You can find
+     * this in the URL if you open the Experience Vitals app and select the frontend you
+     * want to test. Example: APPLICATION-ABCDEF0123456789
+     */
+    appId: string;
+    /**
+     * The authentication token for the installation. See
+     * [Tokens and authentication](https://docs.dynatrace.com/docs/discover-dynatrace/references/dynatrace-api/basics/dynatrace-api-authentication).
+     */
+    token: string;
+    /**
+     * Accepts an array of regular expressions to match against Dynatrace-related warnings. By default, these warnings
+     * trigger test fails. If you anticipate warnings and don't want your tests to fail, use this setting to ignore them
+     * by message. Example:
+     * ["invalid property my_app_data\.\\w+[0-9_]*"]
+     */
+    ignoreWarnings?: string[];
+    /**
+     * Dump the array of Dynatrace events into the console in case an assertion fails.
+     */
+    dumpEventsOnFail?: boolean;
+}
+/**
+ * Worker-scoped fixtures for caching RUM JavaScript across tests in the same worker.
+ * This improves performance by avoiding redundant network requests.
+ */
+export interface DynatraceTestingWorkerFixture {
+    /**
+     * Cache for RUM JavaScript snippets, scoped to the worker.
+     *
+     * @internal
+     */
+    rumJavaScriptCache: Map<string, string>;
+}
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & DynatraceTestingFixture, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions & DynatraceTestingWorkerFixture>;

package/dist/testing/test.js

@@ -0,0 +1,229 @@
+import { expect, test as base } from "@playwright/test";
+import { fetchRumJavaScript } from "./install.js";
+import { uncompress } from "snappyjs";
+const DEFAULT_TIMEOUT = 5_000;
+const decoder = new TextDecoder();
+export const test = base.extend({
+    dynatraceConfig: [{
+            appId: "",
+            endpointUrl: "",
+            token: ""
+        }, { option: true }],
+    // eslint-disable-next-line no-empty-pattern -- Playwright requires object destructuring even when no dependencies are needed
+    rumJavaScriptCache: [async ({}, use) => {
+            const cache = new Map();
+            await use(cache);
+        }, { scope: "worker", auto: true, box: true }],
+    dynatraceTesting: async ({ page, dynatraceConfig, rumJavaScriptCache }, use) => {
+        const { endpointUrl, appId, token, ignoreWarnings = [], dumpEventsOnFail = false } = dynatraceConfig;
+        const beacons = [];
+        const events = [];
+        const warnings = [];
+        const ignoreRegexes = ignoreWarnings.map(x => new RegExp(x, "i"));
+        page.on("console", (msg) => {
+            if (msg.text().includes("ynatrace") && !ignoreRegexes.some(regex => regex.test(msg.text()))) {
+                warnings.push(msg.text());
+            }
+        });
+        await setupRumJavaScript();
+        await use({
+            async waitForBeacons(options = {}) {
+                const { minCount = 0, timeout = DEFAULT_TIMEOUT } = options;
+                const start = Date.now();
+                while (beacons.length < minCount && (Date.now() - start) <= timeout) {
+                    if (warnings.length > 0) {
+                        throwWithEventDump("Unexpected Dynatrace API warnings: " + warnings.join("\n"));
+                    }
+                    await wait(100);
+                }
+                if (beacons.length < minCount) {
+                    throwWithEventDump(`Found only ${beacons.length} Dynatrace beacons after timeout of ${timeout}ms, but expected at least ${minCount}.`);
+                }
+                return beacons;
+            },
+            async expectToHaveSentEvent(expectedEvent, options = {}) {
+                const { timeout = DEFAULT_TIMEOUT } = options;
+                const start = Date.now();
+                let lastNonMatch = void 0;
+                let nextCheckIndex = 0;
+                while ((Date.now() - start) <= timeout) {
+                    for (let i = nextCheckIndex; i < events.length; i++) {
+                        const beaconEvent = events[i];
+                        try {
+                            expect(beaconEvent).toMatchObject(expectedEvent);
+                            return;
+                        }
+                        catch {
+                            lastNonMatch = beaconEvent;
+                        }
+                        nextCheckIndex = i + 1;
+                    }
+                    await wait(100);
+                }
+                if (!lastNonMatch) {
+                    throwWithEventDump("Dynatrace didn't send any events.");
+                }
+                console.log(`[Dynatrace Testing] Didn't find matching events.`);
+                expect(lastNonMatch).toMatchObject(expectedEvent);
+            },
+            async expectToHaveSentEventTimes(expectedEvent, times, options = {}) {
+                const { timeout = DEFAULT_TIMEOUT } = options;
+                const start = Date.now();
+                let lastNonMatch = void 0;
+                let nextCheckIndex = 0;
+                let foundTimes = 0;
+                while ((Date.now() - start) <= timeout) {
+                    for (let i = nextCheckIndex; i < events.length; i++) {
+                        const beaconEvent = events[i];
+                        try {
+                            expect(beaconEvent).toMatchObject(expectedEvent);
+                            foundTimes++;
+                        }
+                        catch {
+                            lastNonMatch = beaconEvent;
+                        }
+                        nextCheckIndex = i + 1;
+                    }
+                    if (foundTimes === times) {
+                        return;
+                    }
+                    if (foundTimes > times) {
+                        throwWithEventDump(`Expected ${times} event occurrences, found ${foundTimes}.`);
+                    }
+                    await wait(100);
+                }
+                if (!lastNonMatch) {
+                    throwWithEventDump("Dynatrace didn't send any events");
+                }
+                if (foundTimes < times) {
+                    throwWithEventDump(`Didn't find the expected amount of ${times} matching events, found ${foundTimes}.`);
+                }
+                expect(lastNonMatch).toMatchObject(expectedEvent);
+            },
+            clearEvents() {
+                events.length = 0;
+                beacons.length = 0;
+            }
+        });
+        /**
+         * Throws an error with a custom message. If event dumping is enabled, logs the received Dynatrace events before
+         * throwing the error.
+         *
+         * @param message The error message to be thrown
+         */
+        function throwWithEventDump(message) {
+            if (dumpEventsOnFail) {
+                console.log("Received Dynatrace events:", events);
+            }
+            throw new Error(message);
+        }
+        async function setupRumJavaScript() {
+            // Fetch RUM JavaScript once and cache it
+            const cacheKey = `${endpointUrl}:${appId}`;
+            let rum = rumJavaScriptCache.get(cacheKey);
+            let beaconUri;
+            if (!rum) {
+                rum = await fetchRumJavaScriptContent(endpointUrl, appId, token);
+                beaconUri = extractBeaconUri(rum);
+                rumJavaScriptCache.set(cacheKey, rum);
+                rumJavaScriptCache.set(`${cacheKey}:beaconUri`, beaconUri);
+            }
+            else {
+                beaconUri = rumJavaScriptCache.get(`${cacheKey}:beaconUri`);
+                if (!beaconUri) {
+                    throw new Error("Failed to retrieve beaconUri from cache.");
+                }
+            }
+            // Listen to network requests to capture beacon data
+            // This approach doesn't interfere with user-defined routes
+            page.on("request", (request) => {
+                const url = request.url();
+                // Check if this is a beacon request matching the extracted beaconUri
+                if (!(beaconUri && url.startsWith(beaconUri) && url.includes("ty=js"))) {
+                    return;
+                }
+                const beaconBodyString = extractBeaconBody(request, url);
+                if (!beaconBodyString) {
+                    return;
+                }
+                try {
+                    const beaconBody = JSON.parse(beaconBodyString);
+                    beacons.push({
+                        url: url,
+                        body: beaconBody
+                    });
+                    events.push(...beaconBody.data.events);
+                }
+                catch (error) {
+                    console.error("[Dynatrace Testing] Failed to parse beacon body:", error);
+                }
+            });
+            // Use addInitScript to inject RUM script tag before any page scripts execute
+            await page.addInitScript(rum);
+        }
+    }
+});
+/**
+ * Fetches the RUM JavaScript content from the Dynatrace API endpoint.
+ *
+ * @param endpointUrl The URL of the Dynatrace API endpoint
+ * @param appId       The application ID to identify the correct RUM JavaScript
+ * @param token       The authentication token for the installation
+ * @returns           A promise that resolves to the RUM JavaScript content
+ */
+async function fetchRumJavaScriptContent(endpointUrl, appId, token) {
+    const rumApiResult = await fetchRumJavaScript(endpointUrl, appId, token);
+    if (!rumApiResult.includes("_complete.js")) {
+        throw new Error("Dynatrace received unexpected RUM JavaScript when requesting the JavaScript Tag via API.");
+    }
+    // Extract the src URL from the script tag
+    const srcMatch = rumApiResult.match(/src="([^"]+)"/);
+    if (!srcMatch) {
+        throw new Error("Failed to extract src URL from RUM JavaScript tag.");
+    }
+    const scriptUrl = srcMatch[1];
+    // Fetch the actual JavaScript content
+    const scriptResponse = await fetch(scriptUrl);
+    return scriptResponse.text();
+}
+/**
+ * Extracts the beacon URI from the RUM JavaScript content.
+ *
+ * @param rum The RUM JavaScript content to extract the beacon URI from
+ * @returns   The extracted beacon URI
+ */
+function extractBeaconUri(rum) {
+    // Extract the beaconUri from the JavaScript content
+    const beaconUriMatch = rum.match(/"beaconUri":"([^"]+)"/);
+    if (!beaconUriMatch) {
+        throw new Error("Failed to extract beaconUri from RUM JavaScript content.");
+    }
+    return beaconUriMatch[1];
+}
+/**
+ * Waits for a given time and resolves upon timeout.
+ *
+ * @param time The time to wait in milliseconds
+ * @returns    A resolved promise when the time ran out
+ */
+function wait(time) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, time);
+    });
+}
+/**
+ * Extracts the body of a beacon request, optionally decompressing it if the URL indicates compressed data.
+ *
+ * @param request The request object containing the beacon data
+ * @param url     The URL of the request to check for specific compression indicators
+ * @returns       The extracted body of the beacon request, or null if no request body is present
+ */
+function extractBeaconBody(request, url) {
+    const buffer = request.postDataBuffer();
+    if (url.includes("co=snappy") && buffer) {
+        const uint8Data = uncompress(buffer);
+        return decoder.decode(uint8Data);
+    }
+    return request.postData();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["../../source/testing/test.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Request } from \"@playwright/test\";\nimport {\n    expect,\n    test as base\n} from \"@playwright/test\";\nimport { fetchRumJavaScript } from \"./install.js\";\nimport { uncompress } from \"snappyjs\";\n\nexport interface WaitForBeaconsOptions {\n    /**\n     * The minimum number of beacon requests to wait for\n     */\n    minCount?: number;\n    /**\n     * The maximum time to wait for beacon requests, in milliseconds - Default: 5_000\n     */\n    timeout?: number;\n}\n\nexport interface ExpectOptions {\n    /**\n     * The maximum time to wait for the event to be sent, in milliseconds - Default: 5_000\n     */\n    timeout?: number;\n}\n\nexport interface DynatraceTesting {\n    /**\n     * Waits for a specified number of beacon requests or until a timeout occurs.\n     *\n     * @param options Configuration options for waiting for beacons\n     * @returns       A promise that resolves with an array of beacon requests\n     */\n    waitForBeacons(options?: WaitForBeaconsOptions): Promise<BeaconRequest[]>;\n\n    /**\n     * Verifies that a specific event has been sent, optionally within a timeout period.\n     *\n     * @param event   The event to check, represented as a key-value pair object. This uses Playwrights expect(event).toMatchObject.\n     * @param options Configuration options for the verification\n     * @returns       A promise that resolves when the event is confirmed to have been sent\n     */\n    expectToHaveSentEvent(event: Record<string, unknown>, options?: ExpectOptions): Promise<void>;\n\n    /**\n     * Verifies that a specific event has been sent a specified number of times, optionally within a timeout period.\n     *\n     * @param event   The event to check, represented as a key-value pair object. This uses Playwrights expect(event).toMatchObject.\n     * @param times   The exact number of times the event is expected to have been sent\n     * @param options Configuration options for the verification\n     * @returns       A promise that resolves when the event is confirmed to have been sent the specified number of times\n     */\n    expectToHaveSentEventTimes(event: Record<string, unknown>, times: number, options?: ExpectOptions): Promise<void>;\n\n    /**\n     * Clears all events and beacons, allowing for subsequent expectations to ignore events that have been sent\n     * in the past. Example:\n     * ```\n     * sendFooEvent();\n     * await dynatraceTesting.expectToHaveSentEventTimes({ foo: \"bar\" }, 1);\n     * dynatraceTesting.clearEvents();\n     * await dynatraceTesting.expectToHaveSentEventTimes({ foo: \"bar\" }, 1);\n     * ```\n     */\n    clearEvents(): void;\n}\n\nexport interface BeaconRequest {\n    url: string;\n    body: Record<string, unknown>;\n}\n\nconst DEFAULT_TIMEOUT = 5_000;\n\nconst decoder = new TextDecoder();\n\nexport interface DynatraceTestingFixture {\n    /**\n     * The testing API providing expect methods.\n     */\n    dynatraceTesting: DynatraceTesting;\n\n    /**\n     * Configuration to enable Dynatrace testing with a given environment.\n     */\n    dynatraceConfig: DynatraceConfig;\n}\n\nexport interface DynatraceConfig {\n    /**\n     * The URL of the Dynatrace API endpoint to connect to, see\n     * [RUM manual insertion tags API](https://docs.dynatrace.com/docs/discover-dynatrace/references/dynatrace-api/environment-api/rum/rum-manual-insertion-tags)\n     * for details. Example: https://{your-environment-id}.live.dynatrace.com or\n     * https://{your-activegate-domain}/e/{your-environment-id}\n     */\n    endpointUrl: string;\n\n    /**\n     * The application ID to identify the correct RUM JavaScript to fetch. You can find\n     * this in the URL if you open the Experience Vitals app and select the frontend you\n     * want to test. Example: APPLICATION-ABCDEF0123456789\n     */\n    appId: string;\n\n    /**\n     * The authentication token for the installation. See\n     * [Tokens and authentication](https://docs.dynatrace.com/docs/discover-dynatrace/references/dynatrace-api/basics/dynatrace-api-authentication).\n     */\n    token: string;\n\n    /**\n     * Accepts an array of regular expressions to match against Dynatrace-related warnings. By default, these warnings\n     * trigger test fails. If you anticipate warnings and don't want your tests to fail, use this setting to ignore them\n     * by message. Example:\n     * [\"invalid property my_app_data\\.\\\\w+[0-9_]*\"]\n     */\n    ignoreWarnings?: string[];\n\n    /**\n     * Dump the array of Dynatrace events into the console in case an assertion fails.\n     */\n    dumpEventsOnFail?: boolean;\n}\n\n/**\n * Worker-scoped fixtures for caching RUM JavaScript across tests in the same worker.\n * This improves performance by avoiding redundant network requests.\n */\nexport interface DynatraceTestingWorkerFixture {\n    /**\n     * Cache for RUM JavaScript snippets, scoped to the worker.\n     *\n     * @internal\n     */\n    rumJavaScriptCache: Map<string, string>;\n}\n\nexport const test = base.extend<DynatraceTestingFixture, DynatraceTestingWorkerFixture>({\n    dynatraceConfig: [{\n        appId: \"\",\n        endpointUrl: \"\",\n        token: \"\"\n    }, { option: true }],\n\n    // eslint-disable-next-line no-empty-pattern -- Playwright requires object destructuring even when no dependencies are needed\n    rumJavaScriptCache: [async ({ }, use) => { // NOSONAR\n        const cache = new Map<string, string>();\n        await use(cache);\n    }, { scope: \"worker\", auto: true, box: true }],\n\n    dynatraceTesting: async ({ page, dynatraceConfig, rumJavaScriptCache }, use) => {\n        const { endpointUrl, appId, token, ignoreWarnings = [], dumpEventsOnFail = false } = dynatraceConfig;\n        const beacons: { url: string, body: Record<string, unknown> }[] = [];\n        const events: Record<string, unknown>[] = [];\n        const warnings: string[] = [];\n        const ignoreRegexes = ignoreWarnings.map(x => new RegExp(x, \"i\"));\n\n        page.on(\"console\", (msg) => {\n            if (msg.text().includes(\"ynatrace\") && !ignoreRegexes.some(regex => regex.test(msg.text()))) {\n                warnings.push(msg.text());\n            }\n        });\n\n        await setupRumJavaScript();\n\n        await use({\n            async waitForBeacons(options: WaitForBeaconsOptions = {}): Promise<BeaconRequest[]> {\n                const { minCount = 0, timeout = DEFAULT_TIMEOUT } = options;\n                const start = Date.now();\n\n                while (beacons.length < minCount && (Date.now() - start) <= timeout) {\n                    if (warnings.length > 0) {\n                        throwWithEventDump(\"Unexpected Dynatrace API warnings: \" + warnings.join(\"\\n\"));\n                    }\n                    await wait(100);\n                }\n\n                if (beacons.length < minCount) {\n                    throwWithEventDump(`Found only ${beacons.length} Dynatrace beacons after timeout of ${timeout}ms, but expected at least ${minCount}.`);\n                }\n\n                return beacons;\n            },\n\n            async expectToHaveSentEvent(\n                expectedEvent: Record<string, unknown>,\n                options: ExpectOptions = {}\n            ): Promise<void> {\n                const { timeout = DEFAULT_TIMEOUT } = options;\n                const start = Date.now();\n                let lastNonMatch: Record<string, unknown> | undefined = void 0;\n                let nextCheckIndex = 0;\n\n                while ((Date.now() - start) <= timeout) {\n                    for (let i = nextCheckIndex; i < events.length; i++) {\n                        const beaconEvent = events[i];\n                        try {\n                            expect(beaconEvent).toMatchObject(expectedEvent);\n                            return;\n                        } catch {\n                            lastNonMatch = beaconEvent;\n                        }\n                        nextCheckIndex = i + 1;\n                    }\n                    await wait(100);\n                }\n\n                if (!lastNonMatch) {\n                    throwWithEventDump(\"Dynatrace didn't send any events.\");\n                }\n\n                console.log(`[Dynatrace Testing] Didn't find matching events.`);\n                expect(lastNonMatch).toMatchObject(expectedEvent);\n            },\n\n            async expectToHaveSentEventTimes(\n                expectedEvent: Record<string, unknown>,\n                times: number,\n                options: ExpectOptions = {}\n            ): Promise<void> {\n                const { timeout = DEFAULT_TIMEOUT } = options;\n                const start = Date.now();\n                let lastNonMatch: Record<string, unknown> | undefined = void 0;\n                let nextCheckIndex = 0;\n                let foundTimes = 0;\n\n                while ((Date.now() - start) <= timeout) {\n                    for (let i = nextCheckIndex; i < events.length; i++) {\n                        const beaconEvent = events[i];\n                        try {\n                            expect(beaconEvent).toMatchObject(expectedEvent);\n                            foundTimes++;\n                        } catch {\n                            lastNonMatch = beaconEvent;\n                        }\n                        nextCheckIndex = i + 1;\n                    }\n                    if (foundTimes === times) {\n                        return;\n                    }\n                    if (foundTimes > times) {\n                        throwWithEventDump(`Expected ${times} event occurrences, found ${foundTimes}.`);\n                    }\n                    await wait(100);\n                }\n\n                if (!lastNonMatch) {\n                    throwWithEventDump(\"Dynatrace didn't send any events\");\n                }\n\n                if (foundTimes < times) {\n                    throwWithEventDump(`Didn't find the expected amount of ${\n                        times\n                    } matching events, found ${foundTimes}.`);\n                }\n\n                expect(lastNonMatch).toMatchObject(expectedEvent);\n            },\n\n            clearEvents(): void {\n                events.length = 0;\n                beacons.length = 0;\n            }\n        });\n\n        /**\n         * Throws an error with a custom message. If event dumping is enabled, logs the received Dynatrace events before\n         * throwing the error.\n         *\n         * @param message The error message to be thrown\n         */\n        function throwWithEventDump(message: string): never {\n            if (dumpEventsOnFail) {\n                console.log(\"Received Dynatrace events:\", events);\n            }\n            throw new Error(message);\n        }\n\n        async function setupRumJavaScript(): Promise<void> {\n            // Fetch RUM JavaScript once and cache it\n            const cacheKey = `${endpointUrl}:${appId}`;\n            let rum = rumJavaScriptCache.get(cacheKey);\n            let beaconUri: string | undefined;\n            if (!rum) {\n                rum = await fetchRumJavaScriptContent(endpointUrl, appId, token);\n                beaconUri = extractBeaconUri(rum);\n\n                rumJavaScriptCache.set(cacheKey, rum);\n                rumJavaScriptCache.set(`${cacheKey}:beaconUri`, beaconUri);\n            } else {\n                beaconUri = rumJavaScriptCache.get(`${cacheKey}:beaconUri`);\n                if (!beaconUri) {\n                    throw new Error(\"Failed to retrieve beaconUri from cache.\");\n                }\n            }\n\n            // Listen to network requests to capture beacon data\n            // This approach doesn't interfere with user-defined routes\n            page.on(\"request\", (request) => {\n                const url = request.url();\n                // Check if this is a beacon request matching the extracted beaconUri\n                if (!(beaconUri && url.startsWith(beaconUri) && url.includes(\"ty=js\"))) {\n                    return;\n                }\n                const beaconBodyString = extractBeaconBody(request, url);\n                if (!beaconBodyString) {\n                    return;\n                }\n                try {\n                    const beaconBody: {\n                        data: {\n                            events: Record<string, unknown>[];\n                        };\n                    } = JSON.parse(beaconBodyString);\n                    beacons.push({\n                        url: url,\n                        body: beaconBody\n                    });\n                    events.push(...beaconBody.data.events);\n                } catch (error) {\n                    console.error(\"[Dynatrace Testing] Failed to parse beacon body:\", error);\n                }\n            });\n\n            // Use addInitScript to inject RUM script tag before any page scripts execute\n            await page.addInitScript(rum);\n        }\n    }\n});\n\n/**\n * Fetches the RUM JavaScript content from the Dynatrace API endpoint.\n *\n * @param endpointUrl The URL of the Dynatrace API endpoint\n * @param appId       The application ID to identify the correct RUM JavaScript\n * @param token       The authentication token for the installation\n * @returns           A promise that resolves to the RUM JavaScript content\n */\nasync function fetchRumJavaScriptContent(endpointUrl: string, appId: string, token: string): Promise<string> {\n    const rumApiResult = await fetchRumJavaScript(endpointUrl, appId, token);\n    if (!rumApiResult.includes(\"_complete.js\")) {\n        throw new Error(\"Dynatrace received unexpected RUM JavaScript when requesting the JavaScript Tag via API.\");\n    }\n\n    // Extract the src URL from the script tag\n    const srcMatch = rumApiResult.match(/src=\"([^\"]+)\"/);\n    if (!srcMatch) {\n        throw new Error(\"Failed to extract src URL from RUM JavaScript tag.\");\n    }\n    const scriptUrl = srcMatch[1];\n\n    // Fetch the actual JavaScript content\n    const scriptResponse = await fetch(scriptUrl);\n    return scriptResponse.text();\n}\n\n/**\n * Extracts the beacon URI from the RUM JavaScript content.\n *\n * @param rum The RUM JavaScript content to extract the beacon URI from\n * @returns   The extracted beacon URI\n */\nfunction extractBeaconUri(rum: string): string {\n    // Extract the beaconUri from the JavaScript content\n    const beaconUriMatch = rum.match(/\"beaconUri\":\"([^\"]+)\"/);\n    if (!beaconUriMatch) {\n        throw new Error(\"Failed to extract beaconUri from RUM JavaScript content.\");\n    }\n    return beaconUriMatch[1];\n}\n\n/**\n * Waits for a given time and resolves upon timeout.\n *\n * @param time The time to wait in milliseconds\n * @returns    A resolved promise when the time ran out\n */\nfunction wait(time: number): Promise<void> {\n    return new Promise((resolve) => {\n        setTimeout(resolve, time);\n    });\n}\n\n/**\n * Extracts the body of a beacon request, optionally decompressing it if the URL indicates compressed data.\n *\n * @param request The request object containing the beacon data\n * @param url     The URL of the request to check for specific compression indicators\n * @returns       The extracted body of the beacon request, or null if no request body is present\n */\nfunction extractBeaconBody(request: Request, url: string): string | null {\n    const buffer = request.postDataBuffer();\n    if (url.includes(\"co=snappy\") && buffer) {\n        const uint8Data = uncompress(buffer);\n        return decoder.decode(uint8Data);\n    }\n    return request.postData();\n}\n"]}