sentry-vir 0.1.1 → 0.2.0

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 './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("./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/logging/attach-tags.d.ts

@@ -0,0 +1,11 @@
+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). This can be called before
+ * setSentryClientForLogging has been called, as sentry-vir will buffer all events. However,
+ * setSentryClientForLogging must be called once at some point to actually clear that buffer.
+ *
+ * Similar to handleError and sendLog.
+ */
+export declare function attachSentryTags(tags: SentryTags): undefined;

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

@@ -0,0 +1,26 @@
+"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). This can be called before
+ * setSentryClientForLogging has been called, as sentry-vir will buffer all events. However,
+ * setSentryClientForLogging must be called once at some point to actually clear that buffer.
+ *
+ * Similar to handleError and sendLog.
+ */
+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,9 @@
+import { EventExtraContext } from '../event-context/event-context';
+/**
+ * Record an error to Sentry without throwing it. This can be called before
+ * setSentryClientForLogging has been called, as sentry-vir will buffer all events. However,
+ * setSentryClientForLogging must be called once at some point to actually clear that buffer.
+ *
+ * Similar to attachSentryTags and sendLog.
+ */
+export declare function handleError(error: unknown, extraContext?: EventExtraContext): string | undefined;

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

@@ -0,0 +1,39 @@
+"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. This can be called before
+ * setSentryClientForLogging has been called, as sentry-vir will buffer all events. However,
+ * setSentryClientForLogging must be called once at some point to actually clear that buffer.
+ *
+ * Similar to attachSentryTags and sendLog.
+ */
+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,19 @@
+import { Event as SentryEvent } from '@sentry/types';
+import { EventDetails, EventExtraContext } from '../event-context/event-context';
+/**
+ * Send non-error events to Sentry. This can be called before setSentryClientForLogging has been
+ * called, as sentry-vir will buffer all events. However, setSentryClientForLogging must be called
+ * once at some point to actually clear that buffer.
+ *
+ * Similar to attachSentryTags and handleError.
+ */
+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,57 @@
+"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. This can be called before setSentryClientForLogging has been
+ * called, as sentry-vir will buffer all events. However, setSentryClientForLogging must be called
+ * once at some point to actually clear that buffer.
+ *
+ * Similar to attachSentryTags and handleError.
+ */
+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,21 @@
+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. Use setSentryClientForLogging to set this. Allows
+ * handleError, setTags, and sendLog to be called before the Sentry client has been setup yet, as
+ * once this is set all events fired from those functions will get sent to Sentry.
+ */
+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/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 './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 './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/logging/attach-tags.d.ts

@@ -0,0 +1,11 @@
+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). This can be called before
+ * setSentryClientForLogging has been called, as sentry-vir will buffer all events. However,
+ * setSentryClientForLogging must be called once at some point to actually clear that buffer.
+ *
+ * Similar to handleError and sendLog.
+ */
+export declare function attachSentryTags(tags: SentryTags): undefined;

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

@@ -0,0 +1,22 @@
+import { addPrematureEvent } from './premature-events';
+import { sentryClientForLogging } from './sentry-client-for-logging';
+/**
+ * Set tags for all future Sentry event handling (errors and logs). This can be called before
+ * setSentryClientForLogging has been called, as sentry-vir will buffer all events. However,
+ * setSentryClientForLogging must be called once at some point to actually clear that buffer.
+ *
+ * Similar to handleError and sendLog.
+ */
+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,9 @@
+import { EventExtraContext } from '../event-context/event-context';
+/**
+ * Record an error to Sentry without throwing it. This can be called before
+ * setSentryClientForLogging has been called, as sentry-vir will buffer all events. However,
+ * setSentryClientForLogging must be called once at some point to actually clear that buffer.
+ *
+ * Similar to attachSentryTags and sendLog.
+ */
+export declare function handleError(error: unknown, extraContext?: EventExtraContext): string | undefined;

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

@@ -0,0 +1,35 @@
+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. This can be called before
+ * setSentryClientForLogging has been called, as sentry-vir will buffer all events. However,
+ * setSentryClientForLogging must be called once at some point to actually clear that buffer.
+ *
+ * Similar to attachSentryTags and sendLog.
+ */
+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,19 @@
+import { Event as SentryEvent } from '@sentry/types';
+import { EventDetails, EventExtraContext } from '../event-context/event-context';
+/**
+ * Send non-error events to Sentry. This can be called before setSentryClientForLogging has been
+ * called, as sentry-vir will buffer all events. However, setSentryClientForLogging must be called
+ * once at some point to actually clear that buffer.
+ *
+ * Similar to attachSentryTags and handleError.
+ */
+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,54 @@
+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. This can be called before setSentryClientForLogging has been
+ * called, as sentry-vir will buffer all events. However, setSentryClientForLogging must be called
+ * once at some point to actually clear that buffer.
+ *
+ * Similar to attachSentryTags and handleError.
+ */
+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,21 @@
+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. Use setSentryClientForLogging to set this. Allows
+ * handleError, setTags, and sendLog to be called before the Sentry client has been setup yet, as
+ * once this is set all events fired from those functions will get sent to Sentry.
+ */
+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,24 @@
+import { sendPrematureEvents } from './premature-events';
+/**
+ * Internal sentry client used for logging. Use setSentryClientForLogging to set this. Allows
+ * handleError, setTags, and sendLog to be called before the Sentry client has been setup yet, as
+ * once this is set all events fired from those functions will get sent to Sentry.
+ */
+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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sentry-vir",
-    "version": "0.1.1",
+    "version": "0.2.0",
     "keywords": [
         "config",
         "helper",
@@ -23,9 +23,6 @@
     "main": "dist/cjs/index.js",
     "module": "dist/esm/index.js",
     "types": "dist/esm/index.d.ts",
-    "workspaces": [
-        "./"
-    ],
     "scripts": {
         "compile": "rm -rf dist && tsc --project tsconfig.json && npm i && tsc --project tsconfig.cjs.json",
         "docs": "virmator docs",

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;
-    }
-}