@tramvai/module-micro-sentry 4.2.1 → 4.3.1

package/README.md

@@ -24,6 +24,42 @@ And make sure to add `SENTRY_DSN` environment on deployed stands. Otherwise modu
 
 ## Explanation
 
+### Working with unhandled rejections and global errors
+
+Micro-sentry itself does not have the proper logic to intercept global [unhandlerejection](https://developer.mozilla.org/en-US/docs/Web/API/Window/unhandledrejection_event) and [error](https://developer.mozilla.org/en-US/docs/Web/API/Window/error_event) events. In this case, `@tramvai/module-micro-sentry` adds an inline script with custom logic for the `unhandledrejection` and `error` events. Before the micro-sentry package is initialized, all errors are added to an errorQueue, and when micro-sentry is initialized, this queue is cleared, and all caught errors are sent to the `SENTRY_DSN` URL. To create your custom global error handler, you can use the `MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN`. For example:
+
+```ts
+// createErrorInterceptor.inline.ts
+
+export function createErrorInterceptor() {
+  window.onerror = function () {
+    // your custom logic
+  };
+  window.onunhandledrejection = function () {
+    // your custom logic
+  };
+}
+```
+
+```ts
+import { createApp } from '@tramvai/core';
+import { TramvaiMicroSentryModule } from '@tramvai/module-micro-sentry';
+import { createErrorInterceptor } from './createErrorInterceptor.inline';
+
+createApp({
+  name: 'sample-application',
+  modules: [
+    TramvaiMicroSentryModule,
+    provide({
+      provide: MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN,
+      useFactory: ({ microSentryInlineErrorInterceptorKey }) => {
+        return `(${createErrorInterceptor})()`;
+      },
+    }),
+  ],
+});
+```
+
 ### Environment variables
 
 Required:
@@ -64,3 +100,11 @@ Ready to use instance of micro-sentry
 ### `MICRO_SENTRY_OPTIONS_TOKEN`
 
 Configuration options for micro-sentry
+
+### `MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN`
+
+Key value for ErrorInterceptor script. This key will be used to save custom logiс to window object.
+
+### `MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN`
+
+Script for inline error interceptor

package/lib/browser.js

@@ -1,12 +1,13 @@
 import { declareModule, provide } from '@tramvai/core';
 import { ENV_MANAGER_TOKEN } from '@tramvai/module-common';
-import { sharedProviders } from './providers.browser.js';
+import { browserProviders } from './providers.browser.js';
 import { MICRO_SENTRY_OPTIONS_TOKEN } from './tokens.browser.js';
-export { MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN } from './tokens.browser.js';
+export { MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN, MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN, MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN } from './tokens.browser.js';
 
 const TramvaiMicroSentryModule = declareModule({
     name: 'TramvaiMicroSentryModule',
     providers: [
+        ...browserProviders,
         provide({
             provide: MICRO_SENTRY_OPTIONS_TOKEN,
             useFactory: ({ envManager }) => {
@@ -20,7 +21,6 @@ const TramvaiMicroSentryModule = declareModule({
                 envManager: ENV_MANAGER_TOKEN,
             },
         }),
-        ...sharedProviders,
     ],
     imports: [],
 });

package/lib/inlineErrorInterceptor.inline.d.ts

@@ -0,0 +1,2 @@
+export declare function createErrorInterceptor(namespace: string): void;
+//# sourceMappingURL=inlineErrorInterceptor.inline.d.ts.map

package/lib/inlineErrorInterceptor.inline.es.js

@@ -0,0 +1,48 @@
+// Идея взята из https://github.com/getsentry/sentry-javascript/blob/master/packages/browser/src/loader.js
+/* eslint-disable prefer-rest-params */
+function createErrorInterceptor(namespace) {
+    const originalOnError = window.onerror;
+    const originalOnUnhandledRejection = window.onunhandledrejection;
+    const errorInterceptorNamespace = {
+        errorsQueue: [],
+        onError(error) {
+            this.errorsQueue.push(error);
+        },
+        clear() {
+            window.onerror = originalOnError;
+            window.onunhandledrejection = originalOnUnhandledRejection;
+            delete window[namespace];
+        },
+    };
+    window[namespace] = errorInterceptorNamespace;
+    window.onerror = function (_message, _source, _lineno, _colno, error) {
+        if (error) {
+            errorInterceptorNamespace.onError(error);
+        }
+        if (originalOnError) {
+            //@ts-expect-error
+            originalOnError.apply(window, arguments);
+        }
+    };
+    window.onunhandledrejection = function (e) {
+        let reason = null;
+        if ('reason' in e) {
+            reason = e.reason;
+            //@ts-expect-error
+        }
+        else if ('detail' in e && 'reason' in e.detail) {
+            //@ts-expect-error
+            reason = e.detail.reason;
+        }
+        if (reason) {
+            errorInterceptorNamespace.onError(reason);
+        }
+        if (originalOnUnhandledRejection) {
+            //@ts-expect-error
+            originalOnUnhandledRejection.apply(window, arguments);
+        }
+    };
+}
+/* eslint-enable prefer-rest-params */
+
+export { createErrorInterceptor };

package/lib/inlineErrorInterceptor.inline.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// Идея взята из https://github.com/getsentry/sentry-javascript/blob/master/packages/browser/src/loader.js
+/* eslint-disable prefer-rest-params */
+function createErrorInterceptor(namespace) {
+    const originalOnError = window.onerror;
+    const originalOnUnhandledRejection = window.onunhandledrejection;
+    const errorInterceptorNamespace = {
+        errorsQueue: [],
+        onError(error) {
+            this.errorsQueue.push(error);
+        },
+        clear() {
+            window.onerror = originalOnError;
+            window.onunhandledrejection = originalOnUnhandledRejection;
+            delete window[namespace];
+        },
+    };
+    window[namespace] = errorInterceptorNamespace;
+    window.onerror = function (_message, _source, _lineno, _colno, error) {
+        if (error) {
+            errorInterceptorNamespace.onError(error);
+        }
+        if (originalOnError) {
+            //@ts-expect-error
+            originalOnError.apply(window, arguments);
+        }
+    };
+    window.onunhandledrejection = function (e) {
+        let reason = null;
+        if ('reason' in e) {
+            reason = e.reason;
+            //@ts-expect-error
+        }
+        else if ('detail' in e && 'reason' in e.detail) {
+            //@ts-expect-error
+            reason = e.detail.reason;
+        }
+        if (reason) {
+            errorInterceptorNamespace.onError(reason);
+        }
+        if (originalOnUnhandledRejection) {
+            //@ts-expect-error
+            originalOnUnhandledRejection.apply(window, arguments);
+        }
+    };
+}
+/* eslint-enable prefer-rest-params */
+
+exports.createErrorInterceptor = createErrorInterceptor;

package/lib/providers.browser.js

@@ -1,9 +1,16 @@
 import { provide, commandLineListTokens } from '@tramvai/core';
 import { ENV_USED_TOKEN } from '@tramvai/module-common';
 import { BrowserMicroSentryClient } from '@micro-sentry/browser';
-import { MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN } from './tokens.browser.js';
+import { MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN, MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN } from './tokens.browser.js';
 
 const sharedProviders = [
+    provide({
+        provide: MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN,
+        useValue: '__MICRO_SENTRY_MODULE_INLINE_ERROR_INTERCEPTOR__',
+    }),
+];
+const browserProviders = [
+    ...sharedProviders,
     provide({
         provide: ENV_USED_TOKEN,
         useValue: [{ key: 'SENTRY_DSN' }],
@@ -19,15 +26,25 @@ const sharedProviders = [
     }),
     provide({
         provide: commandLineListTokens.init,
-        useFactory: ({ microSentry }) => {
+        useFactory: ({ microSentry, microSentryInlineErrorInterceptorKey }) => {
             return function initMicroSentry() {
+                var _a;
+                const errorInterceptor = window[microSentryInlineErrorInterceptorKey];
+                errorInterceptor.onError = (error) => {
+                    microSentry === null || microSentry === void 0 ? void 0 : microSentry.report(error);
+                };
+                while ((_a = errorInterceptor === null || errorInterceptor === void 0 ? void 0 : errorInterceptor.errorsQueue) === null || _a === void 0 ? void 0 : _a.length) {
+                    const error = errorInterceptor.errorsQueue.pop();
+                    errorInterceptor.onError(error);
+                }
                 return microSentry;
             };
         },
         deps: {
             microSentry: MICRO_SENTRY_INSTANCE_TOKEN,
+            microSentryInlineErrorInterceptorKey: MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN,
         },
     }),
 ];
 
-export { sharedProviders };
+export { browserProviders, sharedProviders };

package/lib/providers.d.ts

@@ -1,3 +1,4 @@
 import { type Provider } from '@tramvai/core';
 export declare const sharedProviders: Provider[];
+export declare const browserProviders: Provider[];
 //# sourceMappingURL=providers.d.ts.map

package/lib/providers.es.js

@@ -0,0 +1,50 @@
+import { provide, commandLineListTokens } from '@tramvai/core';
+import { ENV_USED_TOKEN } from '@tramvai/module-common';
+import { BrowserMicroSentryClient } from '@micro-sentry/browser';
+import { MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN, MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN } from './tokens.es.js';
+
+const sharedProviders = [
+    provide({
+        provide: MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN,
+        useValue: '__MICRO_SENTRY_MODULE_INLINE_ERROR_INTERCEPTOR__',
+    }),
+];
+[
+    ...sharedProviders,
+    provide({
+        provide: ENV_USED_TOKEN,
+        useValue: [{ key: 'SENTRY_DSN' }],
+    }),
+    provide({
+        provide: MICRO_SENTRY_INSTANCE_TOKEN,
+        useFactory: ({ microSentryOptions }) => {
+            return new BrowserMicroSentryClient(microSentryOptions);
+        },
+        deps: {
+            microSentryOptions: MICRO_SENTRY_OPTIONS_TOKEN,
+        },
+    }),
+    provide({
+        provide: commandLineListTokens.init,
+        useFactory: ({ microSentry, microSentryInlineErrorInterceptorKey }) => {
+            return function initMicroSentry() {
+                var _a;
+                const errorInterceptor = window[microSentryInlineErrorInterceptorKey];
+                errorInterceptor.onError = (error) => {
+                    microSentry === null || microSentry === void 0 ? void 0 : microSentry.report(error);
+                };
+                while ((_a = errorInterceptor === null || errorInterceptor === void 0 ? void 0 : errorInterceptor.errorsQueue) === null || _a === void 0 ? void 0 : _a.length) {
+                    const error = errorInterceptor.errorsQueue.pop();
+                    errorInterceptor.onError(error);
+                }
+                return microSentry;
+            };
+        },
+        deps: {
+            microSentry: MICRO_SENTRY_INSTANCE_TOKEN,
+            microSentryInlineErrorInterceptorKey: MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN,
+        },
+    }),
+];
+
+export { sharedProviders };

package/lib/providers.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var moduleCommon = require('@tramvai/module-common');
+var browser = require('@micro-sentry/browser');
+var tokens = require('./tokens.js');
+
+const sharedProviders = [
+    core.provide({
+        provide: tokens.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN,
+        useValue: '__MICRO_SENTRY_MODULE_INLINE_ERROR_INTERCEPTOR__',
+    }),
+];
+[
+    ...sharedProviders,
+    core.provide({
+        provide: moduleCommon.ENV_USED_TOKEN,
+        useValue: [{ key: 'SENTRY_DSN' }],
+    }),
+    core.provide({
+        provide: tokens.MICRO_SENTRY_INSTANCE_TOKEN,
+        useFactory: ({ microSentryOptions }) => {
+            return new browser.BrowserMicroSentryClient(microSentryOptions);
+        },
+        deps: {
+            microSentryOptions: tokens.MICRO_SENTRY_OPTIONS_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: core.commandLineListTokens.init,
+        useFactory: ({ microSentry, microSentryInlineErrorInterceptorKey }) => {
+            return function initMicroSentry() {
+                var _a;
+                const errorInterceptor = window[microSentryInlineErrorInterceptorKey];
+                errorInterceptor.onError = (error) => {
+                    microSentry === null || microSentry === void 0 ? void 0 : microSentry.report(error);
+                };
+                while ((_a = errorInterceptor === null || errorInterceptor === void 0 ? void 0 : errorInterceptor.errorsQueue) === null || _a === void 0 ? void 0 : _a.length) {
+                    const error = errorInterceptor.errorsQueue.pop();
+                    errorInterceptor.onError(error);
+                }
+                return microSentry;
+            };
+        },
+        deps: {
+            microSentry: tokens.MICRO_SENTRY_INSTANCE_TOKEN,
+            microSentryInlineErrorInterceptorKey: tokens.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN,
+        },
+    }),
+];
+
+exports.sharedProviders = sharedProviders;

package/lib/server.es.js

@@ -1,15 +1,43 @@
 import { declareModule, provide } from '@tramvai/core';
-import { MICRO_SENTRY_INSTANCE_TOKEN } from './tokens.es.js';
-export { MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN } from './tokens.es.js';
+import { RENDER_SLOTS, ResourceSlot, ResourceType } from '@tramvai/tokens-render';
+import { MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN, MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN, MICRO_SENTRY_INSTANCE_TOKEN } from './tokens.es.js';
+export { MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN, MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN, MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN } from './tokens.es.js';
+import { createErrorInterceptor } from './inlineErrorInterceptor.inline.es.js';
+import { sharedProviders } from './providers.es.js';
 
 const TramvaiMicroSentryModule = declareModule({
     name: 'TramvaiMicroSentryModule',
     imports: [],
     providers: [
+        ...sharedProviders,
+        provide({
+            provide: MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN,
+            useFactory: ({ microSentryInlineErrorInterceptorKey }) => {
+                return `(${createErrorInterceptor})('${microSentryInlineErrorInterceptorKey}')`;
+            },
+            deps: {
+                microSentryInlineErrorInterceptorKey: MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN,
+            },
+        }),
+        provide({
+            provide: RENDER_SLOTS,
+            multi: true,
+            useFactory: ({ payload }) => {
+                return {
+                    slot: ResourceSlot.HEAD_CORE_SCRIPTS,
+                    type: ResourceType.inlineScript,
+                    payload,
+                };
+            },
+            deps: {
+                payload: MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN,
+            },
+        }),
         provide({
             provide: MICRO_SENTRY_INSTANCE_TOKEN,
             useFactory: () => {
                 if (process.env.NODE_ENV === 'development') {
+                    // eslint-disable-next-line no-console
                     console.warn('micro-sentry will work only in browser environment, and will not work in server environment. If you need error logging both on server and client, take a look on @tramvai/module-sentry package');
                 }
                 return null;

package/lib/server.js

@@ -3,16 +3,44 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var core = require('@tramvai/core');
+var tokensRender = require('@tramvai/tokens-render');
 var tokens = require('./tokens.js');
+var inlineErrorInterceptor_inline = require('./inlineErrorInterceptor.inline.js');
+var providers = require('./providers.js');
 
 const TramvaiMicroSentryModule = core.declareModule({
     name: 'TramvaiMicroSentryModule',
     imports: [],
     providers: [
+        ...providers.sharedProviders,
+        core.provide({
+            provide: tokens.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN,
+            useFactory: ({ microSentryInlineErrorInterceptorKey }) => {
+                return `(${inlineErrorInterceptor_inline.createErrorInterceptor})('${microSentryInlineErrorInterceptorKey}')`;
+            },
+            deps: {
+                microSentryInlineErrorInterceptorKey: tokens.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN,
+            },
+        }),
+        core.provide({
+            provide: tokensRender.RENDER_SLOTS,
+            multi: true,
+            useFactory: ({ payload }) => {
+                return {
+                    slot: tokensRender.ResourceSlot.HEAD_CORE_SCRIPTS,
+                    type: tokensRender.ResourceType.inlineScript,
+                    payload,
+                };
+            },
+            deps: {
+                payload: tokens.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN,
+            },
+        }),
         core.provide({
             provide: tokens.MICRO_SENTRY_INSTANCE_TOKEN,
             useFactory: () => {
                 if (process.env.NODE_ENV === 'development') {
+                    // eslint-disable-next-line no-console
                     console.warn('micro-sentry will work only in browser environment, and will not work in server environment. If you need error logging both on server and client, take a look on @tramvai/module-sentry package');
                 }
                 return null;
@@ -21,6 +49,8 @@ const TramvaiMicroSentryModule = core.declareModule({
     ],
 });
 
+exports.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN = tokens.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN;
+exports.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN = tokens.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN;
 exports.MICRO_SENTRY_INSTANCE_TOKEN = tokens.MICRO_SENTRY_INSTANCE_TOKEN;
 exports.MICRO_SENTRY_OPTIONS_TOKEN = tokens.MICRO_SENTRY_OPTIONS_TOKEN;
 exports.TramvaiMicroSentryModule = TramvaiMicroSentryModule;

package/lib/tokens.browser.js

@@ -2,5 +2,7 @@ import { createToken } from '@tramvai/core';
 
 const MICRO_SENTRY_INSTANCE_TOKEN = createToken('MICRO_SENTRY_INSTANCE_TOKEN');
 const MICRO_SENTRY_OPTIONS_TOKEN = createToken('MICRO_SENTRY_OPTIONS_TOKEN');
+const MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN = createToken('MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN');
+const MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN = createToken('MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN');
 
-export { MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN };
+export { MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN, MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN, MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN };

package/lib/tokens.d.ts

@@ -5,4 +5,10 @@ export declare const MICRO_SENTRY_INSTANCE_TOKEN: (BrowserMicroSentryClient & {
 export declare const MICRO_SENTRY_OPTIONS_TOKEN: BrowserSentryClientOptions & {
     __type?: "base token" | undefined;
 };
+export declare const MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN: string & {
+    __type?: "base token" | undefined;
+};
+export declare const MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN: string & {
+    __type?: "base token" | undefined;
+};
 //# sourceMappingURL=tokens.d.ts.map

package/lib/tokens.es.js

@@ -2,5 +2,7 @@ import { createToken } from '@tramvai/core';
 
 const MICRO_SENTRY_INSTANCE_TOKEN = createToken('MICRO_SENTRY_INSTANCE_TOKEN');
 const MICRO_SENTRY_OPTIONS_TOKEN = createToken('MICRO_SENTRY_OPTIONS_TOKEN');
+const MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN = createToken('MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN');
+const MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN = createToken('MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN');
 
-export { MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN };
+export { MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN, MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN, MICRO_SENTRY_INSTANCE_TOKEN, MICRO_SENTRY_OPTIONS_TOKEN };

package/lib/tokens.js

@@ -6,6 +6,10 @@ var core = require('@tramvai/core');
 
 const MICRO_SENTRY_INSTANCE_TOKEN = core.createToken('MICRO_SENTRY_INSTANCE_TOKEN');
 const MICRO_SENTRY_OPTIONS_TOKEN = core.createToken('MICRO_SENTRY_OPTIONS_TOKEN');
+const MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN = core.createToken('MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN');
+const MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN = core.createToken('MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN');
 
+exports.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN = MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_KEY_TOKEN;
+exports.MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN = MICRO_SENTRY_INLINE_ERROR_INTERCEPTOR_TOKEN;
 exports.MICRO_SENTRY_INSTANCE_TOKEN = MICRO_SENTRY_INSTANCE_TOKEN;
 exports.MICRO_SENTRY_OPTIONS_TOKEN = MICRO_SENTRY_OPTIONS_TOKEN;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-micro-sentry",
-  "version": "4.2.1",
+  "version": "4.3.1",
   "description": "Micro-sentry module",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -22,8 +22,9 @@
     "@micro-sentry/browser": "^7.0.1"
   },
   "peerDependencies": {
-    "@tramvai/core": "4.2.1",
-    "@tramvai/module-common": "4.2.1"
+    "@tramvai/tokens-render": "4.3.1",
+    "@tramvai/core": "4.3.1",
+    "@tramvai/module-common": "4.3.1"
   },
   "module": "lib/server.es.js"
 }