sentry-vir 0.1.2 → 0.2.1

package/README.md

@@ -14,8 +14,6 @@ Full api reference: https://electrovir.github.io/sentry-vir
 
 -   Use `initSentry` to initialize Sentry.
 -   Use `sendLog` and `handleError` to send events to Sentry.
--   Use `setSentryClientForLogging` once `initSentry` has resolved to enable those events to send to Sentry.
-    -   Note that `sendLog` and `handleError` _can_ be fired before `setSentryClientForLogging` has been called. Once `setSentryClientForLogging` has been called, it will catch up.
 -   Use `throwWithExtraContext` to throw an error while attaching extra event context for Sentry to pick up.
 
 ## Basic setup example
@@ -27,8 +25,8 @@ Full api reference: https://electrovir.github.io/sentry-vir
  * If initializing sentry for node, instead import from 'sentry-vir/dist/esm/node' (for ESM) or
  * 'sentry-vir/dist/cjs/node' (for CommonJS).
  */
+import {SentryReleaseEnvEnum} from 'sentry-vir';
 import {initSentry} from 'sentry-vir/dist/esm/browser';
-import {SentryReleaseEnvEnum} from '..';
 
 initSentry({
     dsn: 'Sentry project id provided by Sentry',
@@ -49,20 +47,15 @@ initSentry({
 <!-- example-link: src/readme-examples/setup-logging.example.ts -->
 
 ```TypeScript
+import {SentryReleaseEnvEnum, handleError, sendLog, throwWithExtraContext} from 'sentry-vir';
 import {initSentry} from 'sentry-vir/dist/esm/browser';
-import {
-    SentryReleaseEnvEnum,
-    handleError,
-    sendLog,
-    setSentryClientForLogging,
-    throwWithExtraContext,
-} from '..';
 
 sendLog.info('starting file');
 /** Extra log context can be added as the second argument to a sendLog method. */
 sendLog.info('starting file 2', {addExtraContext: 'here'});
 /** Other severities are covered. */
 sendLog.debug('debug log');
+/** Logs and errors will be buffered so it's safe to call this before initSentry has been called. */
 sendLog.warning('warning log');
 
 /** Standard init. Note that this returns a promise. */
@@ -76,18 +69,13 @@ initSentry({
             userTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
         };
     },
-}).then((sentryClient) => {
-    /**
-     * This must be called at some point for all handleError and sendLog events to send to Sentry.
-     * Note that sendLog and handleError can still be fired before setSentryClientForLogging is
-     * called. Once setSentryClientForLogging is called, it'll catch up.
-     */
-    setSentryClientForLogging(sentryClient);
 });
 
 handleError(new Error('test error'));
 /** Extra error context can be added as the second argument to handleError. */
 handleError(new Error('test error 2'), {addExtraContext: 'here'});
+/** These will be included in the Sentry buffer even if initSentry has not been awaited yet. */
+handleError(new Error('test error 2'), {addExtraContext: 'here'});
 
 /** Throw an error with extra context attached for Sentry to pick up. */
 throwWithExtraContext(new Error('final error'), {addExtraContext: 'here'});

package/dist/cjs/auto.js

@@ -25,8 +25,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.autoInitSentry = exports.sentryDepByEnv = void 0;
 const execution_env_1 = require("./env/execution-env");
+const sentry_config_1 = require("./init-sentry/sentry-config");
 const event_processor_1 = require("./processing/event-processor");
-const sentry_config_1 = require("./processing/sentry-config");
 /** The sentry dep import for each execution env. */
 /* c8 ignore next 6 */
 exports.sentryDepByEnv = {

package/dist/cjs/browser.js

@@ -25,8 +25,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initSentry = void 0;
 const execution_env_1 = require("./env/execution-env");
+const sentry_config_1 = require("./init-sentry/sentry-config");
 const event_processor_1 = require("./processing/event-processor");
-const sentry_config_1 = require("./processing/sentry-config");
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client
  * with all the default sentry-vir integrations and configs.

package/dist/cjs/event-context/extra-event-context.d.ts

@@ -1,3 +1,4 @@
+import { Event, EventHint } from '@sentry/types';
 import { EventExtraContext } from './event-context';
 /**
  * Symbol used to attach extra event context to events. This is particularly useful for errors so
@@ -10,8 +11,13 @@ export type HasExtraContext = {
 };
 /** Type guard for whether any given input has extra event context. */
 export declare function hasExtraEventContext(input: unknown): input is HasExtraContext;
+/**
+ * Checks if extra event context has been injected into the input via extraEventContextSymbol and,
+ * if so, extracts it.
+ */
+export declare function extractExtraContentFromSymbol(input: unknown): EventExtraContext | undefined;
 /**
  * Tries to extract extra event context via extraEventContextSymbol. Returns undefined if there is
  * no extra event context.
  */
-export declare function extractExtraEventContext(event: unknown): EventExtraContext | undefined;
+export declare function extractExtraEventContext(event: EventHint | Event): EventExtraContext | undefined;

package/dist/cjs/event-context/extra-event-context.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractExtraEventContext = exports.hasExtraEventContext = exports.extraEventContextSymbol = void 0;
+exports.extractExtraEventContext = exports.extractExtraContentFromSymbol = exports.hasExtraEventContext = exports.extraEventContextSymbol = void 0;
 const common_1 = require("@augment-vir/common");
 /**
  * Symbol used to attach extra event context to events. This is particularly useful for errors so
@@ -12,13 +12,36 @@ function hasExtraEventContext(input) {
     return (0, common_1.typedHasProperty)(input, exports.extraEventContextSymbol);
 }
 exports.hasExtraEventContext = hasExtraEventContext;
+/**
+ * Checks if extra event context has been injected into the input via extraEventContextSymbol and,
+ * if so, extracts it.
+ */
+function extractExtraContentFromSymbol(input) {
+    if (hasExtraEventContext(input)) {
+        return input[exports.extraEventContextSymbol];
+    }
+    else {
+        return undefined;
+    }
+}
+exports.extractExtraContentFromSymbol = extractExtraContentFromSymbol;
 /**
  * Tries to extract extra event context via extraEventContextSymbol. Returns undefined if there is
  * no extra event context.
  */
 function extractExtraEventContext(event) {
-    if (hasExtraEventContext(event)) {
-        return event[exports.extraEventContextSymbol];
+    const fromRootSymbol = extractExtraContentFromSymbol(event);
+    const fromSubSymbol = 'originalException' in event
+        ? extractExtraContentFromSymbol(event.originalException)
+        : undefined;
+    const fromCapture = 'captureContext' in event ? event.captureContext : undefined;
+    const combined = {
+        ...fromRootSymbol,
+        ...fromSubSymbol,
+        ...fromCapture,
+    };
+    if (Object.keys(combined).length) {
+        return combined;
     }
     else {
         return undefined;

package/dist/cjs/index.d.ts

@@ -5,7 +5,10 @@ export * from './event-context/event-severity';
 export * from './event-context/extra-context.error';
 export * from './event-context/extra-event-context';
 export * from './init-sentry/base-sentry-init';
+export * from './init-sentry/sentry-config';
+export * from './logging/attach-tags';
+export * from './logging/handle-error';
+export * from './logging/send-log';
+export * from './logging/sentry-client-for-logging';
 export * from './processing/event-processor';
 export * from './processing/handle-sentry-send';
-export * from './processing/sentry-config';
-export * from './processing/sentry-logger';

package/dist/cjs/index.js

@@ -21,7 +21,10 @@ __exportStar(require("./event-context/event-severity"), exports);
 __exportStar(require("./event-context/extra-context.error"), exports);
 __exportStar(require("./event-context/extra-event-context"), exports);
 __exportStar(require("./init-sentry/base-sentry-init"), exports);
+__exportStar(require("./init-sentry/sentry-config"), exports);
+__exportStar(require("./logging/attach-tags"), exports);
+__exportStar(require("./logging/handle-error"), exports);
+__exportStar(require("./logging/send-log"), exports);
+__exportStar(require("./logging/sentry-client-for-logging"), exports);
 __exportStar(require("./processing/event-processor"), exports);
 __exportStar(require("./processing/handle-sentry-send"), exports);
-__exportStar(require("./processing/sentry-config"), exports);
-__exportStar(require("./processing/sentry-logger"), exports);

package/dist/cjs/init-sentry/base-sentry-init.d.ts

@@ -2,7 +2,7 @@ import type { Options } from '@sentry/types';
 import { SentryDep, SentryExecutionEnvEnum } from '../env/execution-env';
 import { SentryReleaseEnvEnum } from '../env/release-env';
 import { EventExtraContextCreator } from '../event-context/event-context';
-import { UserOverrides } from '../processing/sentry-config';
+import { UserOverrides } from './sentry-config';
 /** Configuration for initializing Sentry. */
 export type InitSentryInput = {
     /**

package/dist/cjs/init-sentry/base-sentry-init.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.baseInitSentry = void 0;
+const sentry_client_for_logging_1 = require("../logging/sentry-client-for-logging");
 const event_processor_1 = require("../processing/event-processor");
-const sentry_config_1 = require("../processing/sentry-config");
+const sentry_config_1 = require("./sentry-config");
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client
  * with all the default sentry-vir integrations and configs.
@@ -18,6 +19,7 @@ async function baseInitSentry({ dsn, releaseEnv, releaseName, sentryConfigOverri
     }, sentryConfigOverrides, releaseEnv);
     sentryDep.init(finalSentryConfig);
     sentryDep.addGlobalEventProcessor((event, hint) => (0, event_processor_1.processSentryEvent)(event, hint, createUniversalContext));
+    (0, sentry_client_for_logging_1.setSentryClientForLogging)(sentryDep);
     return sentryDep;
 }
 exports.baseInitSentry = baseInitSentry;

package/dist/cjs/{processing → init-sentry}/sentry-config.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSentryConfig = void 0;
 const common_1 = require("@augment-vir/common");
 const execution_env_1 = require("../env/execution-env");
-const handle_sentry_send_1 = require("./handle-sentry-send");
+const handle_sentry_send_1 = require("../processing/handle-sentry-send");
 /** Creates the sentry config used internally by sentry-vir. */
 // can't test config creation because it depends on execution environment
 /* c8 ignore next 60 */

package/dist/cjs/logging/attach-tags.d.ts

@@ -0,0 +1,5 @@
+import type { setTags } from '@sentry/core';
+/** A list of tag names as keys and their values. Set a tag to undefined to clear it. */
+export type SentryTags = Parameters<typeof setTags>[0];
+/** Set tags for all future Sentry event handling (errors and logs). */
+export declare function attachSentryTags(tags: SentryTags): undefined;

package/dist/cjs/logging/attach-tags.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachSentryTags = void 0;
+const premature_events_1 = require("./premature-events");
+const sentry_client_for_logging_1 = require("./sentry-client-for-logging");
+/** Set tags for all future Sentry event handling (errors and logs). */
+function attachSentryTags(tags) {
+    try {
+        if (!sentry_client_for_logging_1.sentryClientForLogging) {
+            (0, premature_events_1.addPrematureEvent)({ callback: attachSentryTags, inputs: [tags] });
+            return;
+        }
+        sentry_client_for_logging_1.sentryClientForLogging.setTags(tags);
+    }
+    catch (caught) {
+        console.error('Error while trying to attach Sentry tags:', caught);
+        return undefined;
+    }
+}
+exports.attachSentryTags = attachSentryTags;

package/dist/cjs/logging/handle-error.d.ts

@@ -0,0 +1,3 @@
+import { EventExtraContext } from '../event-context/event-context';
+/** Record an error to Sentry without throwing it. */
+export declare function handleError(error: unknown, extraContext?: EventExtraContext): string | undefined;

package/dist/cjs/logging/handle-error.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = void 0;
+const event_context_1 = require("../event-context/event-context");
+const event_severity_1 = require("../event-context/event-severity");
+const premature_events_1 = require("./premature-events");
+const sentry_client_for_logging_1 = require("./sentry-client-for-logging");
+/** Record an error to Sentry without throwing it. */
+function handleError(error, extraContext) {
+    try {
+        if (!sentry_client_for_logging_1.sentryClientForLogging) {
+            (0, premature_events_1.addPrematureEvent)({
+                callback: handleError,
+                inputs: [
+                    error,
+                    extraContext,
+                ],
+            });
+            return undefined;
+        }
+        const scopeContext = (0, event_context_1.convertEventDetailsToSentryContext)({
+            extraContext,
+            severity: event_severity_1.EventSeverityEnum.Error,
+        });
+        const eventId = sentry_client_for_logging_1.sentryClientForLogging.captureException(error, scopeContext);
+        return eventId;
+    }
+    catch (caught) {
+        console.error('Error while trying to handle error with Sentry:', caught);
+        return undefined;
+    }
+}
+exports.handleError = handleError;

package/dist/cjs/logging/premature-events.d.ts

@@ -0,0 +1,8 @@
+import { AnyFunction } from '@augment-vir/common';
+/** An event that was triggered before setSentryClientForLogging was called. */
+export type PrematureEvent<EntryPointFunction extends AnyFunction = AnyFunction> = {
+    callback: EntryPointFunction;
+    inputs: Parameters<EntryPointFunction>;
+};
+export declare function sendPrematureEvents(): void;
+export declare function addPrematureEvent(prematureEvent: PrematureEvent): void;

package/dist/cjs/logging/premature-events.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPrematureEvent = exports.sendPrematureEvents = void 0;
+/**
+ * Used to store events before the Sentry client is setup. This is exported for testing purposes
+ * only, you don't need to do anything with this.
+ */
+const prematureSentryEvents = [];
+function sendPrematureEvents() {
+    while (prematureSentryEvents.length) {
+        try {
+            const prematureEvent = prematureSentryEvents.pop();
+            if (!prematureEvent) {
+                return;
+            }
+            prematureEvent.callback(...prematureEvent.inputs);
+        }
+        catch (caught) {
+            console.error('error while trying to send premature sentry events:', caught);
+        }
+    }
+}
+exports.sendPrematureEvents = sendPrematureEvents;
+function addPrematureEvent(prematureEvent) {
+    prematureSentryEvents.push(prematureEvent);
+}
+exports.addPrematureEvent = addPrematureEvent;

package/dist/cjs/logging/send-log.d.ts

@@ -0,0 +1,13 @@
+import { Event as SentryEvent } from '@sentry/types';
+import { EventDetails, EventExtraContext } from '../event-context/event-context';
+/** Send non-error events to Sentry. */
+export declare const sendLog: {
+    /** Sends an even to Sentry with debug severity. */
+    readonly debug: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
+    /** Sends an even to Sentry with info severity. */
+    readonly info: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
+    /** Sends an even to Sentry with warning severity. */
+    readonly warning: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
+};
+declare function sendLogToSentry(logInfo: string | Omit<SentryEvent, 'extra' | 'level'>, eventDetails: EventDetails): string | undefined;
+export {};

package/dist/cjs/logging/send-log.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendLog = void 0;
+const common_1 = require("@augment-vir/common");
+const event_context_1 = require("../event-context/event-context");
+const event_severity_1 = require("../event-context/event-severity");
+const premature_events_1 = require("./premature-events");
+const sentry_client_for_logging_1 = require("./sentry-client-for-logging");
+/** Send non-error events to Sentry. */
+exports.sendLog = {
+    /** Sends an even to Sentry with debug severity. */
+    [event_severity_1.EventSeverityEnum.Debug]: wrapLogWithSeverity(event_severity_1.EventSeverityEnum.Debug),
+    /** Sends an even to Sentry with info severity. */
+    [event_severity_1.EventSeverityEnum.Info]: wrapLogWithSeverity(event_severity_1.EventSeverityEnum.Info),
+    /** Sends an even to Sentry with warning severity. */
+    [event_severity_1.EventSeverityEnum.Warning]: wrapLogWithSeverity(event_severity_1.EventSeverityEnum.Warning),
+};
+function wrapLogWithSeverity(severity) {
+    return (info, extraContext) => {
+        return sendLogToSentry(info, {
+            extraContext,
+            severity,
+        });
+    };
+}
+function sendLogToSentry(logInfo, eventDetails) {
+    try {
+        if (!sentry_client_for_logging_1.sentryClientForLogging) {
+            (0, premature_events_1.addPrematureEvent)({
+                callback: sendLogToSentry,
+                inputs: [
+                    logInfo,
+                    eventDetails,
+                ],
+            });
+            return undefined;
+        }
+        const scopeContext = (0, event_context_1.convertEventDetailsToSentryContext)(eventDetails);
+        const eventId = (0, common_1.isRuntimeTypeOf)(logInfo, 'string')
+            ? sentry_client_for_logging_1.sentryClientForLogging.captureMessage(logInfo, scopeContext)
+            : sentry_client_for_logging_1.sentryClientForLogging.captureEvent({
+                ...logInfo,
+                ...scopeContext,
+            });
+        return eventId;
+    }
+    catch (caught) {
+        console.error('Error while trying to send Sentry log:', caught);
+        return undefined;
+    }
+}

package/dist/cjs/logging/sentry-client-for-logging.d.ts

@@ -0,0 +1,17 @@
+import { MaybePromise } from '@augment-vir/common';
+import { SentryDep } from '../env/execution-env';
+/** The bare minimum Sentry client needed for logging events. */
+export type SentryClientForLogging = Pick<SentryDep, 'captureMessage' | 'captureException' | 'captureEvent' | 'setTags'>;
+/** Internal sentry client used for logging. */
+export declare let sentryClientForLogging: SentryClientForLogging | undefined;
+/**
+ * Asynchronously set the Sentry client for logging. When this is called, any events that were
+ * triggered beforehand are handled. Thus, this set can be done at any time, allowing for
+ * asynchronous Sentry client setup but synchronous log and error handling.
+ *
+ * This should be called as soon as possible after you have a return value from initSentry.
+ *
+ * This can be safely called multiple times (to overwrite the previously set Sentry client) because
+ * previous events won't be handled multiple times.
+ */
+export declare function setSentryClientForLogging(client: MaybePromise<SentryClientForLogging>): Promise<void>;

package/dist/cjs/logging/sentry-client-for-logging.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSentryClientForLogging = exports.sentryClientForLogging = void 0;
+const premature_events_1 = require("./premature-events");
+/**
+ * Asynchronously set the Sentry client for logging. When this is called, any events that were
+ * triggered beforehand are handled. Thus, this set can be done at any time, allowing for
+ * asynchronous Sentry client setup but synchronous log and error handling.
+ *
+ * This should be called as soon as possible after you have a return value from initSentry.
+ *
+ * This can be safely called multiple times (to overwrite the previously set Sentry client) because
+ * previous events won't be handled multiple times.
+ */
+async function setSentryClientForLogging(client) {
+    const hadClientBefore = !!exports.sentryClientForLogging;
+    exports.sentryClientForLogging = await client;
+    if (!hadClientBefore) {
+        (0, premature_events_1.sendPrematureEvents)();
+    }
+}
+exports.setSentryClientForLogging = setSentryClientForLogging;

package/dist/cjs/node.js

@@ -25,8 +25,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initSentry = void 0;
 const execution_env_1 = require("./env/execution-env");
+const sentry_config_1 = require("./init-sentry/sentry-config");
 const event_processor_1 = require("./processing/event-processor");
-const sentry_config_1 = require("./processing/sentry-config");
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client
  * with all the default sentry-vir integrations and configs.

package/dist/cjs/processing/event-processor.js

@@ -14,7 +14,8 @@ hint,
 /** Optional callback for creating extra event context. */
 createUniversalContext) {
     const extraContext = {
-        ...(0, extra_event_context_1.extractExtraEventContext)(hint.originalException),
+        ...(0, extra_event_context_1.extractExtraEventContext)(hint),
+        ...(0, extra_event_context_1.extractExtraEventContext)(event),
         ...createUniversalContext?.(),
         originalFullMessage: event.message || (0, common_1.extractErrorMessage)(hint.originalException),
     };

package/dist/esm/auto.js

@@ -1,6 +1,6 @@
 import { SentryExecutionEnvEnum } from './env/execution-env';
+import { createSentryConfig } from './init-sentry/sentry-config';
 import { processSentryEvent } from './processing/event-processor';
-import { createSentryConfig } from './processing/sentry-config';
 /** The sentry dep import for each execution env. */
 /* c8 ignore next 6 */
 export const sentryDepByEnv = {

package/dist/esm/browser.js

@@ -1,6 +1,6 @@
 import { SentryExecutionEnvEnum } from './env/execution-env';
+import { createSentryConfig } from './init-sentry/sentry-config';
 import { processSentryEvent } from './processing/event-processor';
-import { createSentryConfig } from './processing/sentry-config';
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client
  * with all the default sentry-vir integrations and configs.

package/dist/esm/event-context/extra-event-context.d.ts

@@ -1,3 +1,4 @@
+import { Event, EventHint } from '@sentry/types';
 import { EventExtraContext } from './event-context';
 /**
  * Symbol used to attach extra event context to events. This is particularly useful for errors so
@@ -10,8 +11,13 @@ export type HasExtraContext = {
 };
 /** Type guard for whether any given input has extra event context. */
 export declare function hasExtraEventContext(input: unknown): input is HasExtraContext;
+/**
+ * Checks if extra event context has been injected into the input via extraEventContextSymbol and,
+ * if so, extracts it.
+ */
+export declare function extractExtraContentFromSymbol(input: unknown): EventExtraContext | undefined;
 /**
  * Tries to extract extra event context via extraEventContextSymbol. Returns undefined if there is
  * no extra event context.
  */
-export declare function extractExtraEventContext(event: unknown): EventExtraContext | undefined;
+export declare function extractExtraEventContext(event: EventHint | Event): EventExtraContext | undefined;

package/dist/esm/event-context/extra-event-context.js

@@ -8,13 +8,35 @@ export const extraEventContextSymbol = Symbol('extra-event-context');
 export function hasExtraEventContext(input) {
     return typedHasProperty(input, extraEventContextSymbol);
 }
+/**
+ * Checks if extra event context has been injected into the input via extraEventContextSymbol and,
+ * if so, extracts it.
+ */
+export function extractExtraContentFromSymbol(input) {
+    if (hasExtraEventContext(input)) {
+        return input[extraEventContextSymbol];
+    }
+    else {
+        return undefined;
+    }
+}
 /**
  * Tries to extract extra event context via extraEventContextSymbol. Returns undefined if there is
  * no extra event context.
  */
 export function extractExtraEventContext(event) {
-    if (hasExtraEventContext(event)) {
-        return event[extraEventContextSymbol];
+    const fromRootSymbol = extractExtraContentFromSymbol(event);
+    const fromSubSymbol = 'originalException' in event
+        ? extractExtraContentFromSymbol(event.originalException)
+        : undefined;
+    const fromCapture = 'captureContext' in event ? event.captureContext : undefined;
+    const combined = {
+        ...fromRootSymbol,
+        ...fromSubSymbol,
+        ...fromCapture,
+    };
+    if (Object.keys(combined).length) {
+        return combined;
     }
     else {
         return undefined;

package/dist/esm/index.d.ts

@@ -5,7 +5,10 @@ export * from './event-context/event-severity';
 export * from './event-context/extra-context.error';
 export * from './event-context/extra-event-context';
 export * from './init-sentry/base-sentry-init';
+export * from './init-sentry/sentry-config';
+export * from './logging/attach-tags';
+export * from './logging/handle-error';
+export * from './logging/send-log';
+export * from './logging/sentry-client-for-logging';
 export * from './processing/event-processor';
 export * from './processing/handle-sentry-send';
-export * from './processing/sentry-config';
-export * from './processing/sentry-logger';

package/dist/esm/index.js

@@ -5,7 +5,10 @@ export * from './event-context/event-severity';
 export * from './event-context/extra-context.error';
 export * from './event-context/extra-event-context';
 export * from './init-sentry/base-sentry-init';
+export * from './init-sentry/sentry-config';
+export * from './logging/attach-tags';
+export * from './logging/handle-error';
+export * from './logging/send-log';
+export * from './logging/sentry-client-for-logging';
 export * from './processing/event-processor';
 export * from './processing/handle-sentry-send';
-export * from './processing/sentry-config';
-export * from './processing/sentry-logger';

package/dist/esm/init-sentry/base-sentry-init.d.ts

@@ -2,7 +2,7 @@ import type { Options } from '@sentry/types';
 import { SentryDep, SentryExecutionEnvEnum } from '../env/execution-env';
 import { SentryReleaseEnvEnum } from '../env/release-env';
 import { EventExtraContextCreator } from '../event-context/event-context';
-import { UserOverrides } from '../processing/sentry-config';
+import { UserOverrides } from './sentry-config';
 /** Configuration for initializing Sentry. */
 export type InitSentryInput = {
     /**

package/dist/esm/init-sentry/base-sentry-init.js

@@ -1,5 +1,6 @@
+import { setSentryClientForLogging } from '../logging/sentry-client-for-logging';
 import { processSentryEvent } from '../processing/event-processor';
-import { createSentryConfig } from '../processing/sentry-config';
+import { createSentryConfig } from './sentry-config';
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client
  * with all the default sentry-vir integrations and configs.
@@ -15,5 +16,6 @@ export async function baseInitSentry({ dsn, releaseEnv, releaseName, sentryConfi
     }, sentryConfigOverrides, releaseEnv);
     sentryDep.init(finalSentryConfig);
     sentryDep.addGlobalEventProcessor((event, hint) => processSentryEvent(event, hint, createUniversalContext));
+    setSentryClientForLogging(sentryDep);
     return sentryDep;
 }

package/dist/esm/{processing → init-sentry}/sentry-config.js

@@ -1,6 +1,6 @@
 import { mergeDeep } from '@augment-vir/common';
 import { SentryExecutionEnvEnum, } from '../env/execution-env';
-import { createSentryHandler } from './handle-sentry-send';
+import { createSentryHandler } from '../processing/handle-sentry-send';
 /** Creates the sentry config used internally by sentry-vir. */
 // can't test config creation because it depends on execution environment
 /* c8 ignore next 60 */

package/dist/esm/logging/attach-tags.d.ts

@@ -0,0 +1,5 @@
+import type { setTags } from '@sentry/core';
+/** A list of tag names as keys and their values. Set a tag to undefined to clear it. */
+export type SentryTags = Parameters<typeof setTags>[0];
+/** Set tags for all future Sentry event handling (errors and logs). */
+export declare function attachSentryTags(tags: SentryTags): undefined;

package/dist/esm/logging/attach-tags.js

@@ -0,0 +1,16 @@
+import { addPrematureEvent } from './premature-events';
+import { sentryClientForLogging } from './sentry-client-for-logging';
+/** Set tags for all future Sentry event handling (errors and logs). */
+export function attachSentryTags(tags) {
+    try {
+        if (!sentryClientForLogging) {
+            addPrematureEvent({ callback: attachSentryTags, inputs: [tags] });
+            return;
+        }
+        sentryClientForLogging.setTags(tags);
+    }
+    catch (caught) {
+        console.error('Error while trying to attach Sentry tags:', caught);
+        return undefined;
+    }
+}

package/dist/esm/logging/handle-error.d.ts

@@ -0,0 +1,3 @@
+import { EventExtraContext } from '../event-context/event-context';
+/** Record an error to Sentry without throwing it. */
+export declare function handleError(error: unknown, extraContext?: EventExtraContext): string | undefined;

package/dist/esm/logging/handle-error.js

@@ -0,0 +1,29 @@
+import { convertEventDetailsToSentryContext, } from '../event-context/event-context';
+import { EventSeverityEnum } from '../event-context/event-severity';
+import { addPrematureEvent } from './premature-events';
+import { sentryClientForLogging } from './sentry-client-for-logging';
+/** Record an error to Sentry without throwing it. */
+export function handleError(error, extraContext) {
+    try {
+        if (!sentryClientForLogging) {
+            addPrematureEvent({
+                callback: handleError,
+                inputs: [
+                    error,
+                    extraContext,
+                ],
+            });
+            return undefined;
+        }
+        const scopeContext = convertEventDetailsToSentryContext({
+            extraContext,
+            severity: EventSeverityEnum.Error,
+        });
+        const eventId = sentryClientForLogging.captureException(error, scopeContext);
+        return eventId;
+    }
+    catch (caught) {
+        console.error('Error while trying to handle error with Sentry:', caught);
+        return undefined;
+    }
+}

package/dist/esm/logging/premature-events.d.ts

@@ -0,0 +1,8 @@
+import { AnyFunction } from '@augment-vir/common';
+/** An event that was triggered before setSentryClientForLogging was called. */
+export type PrematureEvent<EntryPointFunction extends AnyFunction = AnyFunction> = {
+    callback: EntryPointFunction;
+    inputs: Parameters<EntryPointFunction>;
+};
+export declare function sendPrematureEvents(): void;
+export declare function addPrematureEvent(prematureEvent: PrematureEvent): void;

package/dist/esm/logging/premature-events.js

@@ -0,0 +1,22 @@
+/**
+ * Used to store events before the Sentry client is setup. This is exported for testing purposes
+ * only, you don't need to do anything with this.
+ */
+const prematureSentryEvents = [];
+export function sendPrematureEvents() {
+    while (prematureSentryEvents.length) {
+        try {
+            const prematureEvent = prematureSentryEvents.pop();
+            if (!prematureEvent) {
+                return;
+            }
+            prematureEvent.callback(...prematureEvent.inputs);
+        }
+        catch (caught) {
+            console.error('error while trying to send premature sentry events:', caught);
+        }
+    }
+}
+export function addPrematureEvent(prematureEvent) {
+    prematureSentryEvents.push(prematureEvent);
+}

package/dist/esm/logging/send-log.d.ts

@@ -0,0 +1,13 @@
+import { Event as SentryEvent } from '@sentry/types';
+import { EventDetails, EventExtraContext } from '../event-context/event-context';
+/** Send non-error events to Sentry. */
+export declare const sendLog: {
+    /** Sends an even to Sentry with debug severity. */
+    readonly debug: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
+    /** Sends an even to Sentry with info severity. */
+    readonly info: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
+    /** Sends an even to Sentry with warning severity. */
+    readonly warning: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
+};
+declare function sendLogToSentry(logInfo: string | Omit<SentryEvent, 'extra' | 'level'>, eventDetails: EventDetails): string | undefined;
+export {};

package/dist/esm/logging/send-log.js

@@ -0,0 +1,48 @@
+import { isRuntimeTypeOf } from '@augment-vir/common';
+import { convertEventDetailsToSentryContext, } from '../event-context/event-context';
+import { EventSeverityEnum } from '../event-context/event-severity';
+import { addPrematureEvent } from './premature-events';
+import { sentryClientForLogging } from './sentry-client-for-logging';
+/** Send non-error events to Sentry. */
+export const sendLog = {
+    /** Sends an even to Sentry with debug severity. */
+    [EventSeverityEnum.Debug]: wrapLogWithSeverity(EventSeverityEnum.Debug),
+    /** Sends an even to Sentry with info severity. */
+    [EventSeverityEnum.Info]: wrapLogWithSeverity(EventSeverityEnum.Info),
+    /** Sends an even to Sentry with warning severity. */
+    [EventSeverityEnum.Warning]: wrapLogWithSeverity(EventSeverityEnum.Warning),
+};
+function wrapLogWithSeverity(severity) {
+    return (info, extraContext) => {
+        return sendLogToSentry(info, {
+            extraContext,
+            severity,
+        });
+    };
+}
+function sendLogToSentry(logInfo, eventDetails) {
+    try {
+        if (!sentryClientForLogging) {
+            addPrematureEvent({
+                callback: sendLogToSentry,
+                inputs: [
+                    logInfo,
+                    eventDetails,
+                ],
+            });
+            return undefined;
+        }
+        const scopeContext = convertEventDetailsToSentryContext(eventDetails);
+        const eventId = isRuntimeTypeOf(logInfo, 'string')
+            ? sentryClientForLogging.captureMessage(logInfo, scopeContext)
+            : sentryClientForLogging.captureEvent({
+                ...logInfo,
+                ...scopeContext,
+            });
+        return eventId;
+    }
+    catch (caught) {
+        console.error('Error while trying to send Sentry log:', caught);
+        return undefined;
+    }
+}

package/dist/esm/logging/sentry-client-for-logging.d.ts

@@ -0,0 +1,17 @@
+import { MaybePromise } from '@augment-vir/common';
+import { SentryDep } from '../env/execution-env';
+/** The bare minimum Sentry client needed for logging events. */
+export type SentryClientForLogging = Pick<SentryDep, 'captureMessage' | 'captureException' | 'captureEvent' | 'setTags'>;
+/** Internal sentry client used for logging. */
+export declare let sentryClientForLogging: SentryClientForLogging | undefined;
+/**
+ * Asynchronously set the Sentry client for logging. When this is called, any events that were
+ * triggered beforehand are handled. Thus, this set can be done at any time, allowing for
+ * asynchronous Sentry client setup but synchronous log and error handling.
+ *
+ * This should be called as soon as possible after you have a return value from initSentry.
+ *
+ * This can be safely called multiple times (to overwrite the previously set Sentry client) because
+ * previous events won't be handled multiple times.
+ */
+export declare function setSentryClientForLogging(client: MaybePromise<SentryClientForLogging>): Promise<void>;

package/dist/esm/logging/sentry-client-for-logging.js

@@ -0,0 +1,20 @@
+import { sendPrematureEvents } from './premature-events';
+/** Internal sentry client used for logging. */
+export let sentryClientForLogging;
+/**
+ * Asynchronously set the Sentry client for logging. When this is called, any events that were
+ * triggered beforehand are handled. Thus, this set can be done at any time, allowing for
+ * asynchronous Sentry client setup but synchronous log and error handling.
+ *
+ * This should be called as soon as possible after you have a return value from initSentry.
+ *
+ * This can be safely called multiple times (to overwrite the previously set Sentry client) because
+ * previous events won't be handled multiple times.
+ */
+export async function setSentryClientForLogging(client) {
+    const hadClientBefore = !!sentryClientForLogging;
+    sentryClientForLogging = await client;
+    if (!hadClientBefore) {
+        sendPrematureEvents();
+    }
+}

package/dist/esm/node.js

@@ -1,6 +1,6 @@
 import { SentryExecutionEnvEnum } from './env/execution-env';
+import { createSentryConfig } from './init-sentry/sentry-config';
 import { processSentryEvent } from './processing/event-processor';
-import { createSentryConfig } from './processing/sentry-config';
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client
  * with all the default sentry-vir integrations and configs.

package/dist/esm/processing/event-processor.js

@@ -11,7 +11,8 @@ hint,
 /** Optional callback for creating extra event context. */
 createUniversalContext) {
     const extraContext = {
-        ...extractExtraEventContext(hint.originalException),
+        ...extractExtraEventContext(hint),
+        ...extractExtraEventContext(event),
         ...createUniversalContext?.(),
         originalFullMessage: event.message || extractErrorMessage(hint.originalException),
     };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sentry-vir",
-    "version": "0.1.2",
+    "version": "0.2.1",
     "keywords": [
         "config",
         "helper",
@@ -29,21 +29,24 @@
         "format": "virmator format",
         "publish": "virmator publish \"npm run compile && npm run test:all\"",
         "test": "virmator test-web",
-        "test:all": "concurrently --colors --kill-others-on-fail -c auto --names types,tests,spelling,format,docs \"npm run test:types\" \"npm run test:coverage\" \"npm run test:spelling\" \"npm run test:format\" \"npm run test:docs\"",
+        "test:all": "concurrently --colors --kill-others-on-fail -c auto --names types,tests,spelling,format,docs,deps \"npm run test:types\" \"npm run test:coverage\" \"npm run test:spelling\" \"npm run test:format\" \"npm run test:docs\" \"npm run test:deps\"",
         "test:coverage": "npm run test coverage",
+        "test:deps": "virmator deps check",
         "test:docs": "virmator docs check",
         "test:format": "virmator format check",
         "test:spelling": "virmator spellcheck",
         "test:types": "tsc --noEmit"
     },
     "dependencies": {
-        "@augment-vir/common": "^19.4.2",
+        "@augment-vir/common": "^20.0.1",
         "@sentry/browser": "^7.73.0",
+        "@sentry/core": "^7.73.0",
         "@sentry/node": "^7.73.0",
-        "type-fest": "^4.3.3"
+        "@sentry/types": "^7.73.0",
+        "type-fest": "^4.4.0"
     },
     "devDependencies": {
-        "@augment-vir/browser-testing": "^19.4.2",
+        "@augment-vir/browser-testing": "^20.0.1",
         "@open-wc/testing": "^3.2.0",
         "@types/mocha": "^10.0.2",
         "@web/dev-server-esbuild": "^0.4.1",
@@ -52,6 +55,7 @@
         "@web/test-runner-playwright": "^0.10.1",
         "@web/test-runner-visual-regression": "^0.8.2",
         "cspell": "^7.3.7",
+        "dependency-cruiser": "^14.1.1",
         "esbuild": "^0.19.4",
         "istanbul-smart-text-reporter": "^1.1.2",
         "markdown-code-example-inserter": "^0.3.2",
@@ -64,7 +68,7 @@
         "prettier-plugin-packagejson": "^2.4.6",
         "prettier-plugin-sort-json": "^2.0.0",
         "prettier-plugin-toml": "^0.3.5",
-        "typedoc": "^0.25.1",
-        "virmator": "^8.0.5"
+        "typedoc": "^0.25.2",
+        "virmator": "^9.1.1"
     }
 }

package/dist/cjs/processing/sentry-logger.d.ts

@@ -1,40 +0,0 @@
-import { AnyFunction, MaybePromise } from '@augment-vir/common';
-import type { Event as SentryEvent } from '@sentry/types';
-import type { SentryDep } from '../env/execution-env';
-import { EventDetails, EventExtraContext } from '../event-context/event-context';
-/** The bare minimum Sentry client needed for logging events. */
-export type SentryClientForLogging = Pick<SentryDep, 'captureMessage' | 'captureException' | 'captureEvent'>;
-/** An event that was triggered before setSentryClientForLogging was called. */
-export type PrematureEvent<EntryPointFunction extends AnyFunction = AnyFunction> = {
-    entryPoint: EntryPointFunction;
-    inputs: Parameters<EntryPointFunction>;
-};
-/**
- * Used to store events before the Sentry client is setup. This is exported for testing purposes
- * only, you don't need to do anything with this.
- */
-export declare const prematureSentryEvents: PrematureEvent[];
-/**
- * Asynchronously set the Sentry client for logging. When this is called, any events that were
- * triggered beforehand are handled. Thus, this set can be done at any time, allowing for
- * asynchronous Sentry client setup but synchronous log and error handling.
- *
- * This should be called as soon as possible after you have a return value from initSentry.
- *
- * This can be safely called multiple times (to overwrite the previously set Sentry client) because
- * previous events won't be handled multiple times.
- */
-export declare function setSentryClientForLogging(client: MaybePromise<SentryClientForLogging>): Promise<void>;
-/** Record an error to Sentry without throwing it. */
-export declare function handleError(error: unknown, extraContext?: EventExtraContext): string | undefined;
-/** Send non-error events to Sentry. */
-export declare const sendLog: {
-    /** Sends an even to Sentry with debug severity. */
-    readonly debug: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
-    /** Sends an even to Sentry with info severity. */
-    readonly info: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
-    /** Sends an even to Sentry with warning severity. */
-    readonly warning: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
-};
-declare function sendLogToSentry(logInfo: string | Omit<SentryEvent, 'extra' | 'level'>, eventDetails: EventDetails): string | undefined;
-export {};

package/dist/cjs/processing/sentry-logger.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendLog = exports.handleError = exports.setSentryClientForLogging = exports.prematureSentryEvents = void 0;
-const common_1 = require("@augment-vir/common");
-const event_context_1 = require("../event-context/event-context");
-const event_severity_1 = require("../event-context/event-severity");
-let sentryClientForLogging;
-/**
- * Used to store events before the Sentry client is setup. This is exported for testing purposes
- * only, you don't need to do anything with this.
- */
-exports.prematureSentryEvents = [];
-/**
- * Asynchronously set the Sentry client for logging. When this is called, any events that were
- * triggered beforehand are handled. Thus, this set can be done at any time, allowing for
- * asynchronous Sentry client setup but synchronous log and error handling.
- *
- * This should be called as soon as possible after you have a return value from initSentry.
- *
- * This can be safely called multiple times (to overwrite the previously set Sentry client) because
- * previous events won't be handled multiple times.
- */
-async function setSentryClientForLogging(client) {
-    const hadClientBefore = !!sentryClientForLogging;
-    sentryClientForLogging = await client;
-    if (!hadClientBefore) {
-        sendPrematureEvents();
-    }
-}
-exports.setSentryClientForLogging = setSentryClientForLogging;
-function sendPrematureEvents() {
-    while (exports.prematureSentryEvents.length) {
-        try {
-            const prematureLog = exports.prematureSentryEvents.pop();
-            if (!prematureLog) {
-                return;
-            }
-            prematureLog.entryPoint(...prematureLog.inputs);
-        }
-        catch (caught) {
-            console.error('error while trying to send sentry logs:', caught);
-        }
-    }
-}
-/** Record an error to Sentry without throwing it. */
-function handleError(error, extraContext) {
-    try {
-        if (!sentryClientForLogging) {
-            exports.prematureSentryEvents.push({
-                entryPoint: handleError,
-                inputs: [
-                    error,
-                    extraContext,
-                ],
-            });
-            return undefined;
-        }
-        const scopeContext = (0, event_context_1.convertEventDetailsToSentryContext)({
-            extraContext,
-            severity: event_severity_1.EventSeverityEnum.Error,
-        });
-        const eventId = sentryClientForLogging.captureException(error, scopeContext);
-        return eventId;
-    }
-    catch (caught) {
-        console.error('error while trying to handle error:', caught);
-        return undefined;
-    }
-}
-exports.handleError = handleError;
-/** Send non-error events to Sentry. */
-exports.sendLog = {
-    /** Sends an even to Sentry with debug severity. */
-    [event_severity_1.EventSeverityEnum.Debug]: wrapLogWithSeverity(event_severity_1.EventSeverityEnum.Debug),
-    /** Sends an even to Sentry with info severity. */
-    [event_severity_1.EventSeverityEnum.Info]: wrapLogWithSeverity(event_severity_1.EventSeverityEnum.Info),
-    /** Sends an even to Sentry with warning severity. */
-    [event_severity_1.EventSeverityEnum.Warning]: wrapLogWithSeverity(event_severity_1.EventSeverityEnum.Warning),
-};
-function wrapLogWithSeverity(severity) {
-    return (info, extraContext) => {
-        return sendLogToSentry(info, {
-            extraContext,
-            severity,
-        });
-    };
-}
-function sendLogToSentry(logInfo, eventDetails) {
-    try {
-        if (!sentryClientForLogging) {
-            exports.prematureSentryEvents.push({
-                entryPoint: sendLogToSentry,
-                inputs: [
-                    logInfo,
-                    eventDetails,
-                ],
-            });
-            return undefined;
-        }
-        const scopeContext = (0, event_context_1.convertEventDetailsToSentryContext)(eventDetails);
-        const eventId = (0, common_1.isRuntimeTypeOf)(logInfo, 'string')
-            ? sentryClientForLogging.captureMessage(logInfo, scopeContext)
-            : sentryClientForLogging.captureEvent({
-                ...logInfo,
-                ...scopeContext,
-            });
-        return eventId;
-    }
-    catch (caught) {
-        console.error('error while trying to send log:', caught);
-        return undefined;
-    }
-}

package/dist/esm/processing/sentry-logger.d.ts

@@ -1,40 +0,0 @@
-import { AnyFunction, MaybePromise } from '@augment-vir/common';
-import type { Event as SentryEvent } from '@sentry/types';
-import type { SentryDep } from '../env/execution-env';
-import { EventDetails, EventExtraContext } from '../event-context/event-context';
-/** The bare minimum Sentry client needed for logging events. */
-export type SentryClientForLogging = Pick<SentryDep, 'captureMessage' | 'captureException' | 'captureEvent'>;
-/** An event that was triggered before setSentryClientForLogging was called. */
-export type PrematureEvent<EntryPointFunction extends AnyFunction = AnyFunction> = {
-    entryPoint: EntryPointFunction;
-    inputs: Parameters<EntryPointFunction>;
-};
-/**
- * Used to store events before the Sentry client is setup. This is exported for testing purposes
- * only, you don't need to do anything with this.
- */
-export declare const prematureSentryEvents: PrematureEvent[];
-/**
- * Asynchronously set the Sentry client for logging. When this is called, any events that were
- * triggered beforehand are handled. Thus, this set can be done at any time, allowing for
- * asynchronous Sentry client setup but synchronous log and error handling.
- *
- * This should be called as soon as possible after you have a return value from initSentry.
- *
- * This can be safely called multiple times (to overwrite the previously set Sentry client) because
- * previous events won't be handled multiple times.
- */
-export declare function setSentryClientForLogging(client: MaybePromise<SentryClientForLogging>): Promise<void>;
-/** Record an error to Sentry without throwing it. */
-export declare function handleError(error: unknown, extraContext?: EventExtraContext): string | undefined;
-/** Send non-error events to Sentry. */
-export declare const sendLog: {
-    /** Sends an even to Sentry with debug severity. */
-    readonly debug: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
-    /** Sends an even to Sentry with info severity. */
-    readonly info: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
-    /** Sends an even to Sentry with warning severity. */
-    readonly warning: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
-};
-declare function sendLogToSentry(logInfo: string | Omit<SentryEvent, 'extra' | 'level'>, eventDetails: EventDetails): string | undefined;
-export {};

package/dist/esm/processing/sentry-logger.js

@@ -1,108 +0,0 @@
-import { isRuntimeTypeOf } from '@augment-vir/common';
-import { convertEventDetailsToSentryContext, } from '../event-context/event-context';
-import { EventSeverityEnum } from '../event-context/event-severity';
-let sentryClientForLogging;
-/**
- * Used to store events before the Sentry client is setup. This is exported for testing purposes
- * only, you don't need to do anything with this.
- */
-export const prematureSentryEvents = [];
-/**
- * Asynchronously set the Sentry client for logging. When this is called, any events that were
- * triggered beforehand are handled. Thus, this set can be done at any time, allowing for
- * asynchronous Sentry client setup but synchronous log and error handling.
- *
- * This should be called as soon as possible after you have a return value from initSentry.
- *
- * This can be safely called multiple times (to overwrite the previously set Sentry client) because
- * previous events won't be handled multiple times.
- */
-export async function setSentryClientForLogging(client) {
-    const hadClientBefore = !!sentryClientForLogging;
-    sentryClientForLogging = await client;
-    if (!hadClientBefore) {
-        sendPrematureEvents();
-    }
-}
-function sendPrematureEvents() {
-    while (prematureSentryEvents.length) {
-        try {
-            const prematureLog = prematureSentryEvents.pop();
-            if (!prematureLog) {
-                return;
-            }
-            prematureLog.entryPoint(...prematureLog.inputs);
-        }
-        catch (caught) {
-            console.error('error while trying to send sentry logs:', caught);
-        }
-    }
-}
-/** Record an error to Sentry without throwing it. */
-export function handleError(error, extraContext) {
-    try {
-        if (!sentryClientForLogging) {
-            prematureSentryEvents.push({
-                entryPoint: handleError,
-                inputs: [
-                    error,
-                    extraContext,
-                ],
-            });
-            return undefined;
-        }
-        const scopeContext = convertEventDetailsToSentryContext({
-            extraContext,
-            severity: EventSeverityEnum.Error,
-        });
-        const eventId = sentryClientForLogging.captureException(error, scopeContext);
-        return eventId;
-    }
-    catch (caught) {
-        console.error('error while trying to handle error:', caught);
-        return undefined;
-    }
-}
-/** Send non-error events to Sentry. */
-export const sendLog = {
-    /** Sends an even to Sentry with debug severity. */
-    [EventSeverityEnum.Debug]: wrapLogWithSeverity(EventSeverityEnum.Debug),
-    /** Sends an even to Sentry with info severity. */
-    [EventSeverityEnum.Info]: wrapLogWithSeverity(EventSeverityEnum.Info),
-    /** Sends an even to Sentry with warning severity. */
-    [EventSeverityEnum.Warning]: wrapLogWithSeverity(EventSeverityEnum.Warning),
-};
-function wrapLogWithSeverity(severity) {
-    return (info, extraContext) => {
-        return sendLogToSentry(info, {
-            extraContext,
-            severity,
-        });
-    };
-}
-function sendLogToSentry(logInfo, eventDetails) {
-    try {
-        if (!sentryClientForLogging) {
-            prematureSentryEvents.push({
-                entryPoint: sendLogToSentry,
-                inputs: [
-                    logInfo,
-                    eventDetails,
-                ],
-            });
-            return undefined;
-        }
-        const scopeContext = convertEventDetailsToSentryContext(eventDetails);
-        const eventId = isRuntimeTypeOf(logInfo, 'string')
-            ? sentryClientForLogging.captureMessage(logInfo, scopeContext)
-            : sentryClientForLogging.captureEvent({
-                ...logInfo,
-                ...scopeContext,
-            });
-        return eventId;
-    }
-    catch (caught) {
-        console.error('error while trying to send log:', caught);
-        return undefined;
-    }
-}