@dynatrace/rum-javascript-sdk 1.329.2

package/dist/api/index.js

@@ -0,0 +1,110 @@
+import { getGlobal } from "./global-adapter.js";
+import { isValidAgent } from "./type-guards/is-valid-agent.js";
+import { log } from "./logging.js";
+export { DynatraceError } from "./dynatrace-error.js";
+/**
+ * Safe wrapper for {@link dynatrace.sendEvent} which reverts to a noop if RUM JavaScript is not available.
+ *
+ * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+ *                     values, otherwise they will be replaced with null. The `fields` need to be serializable
+ *                     using JSON.stringify. The resulting event will be populated with `fields` parameter, and
+ *                     modified with additional properties, thus also empty objects are valid. Only properties
+ *                     prefixed with `event_properties.`, the `duration` property and the `start_time` property are
+ *                     allowed.
+ * @param eventContext An optional context that can be used to manipulate the
+ *                     result event within the modification callback.
+ */
+export function sendEvent(fields, eventContext) {
+    guardDynatrace((dt) => {
+        dt.sendEvent(fields, eventContext);
+    });
+}
+/**
+ * Safe wrapper for {@link dynatrace.addEventModifier} which reverts to a noop if RUM JavaScript is not available.
+ *
+ * @param eventModifier The modifier function to modify a given (readonly) JSONEvent. It receives an optional context
+ *                      depending on the type of event, if available. The returned event must be a new object, otherwise
+ *                      modification will be ignored.
+ * @returns             The unsubscriber function to turn off event modification, or undefined if RUM JavaScript is not available.
+ */
+export function addEventModifier(eventModifier) {
+    return guardDynatrace((dt) => {
+        return dt.addEventModifier(eventModifier);
+    });
+}
+/**
+ * Safe wrapper for {@link dynatrace.runHealthCheck} which reverts to a noop if RUM JavaScript is not available.
+ *
+ * @param config                          The optional configuration object for the health check.
+ * @param config.logVerbose               If true, verbose information is included in the health check.
+ * @param config.returnDiagnosticData     If true, the diagnostic data is returned as array instead of just being logged.
+ * @param config.runDetailedOverrideCheck If true, additional information will be logged to the console for overridden native APIs.
+ * @returns                               A promise that settles as soon as the health check has been performed, or undefined if RUM JavaScript is not available.
+ */
+export function runHealthCheck(config) {
+    return guardDynatrace((dt) => {
+        return dt.runHealthCheck(config);
+    });
+}
+/**
+ * Safe wrapper for {@link dynatrace.identifyUser} which reverts to a noop if RUM JavaScript is not available.
+ *
+ * @param value The name of the user. For example, use a name, userid, or your user's email address.
+ */
+export function identifyUser(value) {
+    guardDynatrace((dt) => {
+        dt.identifyUser(value);
+    });
+}
+/**
+ * Safe wrapper for {@link dynatrace.sendSessionPropertyEvent} which reverts to a noop if RUM JavaScript is not available.
+ *
+ * @param fields Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+ *               values, otherwise they will be replaced with null. The `fields` need to be serializable
+ *               using JSON.stringify. All keys must be prefixed with "session_properties.*" and must contain only
+ *               lower-case characters, numbers, underscores or dots. Each dot must be followed by a lower-case
+ *               character. Each underscore must be followed by a lower-case character or number.
+ */
+export function sendSessionPropertyEvent(fields) {
+    guardDynatrace((dt) => {
+        dt.sendSessionPropertyEvent(fields);
+    });
+}
+/**
+ * This function is only available if the Error module is enabled
+ *
+ * @param error  Must be a valid instance of the Error class. If an invalid value is provided, the error will not be processed or sent.
+ * @param fields Optional: Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+ *               values, otherwise they will be replaced with null. The `fields` need to be serializable
+ *               using JSON.stringify. The resulting event will contain the provided `fields`, and is
+ *               modified with additional properties, thus also empty objects are valid. Only properties
+ *               prefixed with `event_properties.`, the `duration` property and the `start_time` property are
+ *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off.
+ *               All event property keys must contain only alphabetic characters, numbers,
+ *               underscores or dots. Each dot must be followed by an alphabetic character. Each underscore
+ *               must be followed by an alphabetic character or number.
+ */
+export function sendExceptionEvent(error, fields) {
+    guardDynatrace((dt) => {
+        if (!dt.sendExceptionEvent) {
+            log("dynatrace.sendExceptionEvent is not available, the Error module might not be enabled");
+            return;
+        }
+        dt.sendExceptionEvent(error, fields);
+    });
+}
+/**
+ * Safe wrapper for various RUM JavaScript API functions which reverts to a noop if RUM JavaScript is not available.
+ *
+ * @param fn The function to be executed if RUM JavaScript is available.
+ * @returns  The result of the provided function call if RUM JavaScript is available, otherwise undefined.
+ */
+function guardDynatrace(fn) {
+    const globalDt = getGlobal("dynatrace");
+    if (!isValidAgent(globalDt)) {
+        log("dynatrace is not available");
+        return void 0;
+    }
+    return fn(globalDt);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../source/api/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAEnC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,SAAS,CAAC,MAAsC,EAAE,YAAsB;IACpF,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,aAAgG;IAC7H,OAAO,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QACzB,OAAO,EAAE,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAC9C,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAC,MAA0B;IACrD,OAAO,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QACzB,OAAO,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACtC,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAwC;IAC7E,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,EAAE,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAY,EAAE,MAAuC;IACpF,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE;QAClB,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,CAAC;YACzB,GAAG,CAAC,sFAAsF,CAAC,CAAC;YAC5F,OAAO;QACX,CAAC;QACD,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;GAKG;AACH,SAAS,cAAc,CAAkE,EAAK;IAC1F,MAAM,QAAQ,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;IACxC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,GAAG,CAAC,4BAA4B,CAAC,CAAC;QAClC,OAAO,KAAK,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC;AACxB,CAAC","sourcesContent":["import type {\n    ApiCreatedEventPropertiesEvent,\n    ApiCreatedSessionPropertiesEvent,\n    EventContext,\n    HealthCheckConfig,\n    JSONEvent,\n    Unsubscriber\n} from \"../types/index.js\";\nimport { getGlobal } from \"./global-adapter.js\";\nimport { isValidAgent } from \"./type-guards/is-valid-agent.js\";\nimport { log } from \"./logging.js\";\n\nexport { DynatraceError } from \"./dynatrace-error.js\";\n\n/**\n * Safe wrapper for {@link dynatrace.sendEvent} which reverts to a noop if RUM JavaScript is not available.\n *\n * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n *                     values, otherwise they will be replaced with null. The `fields` need to be serializable\n *                     using JSON.stringify. The resulting event will be populated with `fields` parameter, and\n *                     modified with additional properties, thus also empty objects are valid. Only properties\n *                     prefixed with `event_properties.`, the `duration` property and the `start_time` property are\n *                     allowed.\n * @param eventContext An optional context that can be used to manipulate the\n *                     result event within the modification callback.\n */\nexport function sendEvent(fields: ApiCreatedEventPropertiesEvent, eventContext?: unknown): void {\n    guardDynatrace((dt) => {\n        dt.sendEvent(fields, eventContext);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.addEventModifier} which reverts to a noop if RUM JavaScript is not available.\n *\n * @param eventModifier The modifier function to modify a given (readonly) JSONEvent. It receives an optional context\n *                      depending on the type of event, if available. The returned event must be a new object, otherwise\n *                      modification will be ignored.\n * @returns             The unsubscriber function to turn off event modification, or undefined if RUM JavaScript is not available.\n */\nexport function addEventModifier(eventModifier: (jsonEvent: Readonly<JSONEvent>, eventContext?: EventContext) => JSONEvent | null): Unsubscriber | undefined {\n    return guardDynatrace((dt) => {\n        return dt.addEventModifier(eventModifier);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.runHealthCheck} which reverts to a noop if RUM JavaScript is not available.\n *\n * @param config                          The optional configuration object for the health check.\n * @param config.logVerbose               If true, verbose information is included in the health check.\n * @param config.returnDiagnosticData     If true, the diagnostic data is returned as array instead of just being logged.\n * @param config.runDetailedOverrideCheck If true, additional information will be logged to the console for overridden native APIs.\n * @returns                               A promise that settles as soon as the health check has been performed, or undefined if RUM JavaScript is not available.\n */\nexport function runHealthCheck(config?: HealthCheckConfig): Promise<unknown[] | undefined> | undefined {\n    return guardDynatrace((dt) => {\n        return dt.runHealthCheck(config);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.identifyUser} which reverts to a noop if RUM JavaScript is not available.\n *\n * @param value The name of the user. For example, use a name, userid, or your user's email address.\n */\nexport function identifyUser(value: string): void {\n    guardDynatrace((dt) => {\n        dt.identifyUser(value);\n    });\n}\n\n/**\n * Safe wrapper for {@link dynatrace.sendSessionPropertyEvent} which reverts to a noop if RUM JavaScript is not available.\n *\n * @param fields Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n *               values, otherwise they will be replaced with null. The `fields` need to be serializable\n *               using JSON.stringify. All keys must be prefixed with \"session_properties.*\" and must contain only\n *               lower-case characters, numbers, underscores or dots. Each dot must be followed by a lower-case\n *               character. Each underscore must be followed by a lower-case character or number.\n */\nexport function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent): void {\n    guardDynatrace((dt) => {\n        dt.sendSessionPropertyEvent(fields);\n    });\n}\n\n/**\n * This function is only available if the Error module is enabled\n *\n * @param error  Must be a valid instance of the Error class. If an invalid value is provided, the error will not be processed or sent.\n * @param fields Optional: Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n *               values, otherwise they will be replaced with null. The `fields` need to be serializable\n *               using JSON.stringify. The resulting event will contain the provided `fields`, and is\n *               modified with additional properties, thus also empty objects are valid. Only properties\n *               prefixed with `event_properties.`, the `duration` property and the `start_time` property are\n *               allowed. String properties are limited to 5000 characters, exceeding characters are cut off.\n *               All event property keys must contain only alphabetic characters, numbers,\n *               underscores or dots. Each dot must be followed by an alphabetic character. Each underscore\n *               must be followed by an alphabetic character or number.\n */\nexport function sendExceptionEvent(error: Error, fields?: ApiCreatedEventPropertiesEvent): void {\n    guardDynatrace((dt) => {\n        if (!dt.sendExceptionEvent) {\n            log(\"dynatrace.sendExceptionEvent is not available, the Error module might not be enabled\");\n            return;\n        }\n        dt.sendExceptionEvent(error, fields);\n    });\n}\n\n/**\n * Safe wrapper for various RUM JavaScript API functions which reverts to a noop if RUM JavaScript is not available.\n *\n * @param fn The function to be executed if RUM JavaScript is available.\n * @returns  The result of the provided function call if RUM JavaScript is available, otherwise undefined.\n */\nfunction guardDynatrace<T extends (dt: NonNullable<typeof globalThis.dynatrace>) => any>(fn: T): ReturnType<T> | undefined {\n    const globalDt = getGlobal(\"dynatrace\");\n    if (!isValidAgent(globalDt)) {\n        log(\"dynatrace is not available\");\n        return void 0;\n    }\n    return fn(globalDt);\n}\n"]}

package/dist/api/logging.d.ts

@@ -0,0 +1,2 @@
+export declare function log(...args: unknown[]): void;
+export declare function warn(...args: unknown[]): void;

package/dist/api/logging.js

@@ -0,0 +1,8 @@
+import { LOG_PREFIX } from "./constants.js";
+export function log(...args) {
+    console.log(LOG_PREFIX, ...args);
+}
+export function warn(...args) {
+    console.warn(LOG_PREFIX, ...args);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NvdXJjZS9hcGkvbG9nZ2luZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFNUMsTUFBTSxVQUFVLEdBQUcsQ0FBQyxHQUFHLElBQWU7SUFDbEMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLEVBQUUsR0FBRyxJQUFJLENBQUMsQ0FBQztBQUNyQyxDQUFDO0FBRUQsTUFBTSxVQUFVLElBQUksQ0FBQyxHQUFHLElBQWU7SUFDbkMsT0FBTyxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsR0FBRyxJQUFJLENBQUMsQ0FBQztBQUN0QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTE9HX1BSRUZJWCB9IGZyb20gXCIuL2NvbnN0YW50cy5qc1wiO1xuXG5leHBvcnQgZnVuY3Rpb24gbG9nKC4uLmFyZ3M6IHVua25vd25bXSk6IHZvaWQge1xuICAgIGNvbnNvbGUubG9nKExPR19QUkVGSVgsIC4uLmFyZ3MpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gd2FybiguLi5hcmdzOiB1bmtub3duW10pOiB2b2lkIHtcbiAgICBjb25zb2xlLndhcm4oTE9HX1BSRUZJWCwgLi4uYXJncyk7XG59XG4iXX0=

package/dist/api/promises/index.d.ts

@@ -0,0 +1,85 @@
+import type { ApiCreatedEventPropertiesEvent, ApiCreatedSessionPropertiesEvent, EventContext, JSONEvent } from "../../types/index.js";
+import type { HealthCheckConfig, Unsubscriber } from "../../types/api/dynatrace-api-types.js";
+export { DynatraceError } from "../dynatrace-error.js";
+/**
+ * Async wrapper for {@link dynatrace.sendEvent}.
+ *
+ * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+ *                     values, otherwise they will be replaced with null. The `fields` need to be serializable
+ *                     using JSON.stringify. The resulting event will be populated with `fields` parameter, and
+ *                     modified with additional properties, thus also empty objects are valid. Only properties
+ *                     prefixed with `event_properties.`, the `duration` property and the `start_time` property are
+ *                     allowed.
+ * @param eventContext An optional context that can be used to manipulate the
+ *                     result event within the modification callback.
+ * @param timeout      Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws             A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                     overridden with an incompatible object
+ */
+export declare function sendEvent(fields: ApiCreatedEventPropertiesEvent, eventContext?: unknown, timeout?: number): Promise<void>;
+/**
+ * Async wrapper for {@link dynatrace.addEventModifier}.
+ *
+ * @param eventModifier The modifier function to modify a given (readonly) JSONEvent. It receives an optional context
+ *                      depending on the type of event, if available. The returned event must be a new object, otherwise
+ *                      modification will be ignored.
+ * @param timeout       Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @returns             A promise that resolves to the unsubscriber function to turn off event modification.
+ * @throws              A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the
+ *                      namespace is overridden with an incompatible object
+ */
+export declare function addEventModifier(eventModifier: (jsonEvent: Readonly<JSONEvent>, eventContext?: EventContext) => JSONEvent | null, timeout?: number): Promise<Unsubscriber>;
+/**
+ * Async wrapper for {@link dynatrace.runHealthCheck}.
+ *
+ * @param config                          The optional configuration object for the health check.
+ * @param config.logVerbose               If true, verbose information is included in the health check.
+ * @param config.returnDiagnosticData     If true, the diagnostic data is returned as array instead of just being logged.
+ * @param config.runDetailedOverrideCheck If true, additional information will be logged to the console for overridden native APIs.
+ * @param timeout                         Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @returns                               A promise that settles as soon as the health check has been performed.
+ * @throws                                A {@link DynatraceError} if the RUM JavaScript is not available within the
+ *                                        timeout, or the namespace is overridden with an incompatible object
+ */
+export declare function runHealthCheck(config?: HealthCheckConfig, timeout?: number): Promise<unknown[] | undefined>;
+/**
+ * Async wrapper for {@link dynatrace.identifyUser}.
+ *
+ * @param value   The name of the user. For example, use a name, userid, or your user's email address.
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                overridden with an incompatible object
+ */
+export declare function identifyUser(value: string, timeout?: number): Promise<void>;
+/**
+ * Async wrapper for {@link dynatrace.sendSessionPropertyEvent}.
+ *
+ * @param fields  Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+ *                values, otherwise they will be replaced with null. The `fields` need to be serializable
+ *                using JSON.stringify. All keys must be prefixed with "session_properties.*" and must contain only
+ *                lower-case characters, numbers, underscores or dots. Each dot must be followed by a lower-case
+ *                character. Each underscore must be followed by a lower-case character or number.
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                overridden with an incompatible object
+ */
+export declare function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent, timeout?: number): Promise<void>;
+/**
+ * Async wrapper for {@link dynatrace.sendExceptionEvent}.
+ * This function is only available if the Error module is enabled
+ *
+ * @param error   Must be a valid instance of the Error class. If an invalid value is provided, the error will not be processed or sent.
+ * @param fields  Optional: Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+ *                values, otherwise they will be replaced with null. The `fields` need to be serializable
+ *                using JSON.stringify. The resulting event will contain the provided `fields`, and is
+ *                modified with additional properties, thus also empty objects are valid. Only properties
+ *                prefixed with `event_properties.`, the `duration` property and the `start_time` property are
+ *                allowed. String properties are limited to 5000 characters, exceeding characters are cut off.
+ *                All event property keys must contain only alphabetic characters, numbers,
+ *                underscores or dots. Each dot must be followed by an alphabetic character. Each underscore
+ *                must be followed by an alphabetic character or number.
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                overridden with an incompatible object
+ */
+export declare function sendExceptionEvent(error: Error, fields?: ApiCreatedEventPropertiesEvent, timeout?: number): Promise<void>;

package/dist/api/promises/index.js

@@ -0,0 +1,104 @@
+import { waitForAgent } from "./wait-for-agent.js";
+import { waitForSendExceptionEvent } from "./wait-for-send-exception-event.js";
+export { DynatraceError } from "../dynatrace-error.js";
+/**
+ * Async wrapper for {@link dynatrace.sendEvent}.
+ *
+ * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+ *                     values, otherwise they will be replaced with null. The `fields` need to be serializable
+ *                     using JSON.stringify. The resulting event will be populated with `fields` parameter, and
+ *                     modified with additional properties, thus also empty objects are valid. Only properties
+ *                     prefixed with `event_properties.`, the `duration` property and the `start_time` property are
+ *                     allowed.
+ * @param eventContext An optional context that can be used to manipulate the
+ *                     result event within the modification callback.
+ * @param timeout      Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws             A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                     overridden with an incompatible object
+ */
+export async function sendEvent(fields, eventContext, timeout = 10_000) {
+    const dynatrace = await waitForAgent(timeout);
+    dynatrace.sendEvent(fields, eventContext);
+}
+/**
+ * Async wrapper for {@link dynatrace.addEventModifier}.
+ *
+ * @param eventModifier The modifier function to modify a given (readonly) JSONEvent. It receives an optional context
+ *                      depending on the type of event, if available. The returned event must be a new object, otherwise
+ *                      modification will be ignored.
+ * @param timeout       Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @returns             A promise that resolves to the unsubscriber function to turn off event modification.
+ * @throws              A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the
+ *                      namespace is overridden with an incompatible object
+ */
+export async function addEventModifier(eventModifier, timeout = 10_000) {
+    const dynatrace = await waitForAgent(timeout);
+    return dynatrace.addEventModifier(eventModifier);
+}
+/**
+ * Async wrapper for {@link dynatrace.runHealthCheck}.
+ *
+ * @param config                          The optional configuration object for the health check.
+ * @param config.logVerbose               If true, verbose information is included in the health check.
+ * @param config.returnDiagnosticData     If true, the diagnostic data is returned as array instead of just being logged.
+ * @param config.runDetailedOverrideCheck If true, additional information will be logged to the console for overridden native APIs.
+ * @param timeout                         Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @returns                               A promise that settles as soon as the health check has been performed.
+ * @throws                                A {@link DynatraceError} if the RUM JavaScript is not available within the
+ *                                        timeout, or the namespace is overridden with an incompatible object
+ */
+export async function runHealthCheck(config, timeout = 10_000) {
+    const dynatrace = await waitForAgent(timeout);
+    return dynatrace.runHealthCheck(config);
+}
+/**
+ * Async wrapper for {@link dynatrace.identifyUser}.
+ *
+ * @param value   The name of the user. For example, use a name, userid, or your user's email address.
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                overridden with an incompatible object
+ */
+export async function identifyUser(value, timeout = 10_000) {
+    const dynatrace = await waitForAgent(timeout);
+    dynatrace.identifyUser(value);
+}
+/**
+ * Async wrapper for {@link dynatrace.sendSessionPropertyEvent}.
+ *
+ * @param fields  Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+ *                values, otherwise they will be replaced with null. The `fields` need to be serializable
+ *                using JSON.stringify. All keys must be prefixed with "session_properties.*" and must contain only
+ *                lower-case characters, numbers, underscores or dots. Each dot must be followed by a lower-case
+ *                character. Each underscore must be followed by a lower-case character or number.
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                overridden with an incompatible object
+ */
+export async function sendSessionPropertyEvent(fields, timeout = 10_000) {
+    const dynatrace = await waitForAgent(timeout);
+    dynatrace.sendSessionPropertyEvent(fields);
+}
+/**
+ * Async wrapper for {@link dynatrace.sendExceptionEvent}.
+ * This function is only available if the Error module is enabled
+ *
+ * @param error   Must be a valid instance of the Error class. If an invalid value is provided, the error will not be processed or sent.
+ * @param fields  Optional: Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as
+ *                values, otherwise they will be replaced with null. The `fields` need to be serializable
+ *                using JSON.stringify. The resulting event will contain the provided `fields`, and is
+ *                modified with additional properties, thus also empty objects are valid. Only properties
+ *                prefixed with `event_properties.`, the `duration` property and the `start_time` property are
+ *                allowed. String properties are limited to 5000 characters, exceeding characters are cut off.
+ *                All event property keys must contain only alphabetic characters, numbers,
+ *                underscores or dots. Each dot must be followed by an alphabetic character. Each underscore
+ *                must be followed by an alphabetic character or number.
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)
+ * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is
+ *                overridden with an incompatible object
+ */
+export async function sendExceptionEvent(error, fields, timeout = 10_000) {
+    const sendExceptionEventGuarded = await waitForSendExceptionEvent(timeout);
+    sendExceptionEventGuarded(error, fields);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/api/promises/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,MAAsC,EAAE,YAAsB,EAAE,UAAkB,MAAM;IACpH,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,aAAgG,EAAE,UAAkB,MAAM;IAC7J,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,OAAO,SAAS,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,MAA0B,EAAE,UAAkB,MAAM;IACrF,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,OAAO,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,KAAa,EAAE,UAAkB,MAAM;IACtE,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAAC,MAAwC,EAAE,UAAkB,MAAM;IAC7G,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,KAAY,EAAE,MAAuC,EAAE,UAAkB,MAAM;IACpH,MAAM,yBAAyB,GAAG,MAAM,yBAAyB,CAAC,OAAO,CAAC,CAAC;IAC3E,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AAC7C,CAAC","sourcesContent":["import type {\n    ApiCreatedEventPropertiesEvent,\n    ApiCreatedSessionPropertiesEvent,\n    EventContext,\n    JSONEvent\n} from \"../../types/index.js\";\nimport type {\n    HealthCheckConfig,\n    Unsubscriber\n} from \"../../types/api/dynatrace-api-types.js\";\nimport { waitForAgent } from \"./wait-for-agent.js\";\nimport { waitForSendExceptionEvent } from \"./wait-for-send-exception-event.js\";\n\nexport { DynatraceError } from \"../dynatrace-error.js\";\n\n/**\n * Async wrapper for {@link dynatrace.sendEvent}.\n *\n * @param fields       Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n *                     values, otherwise they will be replaced with null. The `fields` need to be serializable\n *                     using JSON.stringify. The resulting event will be populated with `fields` parameter, and\n *                     modified with additional properties, thus also empty objects are valid. Only properties\n *                     prefixed with `event_properties.`, the `duration` property and the `start_time` property are\n *                     allowed.\n * @param eventContext An optional context that can be used to manipulate the\n *                     result event within the modification callback.\n * @param timeout      Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws             A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                     overridden with an incompatible object\n */\nexport async function sendEvent(fields: ApiCreatedEventPropertiesEvent, eventContext?: unknown, timeout: number = 10_000): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.sendEvent(fields, eventContext);\n}\n\n/**\n * Async wrapper for {@link dynatrace.addEventModifier}.\n *\n * @param eventModifier The modifier function to modify a given (readonly) JSONEvent. It receives an optional context\n *                      depending on the type of event, if available. The returned event must be a new object, otherwise\n *                      modification will be ignored.\n * @param timeout       Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @returns             A promise that resolves to the unsubscriber function to turn off event modification.\n * @throws              A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the\n *                      namespace is overridden with an incompatible object\n */\nexport async function addEventModifier(eventModifier: (jsonEvent: Readonly<JSONEvent>, eventContext?: EventContext) => JSONEvent | null, timeout: number = 10_000): Promise<Unsubscriber> {\n    const dynatrace = await waitForAgent(timeout);\n    return dynatrace.addEventModifier(eventModifier);\n}\n\n/**\n * Async wrapper for {@link dynatrace.runHealthCheck}.\n *\n * @param config                          The optional configuration object for the health check.\n * @param config.logVerbose               If true, verbose information is included in the health check.\n * @param config.returnDiagnosticData     If true, the diagnostic data is returned as array instead of just being logged.\n * @param config.runDetailedOverrideCheck If true, additional information will be logged to the console for overridden native APIs.\n * @param timeout                         Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @returns                               A promise that settles as soon as the health check has been performed.\n * @throws                                A {@link DynatraceError} if the RUM JavaScript is not available within the\n *                                        timeout, or the namespace is overridden with an incompatible object\n */\nexport async function runHealthCheck(config?: HealthCheckConfig, timeout: number = 10_000): Promise<unknown[] | undefined> {\n    const dynatrace = await waitForAgent(timeout);\n    return dynatrace.runHealthCheck(config);\n}\n\n/**\n * Async wrapper for {@link dynatrace.identifyUser}.\n *\n * @param value   The name of the user. For example, use a name, userid, or your user's email address.\n * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n */\nexport async function identifyUser(value: string, timeout: number = 10_000): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.identifyUser(value);\n}\n\n/**\n * Async wrapper for {@link dynatrace.sendSessionPropertyEvent}.\n *\n * @param fields  Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n *                values, otherwise they will be replaced with null. The `fields` need to be serializable\n *                using JSON.stringify. All keys must be prefixed with \"session_properties.*\" and must contain only\n *                lower-case characters, numbers, underscores or dots. Each dot must be followed by a lower-case\n *                character. Each underscore must be followed by a lower-case character or number.\n * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n */\nexport async function sendSessionPropertyEvent(fields: ApiCreatedSessionPropertiesEvent, timeout: number = 10_000): Promise<void> {\n    const dynatrace = await waitForAgent(timeout);\n    dynatrace.sendSessionPropertyEvent(fields);\n}\n\n/**\n * Async wrapper for {@link dynatrace.sendExceptionEvent}.\n * This function is only available if the Error module is enabled\n *\n * @param error   Must be a valid instance of the Error class. If an invalid value is provided, the error will not be processed or sent.\n * @param fields  Optional: Must be a valid JSON object and cannot contain functions, undefined, Infinity and NaN as\n *                values, otherwise they will be replaced with null. The `fields` need to be serializable\n *                using JSON.stringify. The resulting event will contain the provided `fields`, and is\n *                modified with additional properties, thus also empty objects are valid. Only properties\n *                prefixed with `event_properties.`, the `duration` property and the `start_time` property are\n *                allowed. String properties are limited to 5000 characters, exceeding characters are cut off.\n *                All event property keys must contain only alphabetic characters, numbers,\n *                underscores or dots. Each dot must be followed by an alphabetic character. Each underscore\n *                must be followed by an alphabetic character or number.\n * @param timeout Timeout in milliseconds to wait for the RUM JavaScript to be available (default: 10000)\n * @throws        A {@link DynatraceError} if the RUM JavaScript is not available within the timeout, or the namespace is\n *                overridden with an incompatible object\n */\nexport async function sendExceptionEvent(error: Error, fields?: ApiCreatedEventPropertiesEvent, timeout: number = 10_000): Promise<void> {\n    const sendExceptionEventGuarded = await waitForSendExceptionEvent(timeout);\n    sendExceptionEventGuarded(error, fields);\n}\n"]}

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

@@ -0,0 +1,35 @@
+import type { UserActionStartOptions, UserActionTracker } from "../../types/index.js";
+/**
+ * Async wrapper for {@link dynatrace.userActions.create}.
+ *
+ * @param options An optional options object to configure the user action.
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript and user actions module to be available (default: 10000)
+ * @returns       A promise that resolves to a `UserActionTracker` object.
+ * @throws        A {@link DynatraceError} if the RUM JavaScript or user actions module is not available within the timeout
+ */
+export declare function create(options?: UserActionStartOptions, timeout?: number): Promise<UserActionTracker>;
+/**
+ * Async wrapper for {@link dynatrace.userActions.subscribe}.
+ *
+ * @param subscriber A callback function that is called whenever Dynatrace creates a new user action.
+ * @param timeout    Timeout in milliseconds to wait for the RUM JavaScript and user actions module to be available (default: 10000)
+ * @returns          A promise that resolves to an unsubscriber function.
+ * @throws           A {@link DynatraceError} if the RUM JavaScript or user actions module is not available within the timeout
+ */
+export declare function subscribe(subscriber: (userAction: UserActionTracker) => void, timeout?: number): Promise<() => void>;
+/**
+ * Async wrapper for {@link dynatrace.userActions.setAutomaticDetection}.
+ *
+ * @param automaticDetection If false, disables automatic user action detection, otherwise enables it.
+ * @param timeout            Timeout in milliseconds to wait for the RUM JavaScript and user actions module to be available (default: 10000)
+ * @throws                   A {@link DynatraceError} if the RUM JavaScript or user actions module is not available within the timeout
+ */
+export declare function setAutomaticDetection(automaticDetection: boolean, timeout?: number): Promise<void>;
+/**
+ * Async wrapper for {@link dynatrace.userActions.current}.
+ *
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript and user actions module to be available (default: 10000)
+ * @returns       A promise that resolves to the current user action, or `undefined` if no user action is in progress.
+ * @throws        A {@link DynatraceError} if the RUM JavaScript or user actions module is not available within the timeout
+ */
+export declare function getCurrent(timeout?: number): Promise<UserActionTracker | undefined>;

package/dist/api/promises/user-actions.js

@@ -0,0 +1,48 @@
+import { waitForUserActions } from "./wait-for-user-actions.js";
+/**
+ * Async wrapper for {@link dynatrace.userActions.create}.
+ *
+ * @param options An optional options object to configure the user action.
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript and user actions module to be available (default: 10000)
+ * @returns       A promise that resolves to a `UserActionTracker` object.
+ * @throws        A {@link DynatraceError} if the RUM JavaScript or user actions module is not available within the timeout
+ */
+export async function create(options, timeout = 10_000) {
+    const userActions = await waitForUserActions(timeout);
+    return userActions.create(options);
+}
+/**
+ * Async wrapper for {@link dynatrace.userActions.subscribe}.
+ *
+ * @param subscriber A callback function that is called whenever Dynatrace creates a new user action.
+ * @param timeout    Timeout in milliseconds to wait for the RUM JavaScript and user actions module to be available (default: 10000)
+ * @returns          A promise that resolves to an unsubscriber function.
+ * @throws           A {@link DynatraceError} if the RUM JavaScript or user actions module is not available within the timeout
+ */
+export async function subscribe(subscriber, timeout = 10_000) {
+    const userActions = await waitForUserActions(timeout);
+    return userActions.subscribe(subscriber);
+}
+/**
+ * Async wrapper for {@link dynatrace.userActions.setAutomaticDetection}.
+ *
+ * @param automaticDetection If false, disables automatic user action detection, otherwise enables it.
+ * @param timeout            Timeout in milliseconds to wait for the RUM JavaScript and user actions module to be available (default: 10000)
+ * @throws                   A {@link DynatraceError} if the RUM JavaScript or user actions module is not available within the timeout
+ */
+export async function setAutomaticDetection(automaticDetection, timeout = 10_000) {
+    const userActions = await waitForUserActions(timeout);
+    userActions.setAutomaticDetection(automaticDetection);
+}
+/**
+ * Async wrapper for {@link dynatrace.userActions.current}.
+ *
+ * @param timeout Timeout in milliseconds to wait for the RUM JavaScript and user actions module to be available (default: 10000)
+ * @returns       A promise that resolves to the current user action, or `undefined` if no user action is in progress.
+ * @throws        A {@link DynatraceError} if the RUM JavaScript or user actions module is not available within the timeout
+ */
+export async function getCurrent(timeout = 10_000) {
+    const userActions = await waitForUserActions(timeout);
+    return userActions.current;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/promises/wait-for-agent.d.ts

@@ -0,0 +1,2 @@
+import type { dynatrace as DtApi } from "../../types/api/dynatrace-api-types.js";
+export declare function waitForAgent(timeout?: number): Promise<typeof DtApi>;

package/dist/api/promises/wait-for-agent.js

@@ -0,0 +1,77 @@
+import { log, warn } from "../logging.js";
+import { DynatraceError } from "../dynatrace-error.js";
+import { getGlobal } from "../global-adapter.js";
+import { isValidAgent } from "../type-guards/is-valid-agent.js";
+const INVALID_ASSIGNMENT_MESSAGE = "An invalid object was assigned to the `dynatrace` namespace. This can lead to unexpected behavior when using the API. The assigned object: ";
+const setupPropertyListenerOnce = once(setupPropertyListener);
+const waitingPromises = new Map();
+let nextPromiseId = 0;
+let currentAgent = void 0;
+function setupPropertyListener() {
+    Object.defineProperty(globalThis, "dynatrace", {
+        set: (value) => {
+            if (isValidAgent(value)) {
+                log("RUM JavaScript available, continuing API execution.");
+                currentAgent = value;
+                resolveAllWaitingPromises(value);
+            }
+            else if (value) {
+                rejectAllWaitingPromises(new DynatraceError(INVALID_ASSIGNMENT_MESSAGE, value));
+            }
+        },
+        get: () => {
+            return currentAgent;
+        },
+        configurable: true
+    });
+}
+function resolveAllWaitingPromises(agent) {
+    waitingPromises.forEach((promise) => {
+        clearTimeout(promise.timeoutId);
+        promise.resolve(agent);
+    });
+    waitingPromises.clear();
+}
+function rejectAllWaitingPromises(error) {
+    waitingPromises.forEach((promise) => {
+        clearTimeout(promise.timeoutId);
+        promise.reject(error);
+    });
+    waitingPromises.clear();
+}
+function removeWaitingPromise(promiseId) {
+    waitingPromises.delete(promiseId);
+}
+export function waitForAgent(timeout = 10_000) {
+    const globalDt = getGlobal("dynatrace");
+    if (isValidAgent(globalDt)) {
+        return Promise.resolve(globalDt);
+    }
+    else if (globalDt) {
+        return Promise.reject(new DynatraceError(INVALID_ASSIGNMENT_MESSAGE, globalDt));
+    }
+    setupPropertyListenerOnce();
+    warn("RUM JavaScript is not available yet. API execution halted until it is.");
+    return new Promise((resolve, reject) => {
+        const promiseId = nextPromiseId++;
+        const timeoutId = setTimeout(() => {
+            removeWaitingPromise(promiseId);
+            reject(new DynatraceError("Timeout waiting for RUM JavaScript."));
+        }, timeout);
+        waitingPromises.set(promiseId, { resolve, reject, timeoutId });
+    });
+}
+/**
+ * @param fn the function to be only called once
+ * @returns  the once wrapper function that calls either the given function the first time or does nothing otherwise
+ */
+function once(fn) {
+    let callable = function (...args) {
+        callable = () => void 0;
+        return fn.apply(this, args);
+    };
+    return function (...args) {
+        return callable.apply(this, args);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wait-for-agent.js","sourceRoot":"","sources":["../../../source/api/promises/wait-for-agent.ts"],"names":[],"mappings":"AACA,OAAO,EACH,GAAG,EACH,IAAI,EACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAQhE,MAAM,0BAA0B,GAAG,6IAA6I,CAAC;AAEjL,MAAM,yBAAyB,GAAG,IAAI,CAAC,qBAAqB,CAAC,CAAC;AAE9D,MAAM,eAAe,GAAG,IAAI,GAAG,EAA0B,CAAC;AAC1D,IAAI,aAAa,GAAW,CAAC,CAAC;AAC9B,IAAI,YAAY,GAA6B,KAAK,CAAC,CAAC;AAEpD,SAAS,qBAAqB;IAC1B,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,WAAW,EAAE;QAC3C,GAAG,EAAE,CAAC,KAAc,EAAE,EAAE;YACpB,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;gBACtB,GAAG,CAAC,qDAAqD,CAAC,CAAC;gBAC3D,YAAY,GAAG,KAAK,CAAC;gBACrB,yBAAyB,CAAC,KAAK,CAAC,CAAC;YACrC,CAAC;iBAAM,IAAI,KAAK,EAAE,CAAC;gBACf,wBAAwB,CAAC,IAAI,cAAc,CAAC,0BAA0B,EAAE,KAAK,CAAC,CAAC,CAAC;YACpF,CAAC;QACL,CAAC;QACD,GAAG,EAAE,GAAG,EAAE;YACN,OAAO,YAAY,CAAC;QACxB,CAAC;QACD,YAAY,EAAE,IAAI;KACrB,CAAC,CAAC;AACP,CAAC;AAED,SAAS,yBAAyB,CAAC,KAAmB;IAClD,eAAe,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAChC,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAChC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC,CAAC,CAAC;IACH,eAAe,CAAC,KAAK,EAAE,CAAC;AAC5B,CAAC;AAED,SAAS,wBAAwB,CAAC,KAAqB;IACnD,eAAe,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAChC,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAChC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC,CAAC,CAAC;IACH,eAAe,CAAC,KAAK,EAAE,CAAC;AAC5B,CAAC;AAED,SAAS,oBAAoB,CAAC,SAAiB;IAC3C,eAAe,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,UAAkB,MAAM;IACjD,MAAM,QAAQ,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;IAExC,IAAI,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzB,OAAO,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACrC,CAAC;SAAM,IAAI,QAAQ,EAAE,CAAC;QAClB,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,cAAc,CAAC,0BAA0B,EAAE,QAAQ,CAAC,CAAC,CAAC;IACpF,CAAC;IAED,yBAAyB,EAAE,CAAC;IAE5B,IAAI,CAAC,wEAAwE,CAAC,CAAC;IAE/E,OAAO,IAAI,OAAO,CAAe,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACjD,MAAM,SAAS,GAAG,aAAa,EAAE,CAAC;QAElC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;YAC9B,oBAAoB,CAAC,SAAS,CAAC,CAAC;YAChC,MAAM,CAAC,IAAI,cAAc,CAAC,qCAAqC,CAAC,CAAC,CAAC;QACtE,CAAC,EAAE,OAAO,CAAC,CAAC;QAEZ,eAAe,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IACnE,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;GAGG;AACH,SAAS,IAAI,CACT,EAA6B;IAE7B,IAAI,QAAQ,GAAG,UAAmB,GAAG,IAAO;QACxC,QAAQ,GAAG,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;QACxB,OAAO,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC,CAAC;IAEF,OAAO,UAAmB,GAAG,IAAO;QAChC,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACtC,CAAC,CAAC;AACN,CAAC","sourcesContent":["import type { dynatrace as DtApi } from \"../../types/api/dynatrace-api-types.js\";\nimport {\n    log,\n    warn\n} from \"../logging.js\";\nimport { DynatraceError } from \"../dynatrace-error.js\";\nimport { getGlobal } from \"../global-adapter.js\";\nimport { isValidAgent } from \"../type-guards/is-valid-agent.js\";\n\ninterface WaitingPromise {\n    resolve: (agent: typeof DtApi) => void;\n    reject: (error: DynatraceError) => void;\n    timeoutId: ReturnType<typeof setTimeout>;\n}\n\nconst INVALID_ASSIGNMENT_MESSAGE = \"An invalid object was assigned to the `dynatrace` namespace. This can lead to unexpected behavior when using the API. The assigned object: \";\n\nconst setupPropertyListenerOnce = once(setupPropertyListener);\n\nconst waitingPromises = new Map<number, WaitingPromise>();\nlet nextPromiseId: number = 0;\nlet currentAgent: typeof DtApi | undefined = void 0;\n\nfunction setupPropertyListener(): void {\n    Object.defineProperty(globalThis, \"dynatrace\", {\n        set: (value: unknown) => {\n            if (isValidAgent(value)) {\n                log(\"RUM JavaScript available, continuing API execution.\");\n                currentAgent = value;\n                resolveAllWaitingPromises(value);\n            } else if (value) {\n                rejectAllWaitingPromises(new DynatraceError(INVALID_ASSIGNMENT_MESSAGE, value));\n            }\n        },\n        get: () => {\n            return currentAgent;\n        },\n        configurable: true\n    });\n}\n\nfunction resolveAllWaitingPromises(agent: typeof DtApi): void {\n    waitingPromises.forEach((promise) => {\n        clearTimeout(promise.timeoutId);\n        promise.resolve(agent);\n    });\n    waitingPromises.clear();\n}\n\nfunction rejectAllWaitingPromises(error: DynatraceError): void {\n    waitingPromises.forEach((promise) => {\n        clearTimeout(promise.timeoutId);\n        promise.reject(error);\n    });\n    waitingPromises.clear();\n}\n\nfunction removeWaitingPromise(promiseId: number): void {\n    waitingPromises.delete(promiseId);\n}\n\nexport function waitForAgent(timeout: number = 10_000): Promise<typeof DtApi> {\n    const globalDt = getGlobal(\"dynatrace\");\n\n    if (isValidAgent(globalDt)) {\n        return Promise.resolve(globalDt);\n    } else if (globalDt) {\n        return Promise.reject(new DynatraceError(INVALID_ASSIGNMENT_MESSAGE, globalDt));\n    }\n\n    setupPropertyListenerOnce();\n\n    warn(\"RUM JavaScript is not available yet. API execution halted until it is.\");\n\n    return new Promise<typeof DtApi>((resolve, reject) => {\n        const promiseId = nextPromiseId++;\n\n        const timeoutId = setTimeout(() => {\n            removeWaitingPromise(promiseId);\n            reject(new DynatraceError(\"Timeout waiting for RUM JavaScript.\"));\n        }, timeout);\n\n        waitingPromises.set(promiseId, { resolve, reject, timeoutId });\n    });\n}\n\n/**\n * @param fn the function to be only called once\n * @returns  the once wrapper function that calls either the given function the first time or does nothing otherwise\n */\nfunction once<A extends any[], R, T>(\n    fn: (this: T, ...arg: A) => R\n): ((this: T, ...arg: A) => R | undefined) {\n    let callable = function (this: T, ...args: A): R | undefined {\n        callable = () => void 0;\n        return fn.apply(this, args);\n    };\n\n    return function (this: T, ...args: A): R | undefined {\n        return callable.apply(this, args);\n    };\n}\n"]}

package/dist/api/promises/wait-for-send-exception-event.d.ts

@@ -0,0 +1,9 @@
+import type { sendExceptionEvent } from "../index.js";
+/**
+ * Waits for the RUM JavaScript and error module to become available.
+ *
+ * @param timeout Timeout in milliseconds to wait for the error module to be available (default: 10000)
+ * @returns       A promise that resolves to the error module
+ * @throws        A {@link DynatraceError} if the RUM JavaScript or error module is not available within the timeout
+ */
+export declare function waitForSendExceptionEvent(timeout?: number): Promise<typeof sendExceptionEvent>;

package/dist/api/promises/wait-for-send-exception-event.js

@@ -0,0 +1,18 @@
+import { DynatraceError } from "../dynatrace-error.js";
+import { waitForAgent } from "./wait-for-agent.js";
+/**
+ * Waits for the RUM JavaScript and error module to become available.
+ *
+ * @param timeout Timeout in milliseconds to wait for the error module to be available (default: 10000)
+ * @returns       A promise that resolves to the error module
+ * @throws        A {@link DynatraceError} if the RUM JavaScript or error module is not available within the timeout
+ */
+export async function waitForSendExceptionEvent(timeout = 10_000) {
+    const dynatrace = await waitForAgent(timeout);
+    if (dynatrace.sendExceptionEvent) {
+        return dynatrace.sendExceptionEvent;
+    }
+    // If not immediately available, it means the module is disabled
+    throw new DynatraceError("The `dynatrace.sendExceptionEvent` function is not available. Ensure the Error module is enabled in your RUM configuration.");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/promises/wait-for-user-actions.d.ts

@@ -0,0 +1,9 @@
+import type { UserActions } from "../../types/index.js";
+/**
+ * Waits for the RUM JavaScript and user actions module to become available.
+ *
+ * @param timeout Timeout in milliseconds to wait for the user actions module to be available (default: 10000)
+ * @returns       A promise that resolves to the user actions module
+ * @throws        A {@link DynatraceError} if the RUM JavaScript or user actions module is not available within the timeout
+ */
+export declare function waitForUserActions(timeout?: number): Promise<UserActions>;

package/dist/api/promises/wait-for-user-actions.js

@@ -0,0 +1,18 @@
+import { DynatraceError } from "../dynatrace-error.js";
+import { waitForAgent } from "./wait-for-agent.js";
+/**
+ * Waits for the RUM JavaScript and user actions module to become available.
+ *
+ * @param timeout Timeout in milliseconds to wait for the user actions module to be available (default: 10000)
+ * @returns       A promise that resolves to the user actions module
+ * @throws        A {@link DynatraceError} if the RUM JavaScript or user actions module is not available within the timeout
+ */
+export async function waitForUserActions(timeout = 10_000) {
+    const dynatrace = await waitForAgent(timeout);
+    if (dynatrace.userActions) {
+        return dynatrace.userActions;
+    }
+    // If not immediately available, it means the module is disabled
+    throw new DynatraceError("The `dynatrace.userActions` module is not available. Ensure the User Actions module is enabled in your RUM configuration.");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/type-guards/is-valid-agent.d.ts

@@ -0,0 +1,2 @@
+import type { dynatrace as DtApi } from "../../types/api/dynatrace-api-types.js";
+export declare function isValidAgent(agent: unknown): agent is typeof DtApi;