sentry-vir 0.0.0 → 0.0.1

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

@@ -0,0 +1,7 @@
+/** Maps internal EventDetails type to Sentry's required type for event severity and extra context. */
+export function convertEventDetailsToSentryContext(eventDetails) {
+    return {
+        extra: eventDetails.extraContext ?? {},
+        level: eventDetails.severity,
+    };
+}

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

@@ -0,0 +1,32 @@
+import { isEnumValue } from '@augment-vir/common';
+/** Mapped from Sentry's values into an enum for convenience of use. */
+export var EventSeverityEnum;
+(function (EventSeverityEnum) {
+    EventSeverityEnum["Warning"] = "warning";
+    EventSeverityEnum["Info"] = "info";
+    EventSeverityEnum["Debug"] = "debug";
+    EventSeverityEnum["Fatal"] = "fatal";
+    EventSeverityEnum["Error"] = "error";
+})(EventSeverityEnum || (EventSeverityEnum = {}));
+const consoleLogMethodsPerSeverity = {
+    [EventSeverityEnum.Warning]: console.warn,
+    [EventSeverityEnum.Info]: console.info,
+    [EventSeverityEnum.Debug]: console.debug,
+    [EventSeverityEnum.Fatal]: console.error,
+    [EventSeverityEnum.Error]: console.error,
+};
+/** Extracts the severity level from a sentry event while defaulting to an info level severity. */
+export function extractEventSeverity(event) {
+    if (!isEnumValue(event.level, EventSeverityEnum)) {
+        return EventSeverityEnum.Info;
+    }
+    return event.level;
+}
+/**
+ * Determines which console method should be used for local logging based on the given event's
+ * severity.
+ */
+export function getConsoleMethodForSeverity(event) {
+    const severity = extractEventSeverity(event);
+    return consoleLogMethodsPerSeverity[severity];
+}

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

@@ -0,0 +1,30 @@
+import { ensureError } from '@augment-vir/common';
+import { extraEventContextSymbol } from './extra-event-context';
+/**
+ * Constructs an error with extra event context attached to it in the same way that
+ * throwWithExtraContext attaches data.
+ *
+ * The following examples are equivalent:
+ *
+ * @example
+ *     throw new ExtraContextError('my error', {stuff: 'hi'});
+ *
+ * @example
+ *     const myError = new Error('my error');
+ *     throwWithExtraContext(myError, {stuff: 'hi'});
+ */
+export class ExtraContextError extends Error {
+    constructor(message, extraData) {
+        super(message);
+        this[extraEventContextSymbol] = extraData;
+    }
+}
+/**
+ * Adds extra context to an error without modifying the error's message or stack trace (or any of
+ * its other properties), then throws the error so it can propagate as usual.
+ */
+export function throwWithExtraContext(originalError, extraData) {
+    const error = ensureError(originalError);
+    error[extraEventContextSymbol] = extraData;
+    throw error;
+}

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

@@ -0,0 +1,22 @@
+import { typedHasProperty } from '@augment-vir/common';
+/**
+ * Symbol used to attach extra event context to events. This is particularly useful for errors so
+ * they can be thrown while attaching this extra context to them.
+ */
+export const extraEventContextSymbol = Symbol('extra-event-context');
+/** Type guard for whether any given input has extra event context. */
+export function hasExtraEventContext(input) {
+    return typedHasProperty(input, extraEventContextSymbol);
+}
+/**
+ * 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];
+    }
+    else {
+        return undefined;
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,11 @@
+export * from './env/execution-env';
+export * from './env/release-env';
+export * from './event-context/event-context';
+export * from './event-context/event-severity';
+export * from './event-context/extra-context.error';
+export * from './event-context/extra-event-context';
+export * from './init-sentry/event-processor';
+export * from './init-sentry/handle-sentry-send';
+export * from './init-sentry/init-sentry';
+export * from './init-sentry/sentry-config';
+export * from './init-sentry/sentry-logger';

package/dist/esm/init-sentry/event-processor.js

@@ -0,0 +1,24 @@
+import { extractErrorMessage } from '@augment-vir/common';
+import { convertEventDetailsToSentryContext, } from '../event-context/event-context';
+import { extractEventSeverity } from '../event-context/event-severity';
+import { extractExtraEventContext } from '../event-context/extra-event-context';
+/** Attach extra event data for a sentry event. */
+export function processSentryEvent(
+/** Event from Sentry. */
+event, 
+/** EventHint generated by Sentry. */
+hint, 
+/** Optional callback for creating extra event context. */
+createUniversalContext) {
+    const extraContext = {
+        ...extractExtraEventContext(hint.originalException),
+        ...createUniversalContext?.(),
+        originalFullMessage: event.message || extractErrorMessage(hint.originalException),
+    };
+    const sentryContext = convertEventDetailsToSentryContext({
+        severity: extractEventSeverity(event),
+        extraContext,
+    });
+    Object.assign(event, sentryContext);
+    return event;
+}

package/dist/esm/init-sentry/handle-sentry-send.js

@@ -0,0 +1,43 @@
+import { extractErrorMessage } from '@augment-vir/common';
+import { SentryReleaseEnvEnum } from '../env/release-env';
+import { getConsoleMethodForSeverity } from '../event-context/event-severity';
+/** Creates a handler for Sentry events based on the given env. */
+export function createSentryHandler(
+/**
+ * The release environment (dev vs prod). Determines whether events should be sent to sentry or
+ * not.
+ */
+releaseEnv) {
+    /** The actual function that gets called when handling Sentry events. */
+    function handleSentrySend(
+    /** The event from Sentry. */
+    event, 
+    /** The EventHint generated by Sentry. */
+    hint) {
+        const consoleMethod = getConsoleMethodForSeverity(event);
+        const message = extractOriginalMessage(event, hint);
+        const logArgs = [
+            message,
+            event.extra,
+            { event, hint },
+        ];
+        if (releaseEnv === SentryReleaseEnvEnum.Dev) {
+            consoleMethod('Would have sent to Sentry:', ...logArgs);
+            return null;
+        }
+        else {
+            consoleMethod('Sending to Sentry:', ...logArgs);
+            return event;
+        }
+    }
+    return handleSentrySend;
+}
+/** Tries to extract the original event message from different possible Sentry types. */
+export function extractOriginalMessage(
+/** Event from Sentry. */
+event, 
+/** EventHint generated by Sentry. */
+hint) {
+    const message = event.message || extractErrorMessage(hint.originalException);
+    return message;
+}

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

@@ -0,0 +1,20 @@
+import { getSentryByEnv } from '../env/execution-env';
+import { processSentryEvent } from './event-processor';
+import { createSentryConfig } from './sentry-config';
+/**
+ * Setup a sentry client with all the default sentry-vir integrations and configs.
+ *
+ * To override any default sentry-vir settings, include them in the userConfig input.
+ */
+/* c8 ignore next */
+export async function initSentry({ executionEnv, dsn, releaseEnv, releaseName, sentryConfigOverrides, createUniversalContext, }) {
+    const sentryDep = await getSentryByEnv(executionEnv);
+    const finalSentryConfig = await createSentryConfig(executionEnv, sentryDep, {
+        dsn,
+        environment: releaseEnv,
+        release: releaseName,
+    }, sentryConfigOverrides, releaseEnv);
+    sentryDep.init(finalSentryConfig);
+    sentryDep.addGlobalEventProcessor((event, hint) => processSentryEvent(event, hint, createUniversalContext));
+    return sentryDep;
+}

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

@@ -0,0 +1,47 @@
+import { mergeDeep } from '@augment-vir/common';
+import { SentryExecutionEnvEnum, } from '../env/execution-env';
+import { createSentryHandler } from './handle-sentry-send';
+/** Creates the sentry config used internally by sentry-vir. */
+export async function createSentryConfig(env, sentryDep, requiredSentryOptions, userOverrides, releaseEnv) {
+    const sharedSentryConfig = {
+        beforeSend: createSentryHandler(releaseEnv),
+        beforeSendTransaction: createSentryHandler(releaseEnv),
+        defaultIntegrations: false,
+        enabled: true,
+    };
+    const envSentryConfig = sentryConfigByEnv[env](
+    /**
+     * As cast needed because env and sentryDep are tightly coupled and there's not a good way
+     * to check that they match with a type guard. This is okay, however, because the types of
+     * this functions parameters already imposes the requirement that they are coupled.
+     */
+    sentryDep);
+    const combinedConfig = mergeDeep(sharedSentryConfig, envSentryConfig, requiredSentryOptions, userOverrides);
+    return combinedConfig;
+}
+const sentryConfigByEnv = {
+    [SentryExecutionEnvEnum.Browser](BrowserSentry) {
+        const options = {
+            integrations: [
+                new BrowserSentry.HttpContext(),
+                new BrowserSentry.Dedupe(),
+                new BrowserSentry.InboundFilters(),
+                new BrowserSentry.FunctionToString(),
+                new BrowserSentry.GlobalHandlers(),
+            ],
+        };
+        return options;
+    },
+    [SentryExecutionEnvEnum.Node](NodeSentry) {
+        const options = {
+            integrations: [
+                new NodeSentry.Integrations.OnUncaughtException(),
+                new NodeSentry.Integrations.OnUnhandledRejection(),
+                new NodeSentry.Integrations.ContextLines(),
+                new NodeSentry.Integrations.Context(),
+                new NodeSentry.Integrations.FunctionToString(),
+            ],
+        };
+        return options;
+    },
+};

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

@@ -0,0 +1,91 @@
+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) {
+        const prematureLog = prematureSentryEvents.pop();
+        if (!prematureLog) {
+            return;
+        }
+        prematureLog.entryPoint(...prematureLog.inputs);
+    }
+}
+/** Record an error to Sentry without throwing it. */
+export function handleError(error, extraContext) {
+    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;
+}
+/** 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) {
+    if (!sentryClientForLogging) {
+        prematureSentryEvents.push({
+            entryPoint: 'sendLog',
+            inputs: [
+                logInfo,
+                eventDetails,
+            ],
+        });
+        return undefined;
+    }
+    const scopeContext = convertEventDetailsToSentryContext(eventDetails);
+    const eventId = isRuntimeTypeOf(logInfo, 'string')
+        ? sentryClientForLogging.captureMessage(logInfo, scopeContext)
+        : sentryClientForLogging.captureEvent({
+            ...logInfo,
+            ...scopeContext,
+        });
+    return eventId;
+}

package/dist/types/env/execution-env.d.ts

@@ -0,0 +1,181 @@
+/** Used to determine which Sentry client dependency to import. */
+export declare enum SentryExecutionEnvEnum {
+    Browser = "browser",
+    Node = "node"
+}
+/** The sentry dep import for each execution env. */
+export declare const sentryDepByEnv: {
+    /** Sentry client for the browser. */
+    readonly browser: () => Promise<{
+        default: typeof import("@sentry/browser");
+        Integrations: {
+            GlobalHandlers: typeof import("@sentry/browser").GlobalHandlers;
+            TryCatch: typeof import("@sentry/browser").TryCatch;
+            Breadcrumbs: typeof import("@sentry/browser").Breadcrumbs;
+            LinkedErrors: typeof import("@sentry/browser").LinkedErrors;
+            HttpContext: typeof import("@sentry/browser").HttpContext;
+            Dedupe: typeof import("@sentry/browser").Dedupe;
+            FunctionToString: typeof import("@sentry/browser").FunctionToString; /** Sentry client dependency used only in the browser. */
+            InboundFilters: typeof import("@sentry/browser").InboundFilters;
+        };
+        Replay: typeof import("@sentry/browser").Replay;
+        BrowserTracing: typeof import("@sentry/browser").BrowserTracing;
+        defaultRequestInstrumentationOptions: import("@sentry/browser").RequestInstrumentationOptions;
+        instrumentOutgoingRequests: typeof import("@sentry/browser").instrumentOutgoingRequests;
+        addTracingExtensions: typeof import("@sentry/browser").addTracingExtensions;
+        setMeasurement: typeof import("@sentry/browser").setMeasurement;
+        extractTraceparentData: typeof import("@sentry/browser").extractTraceparentData;
+        getActiveTransaction: typeof import("@sentry/browser").getActiveTransaction;
+        spanStatusfromHttpCode: typeof import("@sentry/browser").spanStatusfromHttpCode;
+        trace: typeof import("@sentry/browser").trace;
+        makeMultiplexedTransport: typeof import("@sentry/browser").makeMultiplexedTransport;
+        ModuleMetadata: typeof import("@sentry/browser").ModuleMetadata;
+        makeBrowserOfflineTransport: typeof import("@sentry/browser").makeBrowserOfflineTransport;
+        onProfilingStartRouteTransaction: typeof import("@sentry/browser").onProfilingStartRouteTransaction;
+        BrowserProfilingIntegration: typeof import("@sentry/browser").BrowserProfilingIntegration;
+        addGlobalEventProcessor: typeof import("@sentry/browser").addGlobalEventProcessor;
+        addBreadcrumb: typeof import("@sentry/browser").addBreadcrumb;
+        captureException: typeof import("@sentry/browser").captureException;
+        captureEvent: typeof import("@sentry/browser").captureEvent;
+        captureMessage: typeof import("@sentry/browser").captureMessage;
+        close: typeof import("@sentry/browser").close;
+        configureScope: typeof import("@sentry/browser").configureScope;
+        createTransport: typeof import("@sentry/browser").createTransport;
+        flush: typeof import("@sentry/browser").flush;
+        getHubFromCarrier: typeof import("@sentry/browser").getHubFromCarrier;
+        getCurrentHub: typeof import("@sentry/browser").getCurrentHub;
+        Hub: typeof import("@sentry/browser").Hub;
+        lastEventId: typeof import("@sentry/browser").lastEventId;
+        makeMain: typeof import("@sentry/browser").makeMain;
+        Scope: typeof import("@sentry/browser").Scope;
+        startTransaction: typeof import("@sentry/browser").startTransaction;
+        getActiveSpan: typeof import("@sentry/browser").getActiveSpan;
+        startSpan: typeof import("@sentry/browser").startSpan;
+        startInactiveSpan: typeof import("@sentry/browser").startInactiveSpan;
+        startSpanManual: typeof import("@sentry/browser").startSpanManual;
+        SDK_VERSION: "7.73.0";
+        setContext: typeof import("@sentry/browser").setContext;
+        setExtra: typeof import("@sentry/browser").setExtra;
+        setExtras: typeof import("@sentry/browser").setExtras;
+        setTag: typeof import("@sentry/browser").setTag;
+        setTags: typeof import("@sentry/browser").setTags;
+        setUser: typeof import("@sentry/browser").setUser;
+        withScope: typeof import("@sentry/browser").withScope;
+        FunctionToString: typeof import("@sentry/browser").FunctionToString;
+        InboundFilters: typeof import("@sentry/browser").InboundFilters;
+        WINDOW: import("@sentry/utils").InternalGlobal & Window;
+        BrowserClient: typeof import("@sentry/browser").BrowserClient;
+        makeFetchTransport: typeof import("@sentry/browser").makeFetchTransport;
+        makeXHRTransport: typeof import("@sentry/browser").makeXHRTransport;
+        defaultStackParser: import("@sentry/types").StackParser;
+        defaultStackLineParsers: import("@sentry/types").StackLineParser[];
+        chromeStackLineParser: import("@sentry/types").StackLineParser;
+        geckoStackLineParser: import("@sentry/types").StackLineParser;
+        opera10StackLineParser: import("@sentry/types").StackLineParser;
+        opera11StackLineParser: import("@sentry/types").StackLineParser;
+        winjsStackLineParser: import("@sentry/types").StackLineParser;
+        eventFromException: typeof import("@sentry/browser").eventFromException;
+        eventFromMessage: typeof import("@sentry/browser").eventFromMessage;
+        exceptionFromError: typeof import("@sentry/browser").exceptionFromError;
+        createUserFeedbackEnvelope: typeof import("@sentry/browser").createUserFeedbackEnvelope;
+        defaultIntegrations: (import("@sentry/browser").HttpContext | import("@sentry/browser").Dedupe | import("@sentry/browser").InboundFilters | import("@sentry/browser").FunctionToString | import("@sentry/browser").GlobalHandlers | import("@sentry/browser").TryCatch | import("@sentry/browser").Breadcrumbs | import("@sentry/browser").LinkedErrors)[];
+        forceLoad: typeof import("@sentry/browser").forceLoad;
+        init: typeof import("@sentry/browser").init;
+        onLoad: typeof import("@sentry/browser").onLoad;
+        showReportDialog: typeof import("@sentry/browser").showReportDialog;
+        captureUserFeedback: typeof import("@sentry/browser").captureUserFeedback;
+        wrap: typeof import("@sentry/browser").wrap;
+        GlobalHandlers: typeof import("@sentry/browser").GlobalHandlers;
+        TryCatch: typeof import("@sentry/browser").TryCatch;
+        Breadcrumbs: typeof import("@sentry/browser").Breadcrumbs;
+        LinkedErrors: typeof import("@sentry/browser").LinkedErrors;
+        HttpContext: typeof import("@sentry/browser").HttpContext;
+        Dedupe: typeof import("@sentry/browser").Dedupe;
+    }>;
+    /** Sentry client for the Node.js. */
+    readonly node: () => Promise<{
+        default: typeof import("@sentry/node");
+        addGlobalEventProcessor: typeof import("@sentry/browser").addGlobalEventProcessor;
+        addBreadcrumb: typeof import("@sentry/browser").addBreadcrumb;
+        captureException: typeof import("@sentry/browser").captureException;
+        captureEvent: typeof import("@sentry/browser").captureEvent;
+        captureMessage: typeof import("@sentry/browser").captureMessage;
+        close: typeof import("@sentry/browser").close;
+        configureScope: typeof import("@sentry/browser").configureScope;
+        createTransport: typeof import("@sentry/browser").createTransport;
+        extractTraceparentData: typeof import("@sentry/browser").extractTraceparentData;
+        flush: typeof import("@sentry/browser").flush;
+        getActiveTransaction: typeof import("@sentry/browser").getActiveTransaction;
+        getHubFromCarrier: typeof import("@sentry/browser").getHubFromCarrier;
+        getCurrentHub: typeof import("@sentry/browser").getCurrentHub;
+        Hub: typeof import("@sentry/browser").Hub;
+        lastEventId: typeof import("@sentry/browser").lastEventId;
+        makeMain: typeof import("@sentry/browser").makeMain;
+        runWithAsyncContext: typeof import("@sentry/node").runWithAsyncContext;
+        Scope: typeof import("@sentry/browser").Scope;
+        startTransaction: typeof import("@sentry/browser").startTransaction;
+        SDK_VERSION: "7.73.0";
+        setContext: typeof import("@sentry/browser").setContext;
+        setExtra: typeof import("@sentry/browser").setExtra;
+        setExtras: typeof import("@sentry/browser").setExtras;
+        setTag: typeof import("@sentry/browser").setTag;
+        setTags: typeof import("@sentry/browser").setTags;
+        setUser: typeof import("@sentry/browser").setUser;
+        spanStatusfromHttpCode: typeof import("@sentry/browser").spanStatusfromHttpCode;
+        trace: typeof import("@sentry/browser").trace;
+        withScope: typeof import("@sentry/browser").withScope;
+        captureCheckIn: typeof import("@sentry/node").captureCheckIn;
+        setMeasurement: typeof import("@sentry/browser").setMeasurement;
+        getActiveSpan: typeof import("@sentry/browser").getActiveSpan;
+        startSpan: typeof import("@sentry/browser").startSpan;
+        startActiveSpan: typeof import("@sentry/browser").startSpan;
+        startInactiveSpan: typeof import("@sentry/browser").startInactiveSpan;
+        startSpanManual: typeof import("@sentry/browser").startSpanManual;
+        autoDiscoverNodePerformanceMonitoringIntegrations: typeof import("@sentry/node").autoDiscoverNodePerformanceMonitoringIntegrations;
+        NodeClient: typeof import("@sentry/node").NodeClient;
+        makeNodeTransport: typeof import("@sentry/node").makeNodeTransport;
+        defaultIntegrations: (import("@sentry/browser").InboundFilters | import("@sentry/browser").FunctionToString | import("@sentry/node/types/integrations").OnUncaughtException | import("@sentry/node/types/integrations").OnUnhandledRejection | import("@sentry/node/types/integrations").ContextLines | import("@sentry/node/types/integrations").Context | import("@sentry/node/types/integrations").Console | import("@sentry/node/types/integrations").Http | import("@sentry/node/types/integrations").LinkedErrors | import("@sentry/node/types/integrations").Modules | import("@sentry/node/types/integrations").RequestData | import("@sentry/node/types/integrations").LocalVariables | import("@sentry/node/types/integrations").Undici)[];
+        init: typeof import("@sentry/node").init;
+        defaultStackParser: import("@sentry/types").StackParser;
+        getSentryRelease: typeof import("@sentry/node").getSentryRelease;
+        addRequestDataToEvent: typeof import("@sentry/node").addRequestDataToEvent;
+        DEFAULT_USER_INCLUDES: string[];
+        extractRequestData: typeof import("@sentry/node").extractRequestData;
+        deepReadDirSync: typeof import("@sentry/node").deepReadDirSync;
+        getModuleFromFilename: typeof import("@sentry/node").getModuleFromFilename;
+        enableAnrDetection: typeof import("@sentry/node").enableAnrDetection;
+        Integrations: {
+            Apollo: typeof import("@sentry-internal/tracing").Apollo;
+            Express: typeof import("@sentry-internal/tracing").Express;
+            GraphQL: typeof import("@sentry-internal/tracing").GraphQL;
+            Mongo: typeof import("@sentry-internal/tracing").Mongo;
+            Mysql: typeof import("@sentry-internal/tracing").Mysql;
+            Postgres: typeof import("@sentry-internal/tracing").Postgres;
+            Prisma: typeof import("@sentry-internal/tracing").Prisma;
+            Console: typeof import("@sentry/node/types/integrations").Console;
+            Http: typeof import("@sentry/node/types/integrations").Http;
+            OnUncaughtException: typeof import("@sentry/node/types/integrations").OnUncaughtException;
+            OnUnhandledRejection: typeof import("@sentry/node/types/integrations").OnUnhandledRejection;
+            LinkedErrors: typeof import("@sentry/node/types/integrations").LinkedErrors;
+            Modules: typeof import("@sentry/node/types/integrations").Modules;
+            ContextLines: typeof import("@sentry/node/types/integrations").ContextLines;
+            Context: typeof import("@sentry/node/types/integrations").Context;
+            RequestData: typeof import("@sentry/node/types/integrations").RequestData;
+            LocalVariables: typeof import("@sentry/node/types/integrations").LocalVariables;
+            Undici: typeof import("@sentry/node/types/integrations").Undici;
+            FunctionToString: typeof import("@sentry/browser").FunctionToString;
+            InboundFilters: typeof import("@sentry/browser").InboundFilters;
+        };
+        Handlers: typeof import("@sentry/node/types/handlers");
+    }>;
+};
+/** Sentry client dependency used only in the browser. */
+export type SentryBrowserDep = Awaited<ReturnType<(typeof sentryDepByEnv)[SentryExecutionEnvEnum.Browser]>>;
+/** Sentry client dependency used only in Node.js. */
+export type SentryNodeDep = Awaited<ReturnType<(typeof sentryDepByEnv)[SentryExecutionEnvEnum.Node]>>;
+/** Any of the Sentry client dependencies. */
+export type SentryDep = SentryBrowserDep | SentryNodeDep;
+/** Pick a Sentry client dependency based on the given environment. */
+export type SentryDepByEnv<Env extends SentryExecutionEnvEnum> = Env extends SentryExecutionEnvEnum.Browser ? SentryBrowserDep : SentryNodeDep;
+/** Determine which Sentry client dependency to use and then import it. */
+export declare function getSentryByEnv<const Env extends SentryExecutionEnvEnum>(env: Env): Promise<SentryDepByEnv<Env>>;

package/dist/types/env/release-env.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Used to determine logging behavior (dev does not send events to Sentry but still logs them
+ * locally).
+ */
+export declare enum SentryReleaseEnvEnum {
+    Prod = "prod",
+    Dev = "dev"
+}

package/dist/types/event-context/event-context.d.ts

@@ -0,0 +1,17 @@
+import { JsonCompatibleValue } from '@augment-vir/common';
+import { ScopeContext } from '@sentry/types';
+import { EventSeverityEnum } from './event-severity';
+/**
+ * Used for all extra context types. While keys must be strings, values can be whatever but must be
+ * JSON compatible.
+ */
+export type EventExtraContext = Record<string, JsonCompatibleValue>;
+/** Function that generates extra event context. */
+export type EventExtraContextCreator = () => EventExtraContext;
+/** Event details before getting sent to Sentry. */
+export type EventDetails = {
+    extraContext?: EventExtraContext | undefined;
+    severity: EventSeverityEnum;
+};
+/** Maps internal EventDetails type to Sentry's required type for event severity and extra context. */
+export declare function convertEventDetailsToSentryContext(eventDetails: EventDetails): Pick<ScopeContext, 'extra' | 'level'>;

package/dist/types/event-context/event-severity.d.ts

@@ -0,0 +1,21 @@
+import type { Event as SentryEvent } from '@sentry/browser';
+/** Mapped from Sentry's values into an enum for convenience of use. */
+export declare enum EventSeverityEnum {
+    Warning = "warning",
+    Info = "info",
+    Debug = "debug",
+    Fatal = "fatal",
+    Error = "error"
+}
+/** Event severities that are not error-level. */
+export type InfoEventSeverity = EventSeverityEnum.Debug | EventSeverityEnum.Info | EventSeverityEnum.Warning;
+/** Extracts the severity level from a sentry event while defaulting to an info level severity. */
+export declare function extractEventSeverity(event: SentryEvent): EventSeverityEnum;
+/**
+ * Determines which console method should be used for local logging based on the given event's
+ * severity.
+ */
+export declare function getConsoleMethodForSeverity(event: SentryEvent): {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+};

package/dist/types/event-context/extra-context.error.d.ts

@@ -0,0 +1,24 @@
+import { EventExtraContext } from './event-context';
+import { extraEventContextSymbol, HasExtraContext } from './extra-event-context';
+/**
+ * Constructs an error with extra event context attached to it in the same way that
+ * throwWithExtraContext attaches data.
+ *
+ * The following examples are equivalent:
+ *
+ * @example
+ *     throw new ExtraContextError('my error', {stuff: 'hi'});
+ *
+ * @example
+ *     const myError = new Error('my error');
+ *     throwWithExtraContext(myError, {stuff: 'hi'});
+ */
+export declare class ExtraContextError extends Error implements HasExtraContext {
+    readonly [extraEventContextSymbol]: EventExtraContext;
+    constructor(message: string, extraData: EventExtraContext);
+}
+/**
+ * Adds extra context to an error without modifying the error's message or stack trace (or any of
+ * its other properties), then throws the error so it can propagate as usual.
+ */
+export declare function throwWithExtraContext(originalError: unknown, extraData: EventExtraContext): never;

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

@@ -0,0 +1,17 @@
+import { EventExtraContext } from './event-context';
+/**
+ * Symbol used to attach extra event context to events. This is particularly useful for errors so
+ * they can be thrown while attaching this extra context to them.
+ */
+export declare const extraEventContextSymbol: unique symbol;
+/** Simply describes an object that has extra event context. */
+export type HasExtraContext = {
+    [extraEventContextSymbol]: EventExtraContext;
+};
+/** Type guard for whether any given input has extra event context. */
+export declare function hasExtraEventContext(input: unknown): input is HasExtraContext;
+/**
+ * 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;

package/dist/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from './env/execution-env';
+export * from './env/release-env';
+export * from './event-context/event-context';
+export * from './event-context/event-severity';
+export * from './event-context/extra-context.error';
+export * from './event-context/extra-event-context';
+export * from './init-sentry/event-processor';
+export * from './init-sentry/handle-sentry-send';
+export * from './init-sentry/init-sentry';
+export * from './init-sentry/sentry-config';
+export * from './init-sentry/sentry-logger';

package/dist/types/init-sentry/event-processor.d.ts

@@ -0,0 +1,10 @@
+import { EventHint, Event as SentryEvent } from '@sentry/types';
+import { EventExtraContextCreator } from '../event-context/event-context';
+/** Attach extra event data for a sentry event. */
+export declare function processSentryEvent(
+/** Event from Sentry. */
+event: SentryEvent, 
+/** EventHint generated by Sentry. */
+hint: EventHint, 
+/** Optional callback for creating extra event context. */
+createUniversalContext?: EventExtraContextCreator | undefined): SentryEvent;