@tramvai/module-log 3.5.0 → 3.9.0

package/lib/browser.js

@@ -1,7 +1,7 @@
 import { __decorate } from 'tslib';
 import { createLoggerFactory, BrowserReporter } from '@tinkoff/logger';
-import { Module } from '@tramvai/core';
-import { LOGGER_TOKEN, LOGGER_INIT_HOOK } from '@tramvai/tokens-common';
+import { Module, provide, Scope, optional } from '@tramvai/core';
+import { LOGGER_TOKEN, LOGGER_INIT_HOOK, LOGGER_SHARED_CONTEXT, LOGGER_REMOTE_REPORTER } from '@tramvai/tokens-common';
 export { LOGGER_TOKEN } from '@tramvai/tokens-common';
 import { LOGGER_NAME, LOGGER_KEY } from './constants.browser.js';
 import { clientProviders } from './devLogs.browser.js';
@@ -18,7 +18,7 @@ LogModule = __decorate([
     Module({
         providers: [
             ...(process.env.NODE_ENV === 'development' ? clientProviders : []),
-            {
+            provide({
                 provide: LOGGER_TOKEN,
                 useFactory({ loggerInitHooks }) {
                     if (loggerInitHooks) {
@@ -31,7 +31,26 @@ LogModule = __decorate([
                 deps: {
                     loggerInitHooks: { token: LOGGER_INIT_HOOK, multi: true, optional: true },
                 },
-            },
+            }),
+            provide({
+                provide: LOGGER_SHARED_CONTEXT,
+                scope: Scope.SINGLETON,
+                useValue: new Map(),
+            }),
+            provide({
+                provide: LOGGER_INIT_HOOK,
+                multi: true,
+                useFactory({ remoteReporter }) {
+                    return (loggerInstance) => {
+                        if (remoteReporter) {
+                            loggerInstance.addReporter(remoteReporter);
+                        }
+                    };
+                },
+                deps: {
+                    remoteReporter: optional(LOGGER_REMOTE_REPORTER),
+                },
+            }),
         ],
     })
 ], LogModule);

package/lib/devLogs.browser.js

@@ -153,8 +153,6 @@ const clientProviders = [
                 const logs = store.getState(LogStore);
                 const ssrLogger = logger({
                     name: 'ssr-logger',
-                    // сетим пустой массив в beforeReporters, чтобы не подтягивать настройки рутового логгера с RemoteReporter
-                    beforeReporters: [],
                     reporters: [new BrowserReporter()],
                     extensions: [new DevLogsExtension(logs)],
                 });

package/lib/devLogs.es.js

@@ -153,8 +153,6 @@ const flushLogs = (ssrLogger, logs) => {
                 const logs = store.getState(LogStore);
                 const ssrLogger = logger({
                     name: 'ssr-logger',
-                    // сетим пустой массив в beforeReporters, чтобы не подтягивать настройки рутового логгера с RemoteReporter
-                    beforeReporters: [],
                     reporters: [new BrowserReporter()],
                     extensions: [new DevLogsExtension(logs)],
                 });

package/lib/devLogs.js

@@ -162,8 +162,6 @@ const flushLogs = (ssrLogger, logs) => {
                 const logs = store.getState(LogStore.LogStore);
                 const ssrLogger = logger$1({
                     name: 'ssr-logger',
-                    // сетим пустой массив в beforeReporters, чтобы не подтягивать настройки рутового логгера с RemoteReporter
-                    beforeReporters: [],
                     reporters: [new logger.BrowserReporter()],
                     extensions: [new DevLogsExtension(logs)],
                 });

package/lib/server.d.ts

@@ -1,4 +1,5 @@
 import { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import './types';
 export * from './LogStore';
 export { LOGGER_TOKEN };
 declare const logger: import("@tinkoff/logger").Factory;

package/lib/server.es.js

@@ -3,8 +3,8 @@ import each from '@tinkoff/utils/array/each';
 import split from '@tinkoff/utils/string/split';
 import { hostname } from 'os';
 import env from 'std-env';
-import { Module, Scope } from '@tramvai/core';
-import { LOGGER_TOKEN, LOGGER_INIT_HOOK } from '@tramvai/tokens-common';
+import { Module, Scope, provide } from '@tramvai/core';
+import { LOGGER_TOKEN, LOGGER_INIT_HOOK, ASYNC_LOCAL_STORAGE_TOKEN, LOGGER_SHARED_CONTEXT } from '@tramvai/tokens-common';
 export { LOGGER_TOKEN } from '@tramvai/tokens-common';
 import { ENV_USED_TOKEN } from '@tramvai/module-environment';
 import { NodeBasicReporter, NodeDevReporter, JSONReporter, createLoggerFactory, LEVELS } from '@tinkoff/logger';
@@ -49,6 +49,32 @@ function factory({ environmentManager, loggerInitHooks }) {
     }
     return logger;
 }
+/**
+ * At server-side, when using LOGGER_SHARED_CONTEXT, new properties will be stored in current
+ * AsyncLocalStorage context (which is unique for each user request).
+ * This extension will read current properties from context, it allows us to automatically bind
+ * user-specific properties (user-agent, ip, etc.) to all logs, called in complete different places in application code.
+ */
+class LoggerSharedContextExtension {
+    constructor({ storage }) {
+        this.storage = storage;
+    }
+    extend(logObj) {
+        var _a;
+        const state = (_a = this.storage.getStore()) === null || _a === void 0 ? void 0 : _a.logger;
+        if (state) {
+            state.forEach((value, key) => {
+                const keyExist = key in logObj;
+                const valueIsNotEmpty = typeof value !== 'undefined';
+                if (!keyExist && valueIsNotEmpty) {
+                    // eslint-disable-next-line no-param-reassign
+                    logObj[key] = value;
+                }
+            });
+        }
+        return logObj;
+    }
+}
 let LogModule = class LogModule {
 };
 LogModule = __decorate([
@@ -82,6 +108,45 @@ LogModule = __decorate([
                 ],
                 multi: true,
             },
+            provide({
+                provide: LOGGER_INIT_HOOK,
+                multi: true,
+                scope: Scope.SINGLETON,
+                useFactory: ({ storage }) => {
+                    const loggerSharedContextExtension = new LoggerSharedContextExtension({ storage });
+                    return (loggerInstance) => {
+                        return loggerInstance.addExtension(loggerSharedContextExtension);
+                    };
+                },
+                deps: {
+                    storage: ASYNC_LOCAL_STORAGE_TOKEN,
+                },
+            }),
+            provide({
+                provide: LOGGER_SHARED_CONTEXT,
+                scope: Scope.SINGLETON,
+                useFactory: ({ storage }) => {
+                    return {
+                        get(key) {
+                            var _a, _b;
+                            return (_b = (_a = storage.getStore()) === null || _a === void 0 ? void 0 : _a.logger) === null || _b === void 0 ? void 0 : _b.get(key);
+                        },
+                        set(key, value) {
+                            const store = storage.getStore();
+                            if (!store) {
+                                return;
+                            }
+                            if (!(store === null || store === void 0 ? void 0 : store.logger)) {
+                                store.logger = new Map();
+                            }
+                            store.logger.set(key, value);
+                        },
+                    };
+                },
+                deps: {
+                    storage: ASYNC_LOCAL_STORAGE_TOKEN,
+                },
+            }),
         ],
     })
 ], LogModule);

package/lib/server.js

@@ -58,6 +58,32 @@ function factory({ environmentManager, loggerInitHooks }) {
     }
     return logger;
 }
+/**
+ * At server-side, when using LOGGER_SHARED_CONTEXT, new properties will be stored in current
+ * AsyncLocalStorage context (which is unique for each user request).
+ * This extension will read current properties from context, it allows us to automatically bind
+ * user-specific properties (user-agent, ip, etc.) to all logs, called in complete different places in application code.
+ */
+class LoggerSharedContextExtension {
+    constructor({ storage }) {
+        this.storage = storage;
+    }
+    extend(logObj) {
+        var _a;
+        const state = (_a = this.storage.getStore()) === null || _a === void 0 ? void 0 : _a.logger;
+        if (state) {
+            state.forEach((value, key) => {
+                const keyExist = key in logObj;
+                const valueIsNotEmpty = typeof value !== 'undefined';
+                if (!keyExist && valueIsNotEmpty) {
+                    // eslint-disable-next-line no-param-reassign
+                    logObj[key] = value;
+                }
+            });
+        }
+        return logObj;
+    }
+}
 exports.LogModule = class LogModule {
 };
 exports.LogModule = tslib.__decorate([
@@ -91,6 +117,45 @@ exports.LogModule = tslib.__decorate([
                 ],
                 multi: true,
             },
+            core.provide({
+                provide: tokensCommon.LOGGER_INIT_HOOK,
+                multi: true,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ storage }) => {
+                    const loggerSharedContextExtension = new LoggerSharedContextExtension({ storage });
+                    return (loggerInstance) => {
+                        return loggerInstance.addExtension(loggerSharedContextExtension);
+                    };
+                },
+                deps: {
+                    storage: tokensCommon.ASYNC_LOCAL_STORAGE_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: tokensCommon.LOGGER_SHARED_CONTEXT,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ storage }) => {
+                    return {
+                        get(key) {
+                            var _a, _b;
+                            return (_b = (_a = storage.getStore()) === null || _a === void 0 ? void 0 : _a.logger) === null || _b === void 0 ? void 0 : _b.get(key);
+                        },
+                        set(key, value) {
+                            const store = storage.getStore();
+                            if (!store) {
+                                return;
+                            }
+                            if (!(store === null || store === void 0 ? void 0 : store.logger)) {
+                                store.logger = new Map();
+                            }
+                            store.logger.set(key, value);
+                        },
+                    };
+                },
+                deps: {
+                    storage: tokensCommon.ASYNC_LOCAL_STORAGE_TOKEN,
+                },
+            }),
         ],
     })
 ], exports.LogModule);

package/lib/types.d.ts

@@ -0,0 +1,7 @@
+import '@tramvai/tokens-common';
+declare module '@tramvai/tokens-common' {
+    interface AsyncLocalStorageState {
+        logger?: Map<string, any>;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-log",
-  "version": "3.5.0",
+  "version": "3.9.0",
   "description": "",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -18,16 +18,16 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@tinkoff/logger": "0.10.168"
+    "@tinkoff/logger": "0.10.169"
   },
   "peerDependencies": {
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/core": "3.5.0",
-    "@tramvai/module-environment": "3.5.0",
-    "@tramvai/papi": "3.5.0",
-    "@tramvai/state": "3.5.0",
-    "@tramvai/tokens-common": "3.5.0",
-    "@tramvai/tokens-server": "3.5.0",
+    "@tramvai/core": "3.9.0",
+    "@tramvai/module-environment": "3.9.0",
+    "@tramvai/papi": "3.9.0",
+    "@tramvai/state": "3.9.0",
+    "@tramvai/tokens-common": "3.9.0",
+    "@tramvai/tokens-server": "3.9.0",
     "std-env": "^2.2.1",
     "tslib": "^2.4.0"
   },