sentry-vir 3.2.3 → 4.0.0

package/README.md

@@ -45,11 +45,11 @@ initSentry({
 
 ```TypeScript
 import {SentryReleaseEnvEnum, handleError, sendLog, throwWithExtraContext} from 'sentry-vir';
-import {initSentry} from 'sentry-vir/dist/browser';
+import {initSentry} from 'sentry-vir/dist/browser.js';
 
 sendLog.info('starting file');
-/** Extra log context can be added as the second argument to a sendLog method. */
-sendLog.info('starting file 2', {addExtraContext: 'here'});
+/** Extra log context and tags can be added as the second argument to a sendLog method. */
+sendLog.info('starting file 2', {context: {addExtraContext: 'here'}});
 /** Other severities are covered. */
 sendLog.debug('debug log');
 /** Logs and errors will be buffered so it's safe to call this before initSentry has been called. */
@@ -69,11 +69,11 @@ initSentry({
 });
 
 handleError(new Error('test error'));
-/** Extra error context can be added as the second argument to handleError. */
-handleError(new Error('test error 2'), {addExtraContext: 'here'});
+/** Extra error context and tags can be added as the second argument to handleError. */
+handleError(new Error('test error 2'), {context: {addExtraContext: 'here'}});
 /** These will be included in the Sentry buffer even if initSentry has not been awaited yet. */
-handleError(new Error('test error 2'), {addExtraContext: 'here'});
+handleError(new Error('test error 2'), {context: {addExtraContext: 'here'}});
 
-/** Throw an error with extra context attached for Sentry to pick up. */
-throwWithExtraContext(new Error('final error'), {addExtraContext: 'here'});
+/** Throw an error with extra context and tags attached for Sentry to pick up. */
+throwWithExtraContext(new Error('final error'), {context: {addExtraContext: 'here'}});
 ```

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

@@ -1,15 +1,27 @@
+import { type JsonCompatibleObject, type PartialWithUndefined } from '@augment-vir/common';
 import { type ScopeContext } from '@sentry/core';
 import { type EventSeverityEnum } from './event-severity.js';
 /**
  * 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, unknown>;
+export type EventExtraContext = JsonCompatibleObject;
+/** Allowed tag value types for Sentry event tags. */
+export type EventTags = Record<string, string | number | boolean>;
+/**
+ * Combined context and tags parameter used for event logging functions. Both properties are
+ * optional.
+ */
+export type EventContextAndTags = PartialWithUndefined<{
+    context: EventExtraContext;
+    tags: EventTags;
+}>;
 /** Function that generates extra event context. */
 export type EventExtraContextCreator = () => EventExtraContext;
 /** Event details before getting sent to Sentry. */
 export type EventDetails = {
     extraContext?: EventExtraContext | undefined;
+    tags?: EventTags | undefined;
     severity: EventSeverityEnum;
 };
 /** Options for creating contexts. Used internally. */
@@ -20,5 +32,8 @@ export type ContextOptions = {
      */
     wasSentPrematurely: boolean;
 };
-/** Maps internal EventDetails type to Sentry's required type for event severity and extra context. */
-export declare function convertEventDetailsToSentryContext(eventDetails: EventDetails, options: ContextOptions): Pick<ScopeContext, 'extra' | 'level'>;
+/**
+ * Maps internal EventDetails type to Sentry's required type for event severity, extra context, and
+ * tags.
+ */
+export declare function convertEventDetailsToSentryContext(eventDetails: EventDetails, options: ContextOptions): Pick<ScopeContext, 'extra' | 'level'> & Partial<Pick<ScopeContext, 'tags'>>;

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

@@ -1,4 +1,7 @@
-/** Maps internal EventDetails type to Sentry's required type for event severity and extra context. */
+/**
+ * Maps internal EventDetails type to Sentry's required type for event severity, extra context, and
+ * tags.
+ */
 export function convertEventDetailsToSentryContext(eventDetails, options) {
     const extra = {
         ...(options.wasSentPrematurely
@@ -11,5 +14,6 @@ export function convertEventDetailsToSentryContext(eventDetails, options) {
     return {
         extra,
         level: eventDetails.severity,
+        ...(eventDetails.tags ? { tags: eventDetails.tags } : {}),
     };
 }

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

@@ -1,21 +1,23 @@
-import { type EventExtraContext } from './event-context.js';
-import { extraEventContextSymbol, type HasExtraContext } from './extra-event-context.js';
+import { type EventContextAndTags, type EventExtraContext, type EventTags } from './event-context.js';
+import { extraEventContextSymbol, extraEventTagsSymbol } from './extra-event-context.js';
 /**
  * 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 Throw new ExtraContextError('my error', {context: {stuff: 'hi'}});
  *
- * @example Const myError = new Error('my error'); throwWithExtraContext(myError, {stuff: 'hi'});
+ * @example Const myError = new Error('my error'); throwWithExtraContext(myError, {context: {stuff:
+ * 'hi'}});
  */
-export declare class ExtraContextError extends Error implements HasExtraContext {
-    readonly [extraEventContextSymbol]: EventExtraContext;
-    constructor(message: string, extraData: EventExtraContext);
+export declare class ExtraContextError extends Error {
+    readonly [extraEventContextSymbol]: EventExtraContext | undefined;
+    readonly [extraEventTagsSymbol]: EventTags | undefined;
+    constructor(message: string, extraData: EventContextAndTags);
 }
 /**
  * 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;
+export declare function throwWithExtraContext(originalError: unknown, extraData: EventContextAndTags): never;

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

@@ -1,20 +1,27 @@
 import { ensureError } from '@augment-vir/common';
-import { extraEventContextSymbol } from './extra-event-context.js';
+import { extraEventContextSymbol, extraEventTagsSymbol, } from './extra-event-context.js';
 /**
  * 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 Throw new ExtraContextError('my error', {context: {stuff: 'hi'}});
  *
- * @example Const myError = new Error('my error'); throwWithExtraContext(myError, {stuff: 'hi'});
+ * @example Const myError = new Error('my error'); throwWithExtraContext(myError, {context: {stuff:
+ * 'hi'}});
  */
 export class ExtraContextError extends Error {
     [extraEventContextSymbol];
+    [extraEventTagsSymbol];
     constructor(message, extraData) {
         super(message);
-        this[extraEventContextSymbol] = extraData;
+        if (extraData.context) {
+            this[extraEventContextSymbol] = extraData.context;
+        }
+        if (extraData.tags) {
+            this[extraEventTagsSymbol] = extraData.tags;
+        }
     }
 }
 /**
@@ -23,6 +30,11 @@ export class ExtraContextError extends Error {
  */
 export function throwWithExtraContext(originalError, extraData) {
     const error = ensureError(originalError);
-    error[extraEventContextSymbol] = extraData;
+    if (extraData.context) {
+        error[extraEventContextSymbol] = extraData.context;
+    }
+    if (extraData.tags) {
+        error[extraEventTagsSymbol] = extraData.tags;
+    }
     throw error;
 }

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

@@ -1,23 +1,44 @@
 import { type Event, type EventHint } from '@sentry/core';
-import { type EventExtraContext } from './event-context.js';
+import { type EventExtraContext, type EventTags } from './event-context.js';
 /**
  * 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;
+/**
+ * Symbol used to attach extra event tags to events. Used alongside extraEventContextSymbol for
+ * attaching tag data to thrown errors.
+ */
+export declare const extraEventTagsSymbol: unique symbol;
 /** Simply describes an object that has extra event context. */
 export type HasExtraContext = {
     [extraEventContextSymbol]: EventExtraContext;
 };
+/** Simply describes an object that has extra event tags. */
+export type HasExtraTags = {
+    [extraEventTagsSymbol]: EventTags;
+};
 /** Type guard for whether any given input has extra event context. */
 export declare function hasExtraEventContext(input: unknown): input is HasExtraContext;
+/** Type guard for whether any given input has extra event tags. */
+export declare function hasExtraEventTags(input: unknown): input is HasExtraTags;
 /**
  * Checks if extra event context has been injected into the input via extraEventContextSymbol and,
  * if so, extracts it.
  */
 export declare function extractExtraContentFromSymbol(input: unknown): EventExtraContext | undefined;
+/**
+ * Checks if extra event tags have been injected into the input via extraEventTagsSymbol and, if so,
+ * extracts them.
+ */
+export declare function extractExtraTagsFromSymbol(input: unknown): EventTags | undefined;
 /**
  * Tries to extract extra event context via extraEventContextSymbol. Returns undefined if there is
  * no extra event context.
  */
 export declare function extractExtraEventContext(event: EventHint | Event): EventExtraContext | undefined;
+/**
+ * Tries to extract extra event tags via extraEventTagsSymbol. Returns undefined if there are no
+ * extra event tags.
+ */
+export declare function extractExtraEventTags(event: EventHint | Event): EventTags | undefined;

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

@@ -4,9 +4,18 @@ import { check } from '@augment-vir/assert';
  * they can be thrown while attaching this extra context to them.
  */
 export const extraEventContextSymbol = Symbol('extra-event-context');
+/**
+ * Symbol used to attach extra event tags to events. Used alongside extraEventContextSymbol for
+ * attaching tag data to thrown errors.
+ */
+export const extraEventTagsSymbol = Symbol('extra-event-tags');
 /** Type guard for whether any given input has extra event context. */
 export function hasExtraEventContext(input) {
-    return check.hasKey(input, extraEventContextSymbol);
+    return check.hasKey(input, extraEventContextSymbol) && !!input[extraEventContextSymbol];
+}
+/** Type guard for whether any given input has extra event tags. */
+export function hasExtraEventTags(input) {
+    return check.hasKey(input, extraEventTagsSymbol) && !!input[extraEventTagsSymbol];
 }
 /**
  * Checks if extra event context has been injected into the input via extraEventContextSymbol and,
@@ -20,6 +29,16 @@ export function extractExtraContentFromSymbol(input) {
         return undefined;
     }
 }
+/**
+ * Checks if extra event tags have been injected into the input via extraEventTagsSymbol and, if so,
+ * extracts them.
+ */
+export function extractExtraTagsFromSymbol(input) {
+    if (hasExtraEventTags(input)) {
+        return input[extraEventTagsSymbol];
+    }
+    return undefined;
+}
 /**
  * Tries to extract extra event context via extraEventContextSymbol. Returns undefined if there is
  * no extra event context.
@@ -44,3 +63,23 @@ export function extractExtraEventContext(event) {
         return undefined;
     }
 }
+/**
+ * Tries to extract extra event tags via extraEventTagsSymbol. Returns undefined if there are no
+ * extra event tags.
+ */
+export function extractExtraEventTags(event) {
+    const fromRootSymbol = extractExtraTagsFromSymbol(event);
+    const fromSubSymbol = 'originalException' in event
+        ? extractExtraTagsFromSymbol(event.originalException)
+        : undefined;
+    const combined = {
+        ...fromRootSymbol,
+        ...fromSubSymbol,
+    };
+    if (Object.keys(combined).length) {
+        return combined;
+    }
+    else {
+        return undefined;
+    }
+}

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

@@ -9,6 +9,8 @@ export function createSentryConfig({ executionEnv, sentryDep, requiredSentryOpti
         defaultIntegrations: false,
         enabled: true,
         maxValueLength: 10_000,
+        tracesSampleRate: undefined,
+        tracesSampler: undefined,
     };
     const envSentryConfig = sentryConfigByEnv[executionEnv](
     /**

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

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

package/dist/logging/handle-error.js

@@ -5,30 +5,31 @@ import { LoggingState, logToConsoleWithoutSentry } from '../processing/log-to-co
 import { addPrematureEvent } from './premature-events.js';
 import { sentryClientForLogging } from './sentry-client-for-logging.js';
 /** Record an error to Sentry without throwing it. */
-export function handleError(error, extraContext) {
-    return internalHandleError(error, extraContext, {
+export function handleError(error, eventOptions) {
+    return internalHandleError(error, eventOptions, {
         wasSentPrematurely: false,
     });
 }
-function internalHandleError(error, extraContext, options) {
+function internalHandleError(error, eventOptions, options) {
     try {
         if (!sentryClientForLogging) {
             logToConsoleWithoutSentry(EventSeverityEnum.Error, LoggingState.NoSentryYet, {
                 message: extractErrorMessage(error),
                 event: undefined,
-                extra: extraContext,
+                extra: eventOptions?.context,
                 hint: undefined,
                 originalException: error,
             });
             addPrematureEvent(internalHandleError, [
                 error,
-                extraContext,
+                eventOptions,
                 { wasSentPrematurely: true },
             ]);
             return undefined;
         }
         const scopeContext = convertEventDetailsToSentryContext({
-            extraContext,
+            extraContext: eventOptions?.context,
+            tags: eventOptions?.tags,
             severity: EventSeverityEnum.Error,
         }, options);
         const eventId = sentryClientForLogging.captureException(error, scopeContext);

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

@@ -1,13 +1,13 @@
 import { type Event as SentryEvent } from '@sentry/core';
-import { type ContextOptions, type EventDetails, type EventExtraContext } from '../event-context/event-context.js';
+import { type ContextOptions, type EventContextAndTags, type EventDetails } from '../event-context/event-context.js';
 /** 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;
+    readonly debug: (info: Parameters<typeof sendLogToSentry>[0], eventOptions?: EventContextAndTags) => string | undefined;
     /** Sends an even to Sentry with info severity. */
-    readonly info: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
+    readonly info: (info: Parameters<typeof sendLogToSentry>[0], eventOptions?: EventContextAndTags) => string | undefined;
     /** Sends an even to Sentry with warning severity. */
-    readonly warning: (info: Parameters<typeof sendLogToSentry>[0], extraContext?: EventExtraContext) => string | undefined;
+    readonly warning: (info: Parameters<typeof sendLogToSentry>[0], eventOptions?: EventContextAndTags) => string | undefined;
 };
 declare function sendLogToSentry(logInfo: string | Omit<SentryEvent, 'extra' | 'level'>, eventDetails: EventDetails, options: ContextOptions): string | undefined;
 export {};

package/dist/logging/send-log.js

@@ -15,9 +15,10 @@ export const sendLog = {
     [EventSeverityEnum.Warning]: wrapLogWithSeverity(EventSeverityEnum.Warning),
 };
 function wrapLogWithSeverity(severity) {
-    return (info, extraContext) => {
+    return (info, eventOptions) => {
         return sendLogToSentry(info, {
-            extraContext,
+            extraContext: eventOptions?.context,
+            tags: eventOptions?.tags,
             severity,
         }, {
             wasSentPrematurely: false,

package/dist/processing/event-processor.js

@@ -1,7 +1,7 @@
 import { extractErrorMessage } from '@augment-vir/common';
 import { convertEventDetailsToSentryContext, } from '../event-context/event-context.js';
 import { extractEventSeverity } from '../event-context/event-severity.js';
-import { extractExtraEventContext } from '../event-context/extra-event-context.js';
+import { extractExtraEventContext, extractExtraEventTags, } from '../event-context/extra-event-context.js';
 /** Attach extra event data for a sentry event. */
 export function processSentryEvent(
 /** Event from Sentry. */
@@ -16,6 +16,10 @@ createUniversalContext) {
         ...createUniversalContext?.(),
         originalFullMessage: event.message || extractErrorMessage(hint.originalException),
     };
+    const extraTags = {
+        ...extractExtraEventTags(hint),
+        ...extractExtraEventTags(event),
+    };
     const sentryContext = convertEventDetailsToSentryContext({
         severity: extractEventSeverity(event),
         extraContext,
@@ -23,6 +27,12 @@ createUniversalContext) {
         wasSentPrematurely: false,
     });
     Object.assign(event, sentryContext);
+    if (Object.keys(extraTags).length) {
+        event.tags = {
+            ...event.tags,
+            ...extraTags,
+        };
+    }
     return event;
 }
 /** Tries to extract the original event message from different possible Sentry types. */

package/dist/processing/throttling.d.ts

@@ -16,7 +16,7 @@ export type ThrottleCacheEntry = {
  *
  * @category Internal
  */
-export declare const throttleCache: Record<string, ThrottleCacheEntry>;
+export declare const throttleCache: Map<string, ThrottleCacheEntry>;
 /**
  * Throttling options.
  *

package/dist/processing/throttling.js

@@ -1,4 +1,4 @@
-import { getOrSet, mergeDefinedProperties } from '@augment-vir/common';
+import { getOrSetFromMap, mergeDefinedProperties, } from '@augment-vir/common';
 import { calculateRelativeDate, getNowInUtcTimezone, isDateAfter, } from 'date-vir';
 import { sendLog } from '../logging/send-log.js';
 import { extractOriginalMessage } from './event-processor.js';
@@ -7,7 +7,7 @@ import { extractOriginalMessage } from './event-processor.js';
  *
  * @category Internal
  */
-export const throttleCache = {};
+export const throttleCache = new Map();
 /**
  * Default values for {@link ThrottleOptions}.
  *
@@ -29,14 +29,14 @@ export function shouldThrottleEvent(
 /** Event from Sentry. */
 event, 
 /** EventHint generated by Sentry. */
-hint = undefined, userOptions = defaultThrottleOptions) {
+hint, userOptions = defaultThrottleOptions) {
     const options = mergeDefinedProperties(defaultThrottleOptions, userOptions);
     if (options.disableThrottling) {
         return false;
     }
     const errorKey = extractOriginalMessage(event, hint);
     const now = getNowInUtcTimezone();
-    const errorThrottleData = getOrSet(throttleCache, errorKey, () => {
+    const errorThrottleData = getOrSetFromMap(throttleCache, errorKey, () => {
         return {
             intervalCount: 0,
             intervalStartAt: now,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sentry-vir",
-    "version": "3.2.3",
+    "version": "4.0.0",
     "description": "Easily use Sentry.",
     "keywords": [
         "config",
@@ -44,55 +44,55 @@
         "test:update": "npm test update"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.47.0",
-        "@augment-vir/common": "^31.47.0",
-        "@sentry/browser": "^10.22.0",
-        "@sentry/core": "^10.22.0",
-        "@sentry/node": "^10.22.0",
-        "date-vir": "^8.0.0",
-        "type-fest": "^5.1.0"
+        "@augment-vir/assert": "^31.65.0",
+        "@augment-vir/common": "^31.65.0",
+        "@sentry/browser": "^10.39.0",
+        "@sentry/core": "^10.39.0",
+        "@sentry/node": "^10.39.0",
+        "date-vir": "^8.1.1",
+        "type-fest": "^5.4.4"
     },
     "devDependencies": {
-        "@augment-vir/test": "^31.47.0",
-        "@eslint/eslintrc": "^3.3.1",
-        "@eslint/js": "^9.38.0",
-        "@stylistic/eslint-plugin": "^5.5.0",
+        "@augment-vir/test": "^31.65.0",
+        "@eslint/eslintrc": "^3.3.3",
+        "@eslint/js": "^9.39.2",
+        "@stylistic/eslint-plugin": "^5.9.0",
         "@stylistic/eslint-plugin-ts": "^4.4.1",
-        "@typescript-eslint/eslint-plugin": "^8.46.2",
-        "@web/dev-server-esbuild": "^1.0.4",
+        "@typescript-eslint/eslint-plugin": "^8.56.0",
+        "@web/dev-server-esbuild": "^1.0.5",
         "@web/test-runner": "^0.20.2",
         "@web/test-runner-commands": "^0.9.0",
         "@web/test-runner-playwright": "^0.11.1",
         "@web/test-runner-visual-regression": "^0.10.0",
-        "cspell": "^9.2.2",
-        "dependency-cruiser": "^17.2.0",
-        "esbuild": "^0.25.11",
-        "eslint": "^9.38.0",
+        "cspell": "^9.6.4",
+        "dependency-cruiser": "^17.3.8",
+        "esbuild": "^0.27.3",
+        "eslint": "^9.39.2",
         "eslint-config-prettier": "^10.1.8",
-        "eslint-plugin-jsdoc": "^61.1.11",
+        "eslint-plugin-jsdoc": "^62.7.0",
         "eslint-plugin-monorepo-cop": "^1.0.2",
-        "eslint-plugin-playwright": "^2.2.2",
-        "eslint-plugin-prettier": "^5.5.4",
+        "eslint-plugin-playwright": "^2.7.0",
+        "eslint-plugin-prettier": "^5.5.5",
         "eslint-plugin-require-extensions": "^0.1.3",
-        "eslint-plugin-sonarjs": "^3.0.5",
-        "eslint-plugin-unicorn": "^62.0.0",
+        "eslint-plugin-sonarjs": "^4.0.0",
+        "eslint-plugin-unicorn": "^63.0.0",
         "istanbul-smart-text-reporter": "^1.1.5",
         "markdown-code-example-inserter": "^3.0.3",
-        "npm-check-updates": "^19.1.2",
+        "npm-check-updates": "^19.4.1",
         "prettier": "~3.3.3",
         "prettier-plugin-interpolated-html-tags": "^2.0.1",
-        "prettier-plugin-jsdoc": "^1.5.0",
-        "prettier-plugin-multiline-arrays": "^4.0.3",
+        "prettier-plugin-jsdoc": "^1.8.0",
+        "prettier-plugin-multiline-arrays": "^4.1.4",
         "prettier-plugin-organize-imports": "^4.3.0",
-        "prettier-plugin-packagejson": "^2.5.19",
-        "prettier-plugin-sort-json": "^4.1.1",
+        "prettier-plugin-packagejson": "^3.0.0",
+        "prettier-plugin-sort-json": "^4.2.0",
         "prettier-plugin-toml": "^2.0.6",
-        "runstorm": "^0.6.2",
-        "typedoc": "^0.28.14",
+        "runstorm": "^1.0.0",
+        "typedoc": "^0.28.17",
         "typescript": "^5.9.3",
-        "typescript-eslint": "^8.46.2",
-        "virmator": "^14.2.1",
-        "vite": "^7.1.12"
+        "typescript-eslint": "^8.56.0",
+        "virmator": "^14.6.1",
+        "vite": "^7.3.1"
     },
     "engines": {
         "node": ">=22"

package/dist/augments/replace-object.d.ts

@@ -1,2 +0,0 @@
-import { type AnyObject } from '@augment-vir/common';
-export declare function replaceObject<T extends AnyObject>(original: T, replacement: T): void;

package/dist/augments/replace-object.js

@@ -1,6 +0,0 @@
-export function replaceObject(original, replacement) {
-    Object.keys(original).forEach((key) => delete original[key]);
-    Object.entries(replacement).forEach(([key, value,]) => {
-        original[key] = value;
-    });
-}