sentry-vir 0.0.0 → 0.0.2

package/dist/cjs/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/cjs/event-context/extra-event-context.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractExtraEventContext = 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
+ * they can be thrown while attaching this extra context to them.
+ */
+exports.extraEventContextSymbol = Symbol('extra-event-context');
+/** Type guard for whether any given input has extra event context. */
+function hasExtraEventContext(input) {
+    return (0, common_1.typedHasProperty)(input, exports.extraEventContextSymbol);
+}
+exports.hasExtraEventContext = hasExtraEventContext;
+/**
+ * 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];
+    }
+    else {
+        return undefined;
+    }
+}
+exports.extractExtraEventContext = extractExtraEventContext;

package/dist/cjs/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/cjs/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./env/execution-env"), exports);
+__exportStar(require("./env/release-env"), exports);
+__exportStar(require("./event-context/event-context"), exports);
+__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/event-processor"), exports);
+__exportStar(require("./init-sentry/handle-sentry-send"), exports);
+__exportStar(require("./init-sentry/init-sentry"), exports);
+__exportStar(require("./init-sentry/sentry-config"), exports);
+__exportStar(require("./init-sentry/sentry-logger"), exports);

package/dist/cjs/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;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSentryEvent = 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 extra_event_context_1 = require("../event-context/extra-event-context");
+/** Attach extra event data for a sentry event. */
+function processSentryEvent(
+/** Event from Sentry. */
+event, 
+/** EventHint generated by Sentry. */
+hint, 
+/** Optional callback for creating extra event context. */
+createUniversalContext) {
+    const extraContext = {
+        ...(0, extra_event_context_1.extractExtraEventContext)(hint.originalException),
+        ...createUniversalContext?.(),
+        originalFullMessage: event.message || (0, common_1.extractErrorMessage)(hint.originalException),
+    };
+    const sentryContext = (0, event_context_1.convertEventDetailsToSentryContext)({
+        severity: (0, event_severity_1.extractEventSeverity)(event),
+        extraContext,
+    });
+    Object.assign(event, sentryContext);
+    return event;
+}
+exports.processSentryEvent = processSentryEvent;

package/dist/cjs/init-sentry/handle-sentry-send.d.ts

@@ -0,0 +1,16 @@
+import type { EventHint } from '@sentry/browser';
+import type { ErrorEvent, TransactionEvent } from '@sentry/types';
+import { SentryReleaseEnvEnum } from '../env/release-env';
+/** Creates a handler for Sentry events based on the given env. */
+export declare function createSentryHandler(
+/**
+ * The release environment (dev vs prod). Determines whether events should be sent to sentry or
+ * not.
+ */
+releaseEnv: SentryReleaseEnvEnum): (event: TransactionEvent | ErrorEvent, hint: EventHint) => TransactionEvent | ErrorEvent | null;
+/** Tries to extract the original event message from different possible Sentry types. */
+export declare function extractOriginalMessage(
+/** Event from Sentry. */
+event: TransactionEvent | ErrorEvent, 
+/** EventHint generated by Sentry. */
+hint: EventHint): string;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractOriginalMessage = exports.createSentryHandler = void 0;
+const common_1 = require("@augment-vir/common");
+const release_env_1 = require("../env/release-env");
+const event_severity_1 = require("../event-context/event-severity");
+/** Creates a handler for Sentry events based on the given env. */
+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 = (0, event_severity_1.getConsoleMethodForSeverity)(event);
+        const message = extractOriginalMessage(event, hint);
+        const logArgs = [
+            message,
+            event.extra,
+            { event, hint },
+        ];
+        if (releaseEnv === release_env_1.SentryReleaseEnvEnum.Dev) {
+            consoleMethod('Would have sent to Sentry:', ...logArgs);
+            return null;
+        }
+        else {
+            consoleMethod('Sending to Sentry:', ...logArgs);
+            return event;
+        }
+    }
+    return handleSentrySend;
+}
+exports.createSentryHandler = createSentryHandler;
+/** Tries to extract the original event message from different possible Sentry types. */
+function extractOriginalMessage(
+/** Event from Sentry. */
+event, 
+/** EventHint generated by Sentry. */
+hint) {
+    const message = event.message || (0, common_1.extractErrorMessage)(hint.originalException);
+    return message;
+}
+exports.extractOriginalMessage = extractOriginalMessage;

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

@@ -0,0 +1,194 @@
+import type { Options } from '@sentry/types';
+import { SentryExecutionEnvEnum } from '../env/execution-env';
+import { SentryReleaseEnvEnum } from '../env/release-env';
+import { EventExtraContextCreator } from '../event-context/event-context';
+import { UserOverrides } from './sentry-config';
+/** Configuration for initializing Sentry. */
+export type InitSentryInput = {
+    /**
+     * The environment wherein the Sentry client will execute. Used to determine which Sentry client
+     * to load: browser or node.
+     */
+    executionEnv: SentryExecutionEnvEnum;
+    /**
+     * The release environment, prod vs dev rather than browser vs node. In dev, events won't be
+     * sent to sentry. In both options, all events will be logged to the local console.
+     */
+    releaseEnv: SentryReleaseEnvEnum;
+    /** Name for the current release. */
+    releaseName: Required<Options>['release'];
+    /** DSN needed for Sentry to hook up to your sentry project. */
+    dsn: Required<Options>['dsn'];
+    /**
+     * Optionally create extra context to be included in all Sentry events. This will execute for
+     * each event that is processed.
+     */
+    createUniversalContext?: EventExtraContextCreator | undefined;
+    /** Optionally override any Sentry config properties that this package sets. */
+    sentryConfigOverrides?: UserOverrides;
+};
+/**
+ * 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.
+ */
+export declare function initSentry({ executionEnv, dsn, releaseEnv, releaseName, sentryConfigOverrides, createUniversalContext, }: InitSentryInput): 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/core").FunctionToString;
+        InboundFilters: typeof import("@sentry/core").InboundFilters;
+    };
+    Replay: typeof import("@sentry/replay").Replay;
+    BrowserTracing: typeof import("@sentry-internal/tracing").BrowserTracing;
+    defaultRequestInstrumentationOptions: import("@sentry-internal/tracing").RequestInstrumentationOptions;
+    instrumentOutgoingRequests: typeof import("@sentry-internal/tracing").instrumentOutgoingRequests;
+    addTracingExtensions: typeof import("@sentry/core").addTracingExtensions;
+    setMeasurement: typeof import("@sentry/core").setMeasurement;
+    extractTraceparentData: typeof import("@sentry/utils").extractTraceparentData;
+    getActiveTransaction: typeof import("@sentry/core").getActiveTransaction;
+    spanStatusfromHttpCode: typeof import("@sentry/core").spanStatusfromHttpCode;
+    trace: typeof import("@sentry/core").trace;
+    makeMultiplexedTransport: typeof import("@sentry/core").makeMultiplexedTransport;
+    ModuleMetadata: typeof import("@sentry/core").ModuleMetadata;
+    makeBrowserOfflineTransport: typeof import("@sentry/browser").makeBrowserOfflineTransport;
+    onProfilingStartRouteTransaction: typeof import("@sentry/browser").onProfilingStartRouteTransaction;
+    BrowserProfilingIntegration: typeof import("@sentry/browser").BrowserProfilingIntegration;
+    addGlobalEventProcessor: typeof import("@sentry/core").addGlobalEventProcessor;
+    addBreadcrumb: typeof import("@sentry/core").addBreadcrumb;
+    captureException: typeof import("@sentry/core").captureException;
+    captureEvent: typeof import("@sentry/core").captureEvent;
+    captureMessage: typeof import("@sentry/core").captureMessage;
+    close: typeof import("@sentry/core").close;
+    configureScope: typeof import("@sentry/core").configureScope;
+    createTransport: typeof import("@sentry/core").createTransport;
+    flush: typeof import("@sentry/core").flush;
+    getHubFromCarrier: typeof import("@sentry/core").getHubFromCarrier;
+    getCurrentHub: typeof import("@sentry/core").getCurrentHub;
+    Hub: typeof import("@sentry/core").Hub;
+    lastEventId: typeof import("@sentry/core").lastEventId;
+    makeMain: typeof import("@sentry/core").makeMain;
+    Scope: typeof import("@sentry/core").Scope;
+    startTransaction: typeof import("@sentry/core").startTransaction;
+    getActiveSpan: typeof import("@sentry/core").getActiveSpan;
+    startSpan: typeof import("@sentry/core").startSpan;
+    startInactiveSpan: typeof import("@sentry/core").startInactiveSpan;
+    startSpanManual: typeof import("@sentry/core").startSpanManual;
+    SDK_VERSION: "7.73.0";
+    setContext: typeof import("@sentry/core").setContext;
+    setExtra: typeof import("@sentry/core").setExtra;
+    setExtras: typeof import("@sentry/core").setExtras;
+    setTag: typeof import("@sentry/core").setTag;
+    setTags: typeof import("@sentry/core").setTags;
+    setUser: typeof import("@sentry/core").setUser;
+    withScope: typeof import("@sentry/core").withScope;
+    FunctionToString: typeof import("@sentry/core").FunctionToString;
+    InboundFilters: typeof import("@sentry/core").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/core").InboundFilters | import("@sentry/core").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;
+} | {
+    default: typeof import("@sentry/node");
+    addGlobalEventProcessor: typeof import("@sentry/core").addGlobalEventProcessor;
+    addBreadcrumb: typeof import("@sentry/core").addBreadcrumb;
+    captureException: typeof import("@sentry/core").captureException;
+    captureEvent: typeof import("@sentry/core").captureEvent;
+    captureMessage: typeof import("@sentry/core").captureMessage;
+    close: typeof import("@sentry/core").close;
+    configureScope: typeof import("@sentry/core").configureScope;
+    createTransport: typeof import("@sentry/core").createTransport;
+    extractTraceparentData: typeof import("@sentry/utils").extractTraceparentData;
+    flush: typeof import("@sentry/core").flush;
+    getActiveTransaction: typeof import("@sentry/core").getActiveTransaction;
+    getHubFromCarrier: typeof import("@sentry/core").getHubFromCarrier;
+    getCurrentHub: typeof import("@sentry/core").getCurrentHub;
+    Hub: typeof import("@sentry/core").Hub;
+    lastEventId: typeof import("@sentry/core").lastEventId;
+    makeMain: typeof import("@sentry/core").makeMain;
+    runWithAsyncContext: typeof import("@sentry/core").runWithAsyncContext;
+    Scope: typeof import("@sentry/core").Scope;
+    startTransaction: typeof import("@sentry/core").startTransaction;
+    SDK_VERSION: "7.73.0";
+    setContext: typeof import("@sentry/core").setContext;
+    setExtra: typeof import("@sentry/core").setExtra;
+    setExtras: typeof import("@sentry/core").setExtras;
+    setTag: typeof import("@sentry/core").setTag;
+    setTags: typeof import("@sentry/core").setTags;
+    setUser: typeof import("@sentry/core").setUser;
+    spanStatusfromHttpCode: typeof import("@sentry/core").spanStatusfromHttpCode;
+    trace: typeof import("@sentry/core").trace;
+    withScope: typeof import("@sentry/core").withScope;
+    captureCheckIn: typeof import("@sentry/core").captureCheckIn;
+    setMeasurement: typeof import("@sentry/core").setMeasurement;
+    getActiveSpan: typeof import("@sentry/core").getActiveSpan;
+    startSpan: typeof import("@sentry/core").startSpan;
+    startActiveSpan: typeof import("@sentry/core").startSpan;
+    startInactiveSpan: typeof import("@sentry/core").startInactiveSpan;
+    startSpanManual: typeof import("@sentry/core").startSpanManual;
+    autoDiscoverNodePerformanceMonitoringIntegrations: typeof import("@sentry/node").autoDiscoverNodePerformanceMonitoringIntegrations;
+    NodeClient: typeof import("@sentry/node").NodeClient;
+    makeNodeTransport: typeof import("@sentry/node").makeNodeTransport;
+    defaultIntegrations: (import("@sentry/core").InboundFilters | import("@sentry/core").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/core").FunctionToString;
+        InboundFilters: typeof import("@sentry/core").InboundFilters;
+    };
+    Handlers: typeof import("@sentry/node/types/handlers");
+}>;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSentry = void 0;
+const execution_env_1 = require("../env/execution-env");
+const event_processor_1 = require("./event-processor");
+const sentry_config_1 = require("./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 */
+async function initSentry({ executionEnv, dsn, releaseEnv, releaseName, sentryConfigOverrides, createUniversalContext, }) {
+    const sentryDep = await (0, execution_env_1.getSentryByEnv)(executionEnv);
+    const finalSentryConfig = await (0, sentry_config_1.createSentryConfig)(executionEnv, sentryDep, {
+        dsn,
+        environment: releaseEnv,
+        release: releaseName,
+    }, sentryConfigOverrides, releaseEnv);
+    sentryDep.init(finalSentryConfig);
+    sentryDep.addGlobalEventProcessor((event, hint) => (0, event_processor_1.processSentryEvent)(event, hint, createUniversalContext));
+    return sentryDep;
+}
+exports.initSentry = initSentry;

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

@@ -0,0 +1,9 @@
+import type { Options } from '@sentry/types';
+import { SentryBrowserDep, SentryDepByEnv, SentryExecutionEnvEnum, SentryNodeDep } from '../env/execution-env';
+import { SentryReleaseEnvEnum } from '../env/release-env';
+/** Optional UserOverrides of Sentry config values. */
+export type UserOverrides = Omit<Partial<Options>, keyof RequiredSentryOptions> | undefined;
+/** Sentry config options that are required. */
+export type RequiredSentryOptions = Pick<Required<Options>, 'dsn' | 'environment' | 'release'>;
+/** Creates the sentry config used internally by sentry-vir. */
+export declare function createSentryConfig<const Env extends SentryExecutionEnvEnum>(env: Env, sentryDep: SentryDepByEnv<Env>, requiredSentryOptions: RequiredSentryOptions, userOverrides: UserOverrides, releaseEnv: SentryReleaseEnvEnum): Promise<SentryBrowserDep | SentryNodeDep>;

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

@@ -0,0 +1,51 @@
+"use strict";
+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");
+/** Creates the sentry config used internally by sentry-vir. */
+async function createSentryConfig(env, sentryDep, requiredSentryOptions, userOverrides, releaseEnv) {
+    const sharedSentryConfig = {
+        beforeSend: (0, handle_sentry_send_1.createSentryHandler)(releaseEnv),
+        beforeSendTransaction: (0, handle_sentry_send_1.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 = (0, common_1.mergeDeep)(sharedSentryConfig, envSentryConfig, requiredSentryOptions, userOverrides);
+    return combinedConfig;
+}
+exports.createSentryConfig = createSentryConfig;
+const sentryConfigByEnv = {
+    [execution_env_1.SentryExecutionEnvEnum.Browser](BrowserSentry) {
+        const options = {
+            integrations: [
+                new BrowserSentry.HttpContext(),
+                new BrowserSentry.Dedupe(),
+                new BrowserSentry.InboundFilters(),
+                new BrowserSentry.FunctionToString(),
+                new BrowserSentry.GlobalHandlers(),
+            ],
+        };
+        return options;
+    },
+    [execution_env_1.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/cjs/init-sentry/sentry-logger.d.ts

@@ -0,0 +1,40 @@
+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> = {
+    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<any>[];
+/**
+ * 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/init-sentry/sentry-logger.js

@@ -0,0 +1,96 @@
+"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) {
+        const prematureLog = exports.prematureSentryEvents.pop();
+        if (!prematureLog) {
+            return;
+        }
+        prematureLog.entryPoint(...prematureLog.inputs);
+    }
+}
+/** Record an error to Sentry without throwing it. */
+function handleError(error, extraContext) {
+    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;
+}
+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) {
+    if (!sentryClientForLogging) {
+        exports.prematureSentryEvents.push({
+            entryPoint: 'sendLog',
+            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;
+}

package/dist/esm/env/execution-env.js

@@ -0,0 +1,20 @@
+/** Used to determine which Sentry client dependency to import. */
+/* c8 ignore next */
+export var SentryExecutionEnvEnum;
+(function (SentryExecutionEnvEnum) {
+    SentryExecutionEnvEnum["Browser"] = "browser";
+    SentryExecutionEnvEnum["Node"] = "node";
+})(SentryExecutionEnvEnum || (SentryExecutionEnvEnum = {}));
+/** The sentry dep import for each execution env. */
+/* c8 ignore next 6 */
+export const sentryDepByEnv = {
+    /** Sentry client for the browser. */
+    [SentryExecutionEnvEnum.Browser]: () => import('@sentry/browser'),
+    /** Sentry client for the Node.js. */
+    [SentryExecutionEnvEnum.Node]: () => import('@sentry/node'),
+};
+/* c8 ignore next 6 */
+/** Determine which Sentry client dependency to use and then import it. */
+export async function getSentryByEnv(env) {
+    return (await sentryDepByEnv[env]());
+}

package/dist/esm/env/release-env.js

@@ -0,0 +1,10 @@
+/**
+ * Used to determine logging behavior (dev does not send events to Sentry but still logs them
+ * locally).
+ */
+/* c8 ignore next */
+export var SentryReleaseEnvEnum;
+(function (SentryReleaseEnvEnum) {
+    SentryReleaseEnvEnum["Prod"] = "prod";
+    SentryReleaseEnvEnum["Dev"] = "dev";
+})(SentryReleaseEnvEnum || (SentryReleaseEnvEnum = {}));