@tramvai/module-application-monitoring 6.80.6

package/README.md

@@ -0,0 +1,278 @@
+# @tramvai/module-application-monitoring
+
+Tramvai module for collecting and sending application health monitoring events throughout the application lifecycle.
+
+## Overview
+
+Tramvai application's health and performance monitoring. It monitors critical lifecycle events from HTML parsing through app initialization and rendering, capturing errors and performance metrics along the way.
+
+### Monitored Events
+
+| Event | Description | Trigger Point |
+| --- | --- | --- |
+| `html-opened` | HTML document parsed and ready | Document parse complete |
+| `assets-loaded` | All critical assets loaded successfully | Window load event |
+| `assets-load-failed` | One or more critical assets failed to load | Window load event (with errors) |
+| `app:initialized` | Application initialization complete | After 'init' command line |
+| `app:initialize-failed` | Application failed to initialize | App init error |
+| `app:rendered` | Application rendered successfully | After successful app render |
+| `app:render-failed` | Application rendering failed | Error boundary or renderer callback |
+| `react:render` | React rendered successfully | After successful react render |
+| `react:error` | React rendered with error | The error occure while react hydration, it can be uncaughtError,caughtError or recoverableError |
+| `app:render-failed` | Application rendering failed | Error boundary or renderer callback |
+
+| `unhandled-error` | Unhandled promise rejection | Global unhandledrejection event |
+
+## Installation
+
+```bash
+npm install @tramvai/module-application-monitoring
+```
+
+Or with yarn:
+
+```bash
+yarn add @tramvai/module-application-monitoring
+```
+
+## Basic Usage
+
+### 1. Register the Module
+
+Add the module to your Tramvai application:
+
+```typescript
+import { createApp } from '@tramvai/core';
+import { ApplicationMonitoringModule } from '@tramvai/module-application-monitoring';
+
+createApp({
+  name: 'my-app',
+  modules: [ApplicationMonitoringModule],
+});
+```
+
+### 2. Provide an Inline Reporter Factory
+
+Inline reporter are used to capture lifecycle events and send them to a monitoring service (like an analytics tool or error logger). Inline reporters are injected into the HTML during server-side rendering. This allows to detect errors and performance issues early, even before the app is fully up and running.
+
+Key Events Sent Through Inline Reporters:
+
+- **HTML Opened** (`html-opened`): Tracks when the HTML is parsed and ready.
+- **Assets Loaded** (`assets-loaded`) / Assets Load Failed (`**assets-load-failed**`): Tracks the success/failure of loading assets (JS, CSS, etc.).
+- **App Start Failed** (`app-start-failed`): Tracks initialization errors.
+- **Unhandled Errors** (`unhandled-error`): Tracks unhandled errors or promise rejections.
+
+The module requires an inline reporter factory to send events to your monitoring service. To do this provide `INLINE_REPORTER_FACTORY_SCRIPT_TOKEN` using inline script or object
+
+```typescript
+import { provide } from '@tramvai/core';
+import { INLINE_REPORTER_FACTORY_SCRIPT_TOKEN } from '@tramvai/module-application-monitoring';
+
+const providers = [
+  provide({
+    provide: INLINE_REPORTER_FACTORY_SCRIPT_TOKEN,
+    useValue: (parameters) => {
+      return {
+        send(eventName, payload) {
+          fetch('/api/monitoring', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              event: eventName,
+              ...parameters,
+              ...payload,
+              timestamp: Date.now(),
+            }),
+          });
+        },
+      };
+    },
+  }),
+];
+```
+
+```typescript
+import { provide } from '@tramvai/core';
+import { INLINE_REPORTER_FACTORY_SCRIPT_TOKEN } from '@tramvai/module-application-monitoring';
+import { inlineReporterFactoryScript } from './inlineReporter.inline';
+
+const providers = [
+  provide({
+    provide: INLINE_REPORTER_FACTORY_SCRIPT_TOKEN,
+    useFactory: () => {
+      return inlineReporterFactoryScript;
+    },
+  }),
+];
+```
+
+## Configuration
+
+### Tokens
+
+#### INLINE_REPORTER_PARAMETERS_TOKEN
+
+**Example: Adding Custom Parameters**
+
+```typescript
+import { provide } from '@tramvai/core';
+import { INLINE_REPORTER_PARAMETERS_TOKEN } from '@tramvai/module-application-monitoring';
+
+provide({
+  provide: INLINE_REPORTER_PARAMETERS_TOKEN,
+  useFactory: ({ appInfo, envManager }) => {
+    return {
+      appName: appInfo.appName,
+      appRelease: envManager.get('APP_RELEASE'),
+      appVersion: envManager.get('APP_VERSION'),
+      environment: envManager.get('NODE_ENV'),
+      region: envManager.get('DEPLOY_REGION'),
+    };
+  },
+  deps: {
+    envManager: ENV_MANAGER_TOKEN,
+    appInfo: APP_INFO_TOKEN,
+  },
+});
+```
+
+### How to configure monitoring for main Tramvai events
+
+There is a possibility to monitor the main events that occur while the Tramvai application is being initialized. Here is a list of these events:
+
+- `app:initialized`
+- `app:initialize-failed`
+- `app:rendered`
+- `app:render-failed`
+- `react:render`
+- `react:error`
+
+When you are using ApplicationMonitoringModule, these events are sent to your remote logger by default. But in some cases, you will need custom metrics. Here is an example of how to do this:
+
+```typescript
+import { provide } from '@tramvai/core';
+import { TRAMVAI_HOOKS_TOKEN, commandLineListTokens } from '@tramvai/core';
+
+const providers = [
+  provide({
+    provide: commandLineListTokens.init,
+    useFactory: ({ tramvaiHooks }) => {
+      hooks['app:initialized'].tap('app-init', () => {
+        fetch('/api/monitoring', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            event: 'app-initialized',
+            ...parameters,
+            ...payload,
+            timestamp: Date.now(),
+          }),
+        });
+      });
+      hooks['app:initialize-failed'].tap('app-init-failed', (_, { error }) => {
+        fetch('/api/monitoring', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            event: 'app-initialize-failed',
+            ...error,
+            ...parameters,
+            ...payload,
+            timestamp: Date.now(),
+          }),
+        });
+      });
+      hooks['app:rendered'].tap('app-rendered', () => {
+        fetch('/api/monitoring', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            event: 'app-rendered',
+            ...parameters,
+            ...payload,
+            timestamp: Date.now(),
+          }),
+        });
+        s;
+      });
+      hooks['app:render-failed'].tap('app-render-failed', (_, { error }) => {
+        fetch('/api/monitoring', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            event: 'app-render-failed',
+            error,
+            ...parameters,
+            ...payload,
+            timestamp: Date.now(),
+          }),
+        });
+        s;
+      });
+
+      hooks['react:render'].tap('react-render', () => {
+        fetch('/api/monitoring', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            event: eventName,
+            ...parameters,
+            ...payload,
+            timestamp: Date.now(),
+          }),
+        });
+      });
+
+      hooks['react:error'].tap('react-error', (_, { error }) => {
+        fetch('/api/monitoring', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            error,
+            event: 'react-error',
+            ...parameters,
+            ...payload,
+            timestamp: Date.now(),
+          }),
+        });
+      });
+    },
+    deps: {
+      tramvaiHooks: TRAMVAI_HOOKS_TOKEN,
+    },
+  }),
+];
+```
+
+## How It Works
+
+### Server-Side
+
+1. **Inline Scripts Injection**: The module injects monitoring scripts into the HTML `<head>` during server-side rendering
+2. **Early Monitoring**: Scripts execute immediately to catch early errors and events
+3. **Reporter Initialization**: The inline reporter factory creates a global reporter instance
+4. **Hook Registration**: Server-side hooks are registered to track initialization events
+
+### Client-Side
+
+1. **HTML Opened**: First script executes when HTML is parsed
+2. **Asset Monitoring**: Error listeners track script/link loading failures
+3. **App Creation**: Monitors unhandled errors during app bootstrap
+4. **Initialization**: Tracks when app completes initialization
+5. **Rendering**: Integrates with error boundaries and renderer callbacks
+
+### Event Flow
+
+```
+HTML Parse → html-opened
+    ↓
+Asset Loading → assets-loaded / assets-load-failed
+    ↓
+App Bootstrap → app-start-failed (on error)
+    ↓
+App Init → app-initialized
+    ↓
+App Render → app-rendered / app-render-failed
+    ↓
+Runtime → unhandled-error (if occurs)
+```

package/lib/browser.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './tokens';
+export declare const ApplicationMonitoringModule: import("@tinkoff/dippy/lib/modules/module.h").ModuleClass & Partial<import("@tinkoff/dippy/lib/modules/module.h").ModuleSecretParameters> & {
+    [x: string]: (...args: any[]) => import("@tramvai/core").ModuleType;
+};
+//# sourceMappingURL=browser.d.ts.map

package/lib/browser.js

@@ -0,0 +1,11 @@
+import { declareModule } from '@tramvai/core';
+import { sharedProviders } from './sharedProviders.browser.js';
+export { INLINE_REPORTER_FACTORY_SCRIPT_TOKEN, INLINE_REPORTER_PARAMETERS_TOKEN } from './tokens.browser.js';
+
+const ApplicationMonitoringModule = declareModule({
+    name: 'ApplicationMonitoringModule',
+    imports: [],
+    providers: [...sharedProviders],
+});
+
+export { ApplicationMonitoringModule };

package/lib/constants.browser.js

@@ -0,0 +1,3 @@
+const LOGGER_NAME = 'application-health';
+
+export { LOGGER_NAME };

package/lib/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const LOGGER_NAME = "application-health";
+//# sourceMappingURL=constants.d.ts.map

package/lib/constants.es.js

@@ -0,0 +1,3 @@
+const LOGGER_NAME = 'application-health';
+
+export { LOGGER_NAME };

package/lib/constants.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const LOGGER_NAME = 'application-health';
+
+exports.LOGGER_NAME = LOGGER_NAME;

package/lib/inlineReporters/events/appCreationMonitoringScript.inline.d.ts

@@ -0,0 +1,4 @@
+export declare const appCreationMonitoringScript: (payload: {
+    [x: string]: any;
+}) => void;
+//# sourceMappingURL=appCreationMonitoringScript.inline.d.ts.map

package/lib/inlineReporters/events/appCreationMonitoringScript.inline.es.js

@@ -0,0 +1,10 @@
+const appCreationMonitoringScript = (payload) => {
+    window.addEventListener('unhandledrejection', 
+    //@ts-expect-error
+    (event) => {
+        const eventName = 'unhandled-error';
+        window.__TRAMVAI_INLINE_REPORTER?.send?.(eventName, { ...event, ...payload });
+    }, true);
+};
+
+export { appCreationMonitoringScript };

package/lib/inlineReporters/events/appCreationMonitoringScript.inline.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const appCreationMonitoringScript = (payload) => {
+    window.addEventListener('unhandledrejection', 
+    //@ts-expect-error
+    (event) => {
+        const eventName = 'unhandled-error';
+        window.__TRAMVAI_INLINE_REPORTER?.send?.(eventName, { ...event, ...payload });
+    }, true);
+};
+
+exports.appCreationMonitoringScript = appCreationMonitoringScript;

package/lib/inlineReporters/events/errorMonitoringScript.inline.d.ts

@@ -0,0 +1,4 @@
+export declare const errorMonitoringScript: (payload: {
+    [x: string]: any;
+}) => void;
+//# sourceMappingURL=errorMonitoringScript.inline.d.ts.map

package/lib/inlineReporters/events/errorMonitoringScript.inline.es.js

@@ -0,0 +1,29 @@
+const errorMonitoringScript = (payload) => {
+    const errors = [];
+    window.addEventListener('error', (event) => {
+        const tag = event && event.target;
+        const tagName = tag && tag.tagName && tag.tagName.toLowerCase();
+        if (!tag || (tagName !== 'link' && tagName !== 'script')) {
+            return;
+        }
+        if (event?.error?.retry === 'success') {
+            return;
+        }
+        if (!tag.dataset.critical && !tag.dataset.webpack) {
+            return;
+        }
+        errors.push(event);
+    }, true);
+    window.addEventListener('load', () => {
+        let eventName = null;
+        if (errors.length > 0) {
+            eventName = 'assets-load-failed';
+        }
+        else {
+            eventName = 'assets-loaded';
+        }
+        window.__TRAMVAI_INLINE_REPORTER?.send?.(eventName, { ...payload });
+    });
+};
+
+export { errorMonitoringScript };

package/lib/inlineReporters/events/errorMonitoringScript.inline.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const errorMonitoringScript = (payload) => {
+    const errors = [];
+    window.addEventListener('error', (event) => {
+        const tag = event && event.target;
+        const tagName = tag && tag.tagName && tag.tagName.toLowerCase();
+        if (!tag || (tagName !== 'link' && tagName !== 'script')) {
+            return;
+        }
+        if (event?.error?.retry === 'success') {
+            return;
+        }
+        if (!tag.dataset.critical && !tag.dataset.webpack) {
+            return;
+        }
+        errors.push(event);
+    }, true);
+    window.addEventListener('load', () => {
+        let eventName = null;
+        if (errors.length > 0) {
+            eventName = 'assets-load-failed';
+        }
+        else {
+            eventName = 'assets-loaded';
+        }
+        window.__TRAMVAI_INLINE_REPORTER?.send?.(eventName, { ...payload });
+    });
+};
+
+exports.errorMonitoringScript = errorMonitoringScript;

package/lib/inlineReporters/events/htmlOpenedMonitoringScript.inline.d.ts

@@ -0,0 +1,4 @@
+export declare const htmlOpenedMonitoringScript: (payload: {
+    [x: string]: any;
+}) => void;
+//# sourceMappingURL=htmlOpenedMonitoringScript.inline.d.ts.map

package/lib/inlineReporters/events/htmlOpenedMonitoringScript.inline.es.js

@@ -0,0 +1,5 @@
+const htmlOpenedMonitoringScript = (payload) => {
+    window.__TRAMVAI_INLINE_REPORTER?.send?.('html-opened', { ...payload });
+};
+
+export { htmlOpenedMonitoringScript };

package/lib/inlineReporters/events/htmlOpenedMonitoringScript.inline.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const htmlOpenedMonitoringScript = (payload) => {
+    window.__TRAMVAI_INLINE_REPORTER?.send?.('html-opened', { ...payload });
+};
+
+exports.htmlOpenedMonitoringScript = htmlOpenedMonitoringScript;

package/lib/inlineReporters/events/index.d.ts

@@ -0,0 +1,4 @@
+export * from './appCreationMonitoringScript.inline';
+export * from './errorMonitoringScript.inline';
+export * from './htmlOpenedMonitoringScript.inline';
+//# sourceMappingURL=index.d.ts.map

package/lib/server.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './tokens';
+export declare const ApplicationMonitoringModule: import("@tinkoff/dippy/lib/modules/module.h").ModuleClass & Partial<import("@tinkoff/dippy/lib/modules/module.h").ModuleSecretParameters> & {
+    [x: string]: (...args: any[]) => import("@tramvai/core").ModuleType;
+};
+//# sourceMappingURL=server.d.ts.map

package/lib/server.es.js

@@ -0,0 +1,76 @@
+import { declareModule, provide } from '@tramvai/core';
+import { RENDER_SLOTS, ResourceSlot, ResourceType } from '@tramvai/tokens-render';
+import { LOGGER_TOKEN } from '@tramvai/module-common';
+import { INLINE_REPORTER_PARAMETERS_TOKEN, INLINE_REPORTER_FACTORY_SCRIPT_TOKEN } from './tokens.es.js';
+export { INLINE_REPORTER_FACTORY_SCRIPT_TOKEN, INLINE_REPORTER_PARAMETERS_TOKEN } from './tokens.es.js';
+import { appCreationMonitoringScript } from './inlineReporters/events/appCreationMonitoringScript.inline.es.js';
+import { errorMonitoringScript } from './inlineReporters/events/errorMonitoringScript.inline.es.js';
+import { htmlOpenedMonitoringScript } from './inlineReporters/events/htmlOpenedMonitoringScript.inline.es.js';
+import { sharedProviders } from './sharedProviders.es.js';
+
+const ApplicationMonitoringModule = declareModule({
+    name: 'ApplicationMonitoringModule',
+    imports: [],
+    providers: [
+        ...sharedProviders,
+        provide({
+            provide: RENDER_SLOTS,
+            multi: true,
+            useFactory: ({ inlineReporterFactory, inlineReporterParameters, logger }) => {
+                const log = logger('application-monitoring');
+                if (!inlineReporterFactory) {
+                    log.debug('@tramvai/module-application-monitoring is on use but INLINE_REPORTER_FACTORY_SCRIPT_TOKEN token is not provided');
+                    return [];
+                }
+                return {
+                    slot: ResourceSlot.HEAD_PERFORMANCE,
+                    type: ResourceType.inlineScript,
+                    payload: `window.__TRAMVAI_INLINE_REPORTER = (${inlineReporterFactory})(${JSON.stringify(inlineReporterParameters)})`,
+                };
+            },
+            deps: {
+                logger: LOGGER_TOKEN,
+                inlineReporterParameters: INLINE_REPORTER_PARAMETERS_TOKEN,
+                inlineReporterFactory: {
+                    token: INLINE_REPORTER_FACTORY_SCRIPT_TOKEN,
+                    optional: true,
+                },
+            },
+        }),
+        provide({
+            provide: RENDER_SLOTS,
+            multi: true,
+            useFactory: () => {
+                return {
+                    slot: ResourceSlot.HEAD_PERFORMANCE,
+                    type: ResourceType.inlineScript,
+                    payload: `(${htmlOpenedMonitoringScript})()`,
+                };
+            },
+        }),
+        provide({
+            provide: RENDER_SLOTS,
+            multi: true,
+            useFactory: () => {
+                return {
+                    slot: ResourceSlot.HEAD_PERFORMANCE,
+                    type: ResourceType.inlineScript,
+                    payload: `(${errorMonitoringScript})()`,
+                };
+            },
+        }),
+        provide({
+            provide: RENDER_SLOTS,
+            multi: true,
+            useFactory: () => {
+                return {
+                    slot: ResourceSlot.HEAD_PERFORMANCE,
+                    type: ResourceType.inlineScript,
+                    payload: `(${appCreationMonitoringScript})()`,
+                };
+            },
+        }),
+    ],
+});
+
+export { ApplicationMonitoringModule };

package/lib/server.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var tokensRender = require('@tramvai/tokens-render');
+var moduleCommon = require('@tramvai/module-common');
+var tokens = require('./tokens.js');
+var appCreationMonitoringScript_inline = require('./inlineReporters/events/appCreationMonitoringScript.inline.js');
+var errorMonitoringScript_inline = require('./inlineReporters/events/errorMonitoringScript.inline.js');
+var htmlOpenedMonitoringScript_inline = require('./inlineReporters/events/htmlOpenedMonitoringScript.inline.js');
+var sharedProviders = require('./sharedProviders.js');
+
+const ApplicationMonitoringModule = core.declareModule({
+    name: 'ApplicationMonitoringModule',
+    imports: [],
+    providers: [
+        ...sharedProviders.sharedProviders,
+        core.provide({
+            provide: tokensRender.RENDER_SLOTS,
+            multi: true,
+            useFactory: ({ inlineReporterFactory, inlineReporterParameters, logger }) => {
+                const log = logger('application-monitoring');
+                if (!inlineReporterFactory) {
+                    log.debug('@tramvai/module-application-monitoring is on use but INLINE_REPORTER_FACTORY_SCRIPT_TOKEN token is not provided');
+                    return [];
+                }
+                return {
+                    slot: tokensRender.ResourceSlot.HEAD_PERFORMANCE,
+                    type: tokensRender.ResourceType.inlineScript,
+                    payload: `window.__TRAMVAI_INLINE_REPORTER = (${inlineReporterFactory})(${JSON.stringify(inlineReporterParameters)})`,
+                };
+            },
+            deps: {
+                logger: moduleCommon.LOGGER_TOKEN,
+                inlineReporterParameters: tokens.INLINE_REPORTER_PARAMETERS_TOKEN,
+                inlineReporterFactory: {
+                    token: tokens.INLINE_REPORTER_FACTORY_SCRIPT_TOKEN,
+                    optional: true,
+                },
+            },
+        }),
+        core.provide({
+            provide: tokensRender.RENDER_SLOTS,
+            multi: true,
+            useFactory: () => {
+                return {
+                    slot: tokensRender.ResourceSlot.HEAD_PERFORMANCE,
+                    type: tokensRender.ResourceType.inlineScript,
+                    payload: `(${htmlOpenedMonitoringScript_inline.htmlOpenedMonitoringScript})()`,
+                };
+            },
+        }),
+        core.provide({
+            provide: tokensRender.RENDER_SLOTS,
+            multi: true,
+            useFactory: () => {
+                return {
+                    slot: tokensRender.ResourceSlot.HEAD_PERFORMANCE,
+                    type: tokensRender.ResourceType.inlineScript,
+                    payload: `(${errorMonitoringScript_inline.errorMonitoringScript})()`,
+                };
+            },
+        }),
+        core.provide({
+            provide: tokensRender.RENDER_SLOTS,
+            multi: true,
+            useFactory: () => {
+                return {
+                    slot: tokensRender.ResourceSlot.HEAD_PERFORMANCE,
+                    type: tokensRender.ResourceType.inlineScript,
+                    payload: `(${appCreationMonitoringScript_inline.appCreationMonitoringScript})()`,
+                };
+            },
+        }),
+    ],
+});
+
+exports.INLINE_REPORTER_FACTORY_SCRIPT_TOKEN = tokens.INLINE_REPORTER_FACTORY_SCRIPT_TOKEN;
+exports.INLINE_REPORTER_PARAMETERS_TOKEN = tokens.INLINE_REPORTER_PARAMETERS_TOKEN;
+exports.ApplicationMonitoringModule = ApplicationMonitoringModule;

package/lib/sharedProviders.browser.js

@@ -0,0 +1,77 @@
+import { LOGGER_TOKEN, ENV_MANAGER_TOKEN } from '@tramvai/module-common';
+import { provide, commandLineListTokens, TRAMVAI_HOOKS_TOKEN, APP_INFO_TOKEN } from '@tramvai/core';
+import { INLINE_REPORTER_PARAMETERS_TOKEN } from './tokens.browser.js';
+import { LOGGER_NAME } from './constants.browser.js';
+
+const sharedProviders = [
+    provide({
+        provide: commandLineListTokens.init,
+        useFactory: ({ logger, tramvaiHooks }) => {
+            const log = logger({
+                name: LOGGER_NAME,
+                defaults: {
+                    remote: true,
+                },
+            });
+            return function applicationHealthSubscribe() {
+                let applicationRenderFinished = false;
+                tramvaiHooks['app:initialized'].tap('application-health', () => {
+                    log.info({ event: 'app:initialized' });
+                });
+                tramvaiHooks['app:initialize-failed'].tap('application-health', () => {
+                    log.info({ event: 'app:initialized-failed' });
+                });
+                tramvaiHooks['app:rendered'].tap('application-health', () => {
+                    log.info({ event: 'app:rendered' });
+                    if (!applicationRenderFinished) {
+                        applicationRenderFinished = true;
+                    }
+                });
+                tramvaiHooks['react:render'].tap('application-health', () => {
+                    log.info({ event: 'react:render' });
+                    if (!applicationRenderFinished) {
+                        applicationRenderFinished = true;
+                        tramvaiHooks['app:rendered'].call({});
+                    }
+                });
+                tramvaiHooks['app:render-failed'].tap('application-health', (_, { error }) => {
+                    log.error({ event: 'app:initialized', error });
+                });
+                tramvaiHooks['react:error'].tap('application-health', (_, { event, error, errorInfo, otherErrors }) => {
+                    log.error({ event: 'react:error', error, errorInfo, otherErrors });
+                    switch (event) {
+                        case 'page-error-boundary':
+                        case 'hydrate:on-uncaught-error':
+                        case 'hydrate:failed': {
+                            if (!applicationRenderFinished) {
+                                applicationRenderFinished = true;
+                                tramvaiHooks['app:render-failed'].call({ error });
+                            }
+                            break;
+                        }
+                    }
+                });
+            };
+        },
+        deps: {
+            logger: LOGGER_TOKEN,
+            tramvaiHooks: TRAMVAI_HOOKS_TOKEN,
+        },
+    }),
+    provide({
+        provide: INLINE_REPORTER_PARAMETERS_TOKEN,
+        useFactory: ({ appInfo, envManager }) => {
+            return {
+                appName: appInfo.appName,
+                appRelease: envManager.get('APP_RELEASE'),
+                appVersion: envManager.get('APP_VERSION'),
+            };
+        },
+        deps: {
+            envManager: ENV_MANAGER_TOKEN,
+            appInfo: APP_INFO_TOKEN,
+        },
+    }),
+];
+
+export { sharedProviders };

package/lib/sharedProviders.d.ts

@@ -0,0 +1,26 @@
+export declare const sharedProviders: (import("@tramvai/core").Provider<{
+    logger: import("@tramvai/module-common").Logger & ((configOrName: string | {
+        [key: string]: any;
+        name: string;
+    }) => import("@tramvai/module-common").Logger) & {
+        __type?: "base token" | undefined;
+    };
+    tramvaiHooks: import("@tramvai/core").TramvaiHooks & {
+        __type?: "base token" | undefined;
+    };
+}, import("@tramvai/core").Command & {
+    __type?: "multi token" | undefined;
+}> | import("@tramvai/core").Provider<{
+    envManager: import("@tramvai/module-common").EnvironmentManager & {
+        __type?: "base token" | undefined;
+    };
+    appInfo: {
+        [key: string]: string;
+        appName: string;
+    } & {
+        __type?: "base token" | undefined;
+    };
+}, import("./types").InlineReporterParameters & {
+    __type?: "base token" | undefined;
+}>)[];
+//# sourceMappingURL=sharedProviders.d.ts.map

package/lib/sharedProviders.es.js

@@ -0,0 +1,77 @@
+import { LOGGER_TOKEN, ENV_MANAGER_TOKEN } from '@tramvai/module-common';
+import { provide, commandLineListTokens, TRAMVAI_HOOKS_TOKEN, APP_INFO_TOKEN } from '@tramvai/core';
+import { INLINE_REPORTER_PARAMETERS_TOKEN } from './tokens.es.js';
+import { LOGGER_NAME } from './constants.es.js';
+
+const sharedProviders = [
+    provide({
+        provide: commandLineListTokens.init,
+        useFactory: ({ logger, tramvaiHooks }) => {
+            const log = logger({
+                name: LOGGER_NAME,
+                defaults: {
+                    remote: true,
+                },
+            });
+            return function applicationHealthSubscribe() {
+                let applicationRenderFinished = false;
+                tramvaiHooks['app:initialized'].tap('application-health', () => {
+                    log.info({ event: 'app:initialized' });
+                });
+                tramvaiHooks['app:initialize-failed'].tap('application-health', () => {
+                    log.info({ event: 'app:initialized-failed' });
+                });
+                tramvaiHooks['app:rendered'].tap('application-health', () => {
+                    log.info({ event: 'app:rendered' });
+                    if (!applicationRenderFinished) {
+                        applicationRenderFinished = true;
+                    }
+                });
+                tramvaiHooks['react:render'].tap('application-health', () => {
+                    log.info({ event: 'react:render' });
+                    if (!applicationRenderFinished) {
+                        applicationRenderFinished = true;
+                        tramvaiHooks['app:rendered'].call({});
+                    }
+                });
+                tramvaiHooks['app:render-failed'].tap('application-health', (_, { error }) => {
+                    log.error({ event: 'app:initialized', error });
+                });
+                tramvaiHooks['react:error'].tap('application-health', (_, { event, error, errorInfo, otherErrors }) => {
+                    log.error({ event: 'react:error', error, errorInfo, otherErrors });
+                    switch (event) {
+                        case 'page-error-boundary':
+                        case 'hydrate:on-uncaught-error':
+                        case 'hydrate:failed': {
+                            if (!applicationRenderFinished) {
+                                applicationRenderFinished = true;
+                                tramvaiHooks['app:render-failed'].call({ error });
+                            }
+                            break;
+                        }
+                    }
+                });
+            };
+        },
+        deps: {
+            logger: LOGGER_TOKEN,
+            tramvaiHooks: TRAMVAI_HOOKS_TOKEN,
+        },
+    }),
+    provide({
+        provide: INLINE_REPORTER_PARAMETERS_TOKEN,
+        useFactory: ({ appInfo, envManager }) => {
+            return {
+                appName: appInfo.appName,
+                appRelease: envManager.get('APP_RELEASE'),
+                appVersion: envManager.get('APP_VERSION'),
+            };
+        },
+        deps: {
+            envManager: ENV_MANAGER_TOKEN,
+            appInfo: APP_INFO_TOKEN,
+        },
+    }),
+];
+
+export { sharedProviders };

package/lib/sharedProviders.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var moduleCommon = require('@tramvai/module-common');
+var core = require('@tramvai/core');
+var tokens = require('./tokens.js');
+var constants = require('./constants.js');
+
+const sharedProviders = [
+    core.provide({
+        provide: core.commandLineListTokens.init,
+        useFactory: ({ logger, tramvaiHooks }) => {
+            const log = logger({
+                name: constants.LOGGER_NAME,
+                defaults: {
+                    remote: true,
+                },
+            });
+            return function applicationHealthSubscribe() {
+                let applicationRenderFinished = false;
+                tramvaiHooks['app:initialized'].tap('application-health', () => {
+                    log.info({ event: 'app:initialized' });
+                });
+                tramvaiHooks['app:initialize-failed'].tap('application-health', () => {
+                    log.info({ event: 'app:initialized-failed' });
+                });
+                tramvaiHooks['app:rendered'].tap('application-health', () => {
+                    log.info({ event: 'app:rendered' });
+                    if (!applicationRenderFinished) {
+                        applicationRenderFinished = true;
+                    }
+                });
+                tramvaiHooks['react:render'].tap('application-health', () => {
+                    log.info({ event: 'react:render' });
+                    if (!applicationRenderFinished) {
+                        applicationRenderFinished = true;
+                        tramvaiHooks['app:rendered'].call({});
+                    }
+                });
+                tramvaiHooks['app:render-failed'].tap('application-health', (_, { error }) => {
+                    log.error({ event: 'app:initialized', error });
+                });
+                tramvaiHooks['react:error'].tap('application-health', (_, { event, error, errorInfo, otherErrors }) => {
+                    log.error({ event: 'react:error', error, errorInfo, otherErrors });
+                    switch (event) {
+                        case 'page-error-boundary':
+                        case 'hydrate:on-uncaught-error':
+                        case 'hydrate:failed': {
+                            if (!applicationRenderFinished) {
+                                applicationRenderFinished = true;
+                                tramvaiHooks['app:render-failed'].call({ error });
+                            }
+                            break;
+                        }
+                    }
+                });
+            };
+        },
+        deps: {
+            logger: moduleCommon.LOGGER_TOKEN,
+            tramvaiHooks: core.TRAMVAI_HOOKS_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokens.INLINE_REPORTER_PARAMETERS_TOKEN,
+        useFactory: ({ appInfo, envManager }) => {
+            return {
+                appName: appInfo.appName,
+                appRelease: envManager.get('APP_RELEASE'),
+                appVersion: envManager.get('APP_VERSION'),
+            };
+        },
+        deps: {
+            envManager: moduleCommon.ENV_MANAGER_TOKEN,
+            appInfo: core.APP_INFO_TOKEN,
+        },
+    }),
+];
+
+exports.sharedProviders = sharedProviders;

package/lib/tokens.browser.js

@@ -0,0 +1,6 @@
+import { createToken } from '@tinkoff/dippy';
+
+const INLINE_REPORTER_PARAMETERS_TOKEN = createToken('INLINE_REPORTER_PARAMETERS_TOKEN');
+const INLINE_REPORTER_FACTORY_SCRIPT_TOKEN = createToken('INLINE_REPORTER_FACTORY_SCRIPT');
+
+export { INLINE_REPORTER_FACTORY_SCRIPT_TOKEN, INLINE_REPORTER_PARAMETERS_TOKEN };

package/lib/tokens.d.ts

@@ -0,0 +1,8 @@
+import type { InlineReporterParameters, TramvaiInlineReporter } from './types';
+export declare const INLINE_REPORTER_PARAMETERS_TOKEN: InlineReporterParameters & {
+    __type?: "base token" | undefined;
+};
+export declare const INLINE_REPORTER_FACTORY_SCRIPT_TOKEN: ((inlineReporterParameters: InlineReporterParameters) => TramvaiInlineReporter) & {
+    __type?: "base token" | undefined;
+};
+//# sourceMappingURL=tokens.d.ts.map

package/lib/tokens.es.js

@@ -0,0 +1,6 @@
+import { createToken } from '@tinkoff/dippy';
+
+const INLINE_REPORTER_PARAMETERS_TOKEN = createToken('INLINE_REPORTER_PARAMETERS_TOKEN');
+const INLINE_REPORTER_FACTORY_SCRIPT_TOKEN = createToken('INLINE_REPORTER_FACTORY_SCRIPT');
+
+export { INLINE_REPORTER_FACTORY_SCRIPT_TOKEN, INLINE_REPORTER_PARAMETERS_TOKEN };

package/lib/tokens.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dippy = require('@tinkoff/dippy');
+
+const INLINE_REPORTER_PARAMETERS_TOKEN = dippy.createToken('INLINE_REPORTER_PARAMETERS_TOKEN');
+const INLINE_REPORTER_FACTORY_SCRIPT_TOKEN = dippy.createToken('INLINE_REPORTER_FACTORY_SCRIPT');
+
+exports.INLINE_REPORTER_FACTORY_SCRIPT_TOKEN = INLINE_REPORTER_FACTORY_SCRIPT_TOKEN;
+exports.INLINE_REPORTER_PARAMETERS_TOKEN = INLINE_REPORTER_PARAMETERS_TOKEN;

package/lib/types.d.ts

@@ -0,0 +1,17 @@
+declare global {
+    interface Window {
+        __TRAMVAI_INLINE_REPORTER: TramvaiInlineReporter;
+    }
+}
+export interface TramvaiInlineReporter {
+    send(eventName: string, payload?: {
+        [key: string]: any;
+    }): void;
+}
+export interface InlineReporterParameters {
+    appName: string;
+    appVersion: string | undefined;
+    appRelease: string | undefined;
+    [x: string]: any;
+}
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@tramvai/module-application-monitoring",
+  "version": "6.80.6",
+  "description": "Модуль сбора и отправки событий мониторинга состояния приложения",
+  "browser": "lib/browser.js",
+  "main": "lib/server.js",
+  "module": "lib/server.es.js",
+  "typings": "lib/server.d.ts",
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/tramvaijs/tramvai.git"
+  },
+  "scripts": {
+    "build": "tramvai-build --forPublish --preserveModules",
+    "watch": "tsc -w"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@tramvai/module-common": "6.80.6",
+    "@tramvai/tokens-render": "6.80.6"
+  },
+  "peerDependencies": {
+    "@tinkoff/dippy": "^1.0.0",
+    "@tramvai/core": "6.80.6",
+    "@tramvai/react": "6.80.6",
+    "tslib": "^2.4.0"
+  }
+}