feat: 3.2.0 release

dist/lib/index.d.ts

@@ -1,3 +1,4 @@
 export { LoggedRoute, LoggedFunction, LoggedController, LoggedInjectable, LoggedGuard, LoggedInterceptor, } from "./logged";
 export { ScopedLogger } from "./logger";
 export { InjectLogger, LoggedParam, LoggedHeaders, LoggedBody, LoggedQuery, Logged, Returns } from "./reflected";
+export { getRequestLogger } from './utils';

dist/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Returns = exports.Logged = exports.LoggedQuery = exports.LoggedBody = exports.LoggedHeaders = exports.LoggedParam = exports.InjectLogger = exports.ScopedLogger = exports.LoggedInterceptor = exports.LoggedGuard = exports.LoggedInjectable = exports.LoggedController = exports.LoggedFunction = exports.LoggedRoute = void 0;
+exports.getRequestLogger = exports.Returns = exports.Logged = exports.LoggedQuery = exports.LoggedBody = exports.LoggedHeaders = exports.LoggedParam = exports.InjectLogger = exports.ScopedLogger = exports.LoggedInterceptor = exports.LoggedGuard = exports.LoggedInjectable = exports.LoggedController = exports.LoggedFunction = exports.LoggedRoute = void 0;
 var logged_1 = require("./logged");
 Object.defineProperty(exports, "LoggedRoute", { enumerable: true, get: function () { return logged_1.LoggedRoute; } });
 Object.defineProperty(exports, "LoggedFunction", { enumerable: true, get: function () { return logged_1.LoggedFunction; } });
@@ -18,3 +18,5 @@ Object.defineProperty(exports, "LoggedBody", { enumerable: true, get: function (
 Object.defineProperty(exports, "LoggedQuery", { enumerable: true, get: function () { return reflected_1.LoggedQuery; } });
 Object.defineProperty(exports, "Logged", { enumerable: true, get: function () { return reflected_1.Logged; } });
 Object.defineProperty(exports, "Returns", { enumerable: true, get: function () { return reflected_1.Returns; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "getRequestLogger", { enumerable: true, get: function () { return utils_1.getRequestLogger; } });

dist/lib/logged.d.ts

@@ -18,8 +18,10 @@ interface OverrideBuildOptions {
     /** @deprecated use `errorLogLevel: 'skip'` instead */
     skipErrorLog: boolean;
 }
+export declare const REQUEST_LOG_ID = "__nestlogged_request_log_id__";
 export declare function LoggedFunction<F extends Array<any>, R>(options?: Partial<OverrideBuildOptions>): (_target: any, key: string, descriptor: TypedPropertyDescriptor<(...args: F) => R | Promise<R>>) => void;
 export declare function LoggedRoute<F extends Array<any>, R>(route?: string, options?: Partial<OverrideBuildOptions>): (_target: any, key: string, descriptor: TypedPropertyDescriptor<(...args: F) => R>) => void;
 export declare function LoggedGuard<F extends Array<any>, R>(options?: Partial<OverrideBuildOptions>): (_target: any, key: string, descriptor: TypedPropertyDescriptor<(context: ExecutionContext, ...args: F) => R>) => void;
 export declare function LoggedInterceptor<F extends Array<any>, R>(options?: Partial<OverrideBuildOptions>): (_target: any, key: string, descriptor: TypedPropertyDescriptor<(context: ExecutionContext, ...args: F) => R>) => void;
+export declare function LoggedMiddleware<F extends Array<any>, R>(options?: Partial<OverrideBuildOptions>): (_target: any, key: string, descriptor: TypedPropertyDescriptor<(context: ExecutionContext, ...args: F) => R>) => void;
 export {};

dist/lib/logged.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggedInterceptor = exports.LoggedGuard = exports.LoggedRoute = exports.LoggedFunction = exports.LoggedController = exports.LoggedInjectable = void 0;
+exports.LoggedMiddleware = exports.LoggedInterceptor = exports.LoggedGuard = exports.LoggedRoute = exports.LoggedFunction = exports.REQUEST_LOG_ID = exports.LoggedController = exports.LoggedInjectable = void 0;
 const common_1 = require("@nestjs/common");
 const logger_1 = require("./logger");
 const reflected_1 = require("./reflected");
@@ -95,19 +95,28 @@ class LoggedMetadata {
     }
 }
 const callLogIdentifyMessageDictionary = {
-    route: 'HIT HTTP',
+    route: 'ENDPOINT',
-    function: 'CALL',
+    function: 'FUNCTION',
-    guard: 'HIT GUARD',
+    guard: 'GUARD',
-    interceptor: 'HIT INTERCEPTOR'
+    interceptor: 'INTERCEPTOR',
+    middleware: 'MIDDLEWARE',
 };
-function createCallLogIdentifyMessage(type, key, route) {
+function createCallLogIdentifyMessage(message, type, key, route) {
-    return `${callLogIdentifyMessageDictionary[type]} ${type === 'route' ? `${route} (${key})` : type === 'guard' ? `${route}` : key}`;
+    if (message === 'ERROR')
+        return `ERROR WHILE ${callLogIdentifyMessageDictionary[type]} ${key} (${route}): `;
+    if (type === 'guard' || type === 'interceptor' || type === 'middleware' || type === 'route')
+        return `${message} ${callLogIdentifyMessageDictionary[type]} ${key} (${route})`;
+    if (type === 'function')
+        return `${message} ${callLogIdentifyMessageDictionary[type]} ${key}`;
+    return `${message} ${callLogIdentifyMessageDictionary[type]}`;
 }
+exports.REQUEST_LOG_ID = '__nestlogged_request_log_id__';
 function overrideBuild(type, originalFunction, baseLogger, metadatas, key, returnsData, logged, route) {
     return function (...args) {
         // Creating ScopedLogger
         let injectedLogger = baseLogger;
         if (typeof metadatas.scopedLoggerInjectableParam !== "undefined") {
+            if (type === 'function') {
                 if (args.length <= metadatas.scopedLoggerInjectableParam ||
                     !(args[metadatas.scopedLoggerInjectableParam] instanceof logger_1.ScopedLogger)) {
                     args[metadatas.scopedLoggerInjectableParam] = logger_1.ScopedLogger.fromRoot(baseLogger, key);
@@ -115,19 +124,54 @@ function overrideBuild(type, originalFunction, baseLogger, metadatas, key, retur
                 else {
                     args[metadatas.scopedLoggerInjectableParam] = logger_1.ScopedLogger.fromSuper(baseLogger, args[metadatas.scopedLoggerInjectableParam], key);
                 }
+            }
+            else {
+                // special, can access to request object
+                if (type === 'guard' || type === 'interceptor') {
+                    // args[0] == ExecutionContext
+                    const ctx = args[0];
+                    if (ctx.getType() !== 'http') {
+                        injectedLogger.error('Cannot inject logger: Request type is not http');
+                    }
+                    else {
+                        let req = ctx.switchToHttp().getRequest();
+                        if (req[exports.REQUEST_LOG_ID] === undefined) {
+                            req[exports.REQUEST_LOG_ID] = logger_1.ScopedLogger.createScopeId();
+                        }
+                        args[metadatas.scopedLoggerInjectableParam] = logger_1.ScopedLogger.fromRoot(baseLogger, key, req[exports.REQUEST_LOG_ID]);
+                    }
+                }
+                else if (type === 'middleware') {
+                    let req = args[0];
+                    if (req[exports.REQUEST_LOG_ID] === undefined) {
+                        req[exports.REQUEST_LOG_ID] = logger_1.ScopedLogger.createScopeId();
+                    }
+                    args[metadatas.scopedLoggerInjectableParam] = logger_1.ScopedLogger.fromRoot(baseLogger, key, req[exports.REQUEST_LOG_ID]);
+                }
+                else if (type === 'route') {
+                    // args[metadatas.scopedLoggerInjectableParam] is now Request object, thanks to code in @LoggedRoute!!!!
+                    let req = args[metadatas.scopedLoggerInjectableParam];
+                    if (req[exports.REQUEST_LOG_ID] === undefined) {
+                        req[exports.REQUEST_LOG_ID] = logger_1.ScopedLogger.createScopeId();
+                    }
+                    args[metadatas.scopedLoggerInjectableParam] = logger_1.ScopedLogger.fromRoot(baseLogger, key, req[exports.REQUEST_LOG_ID]);
+                }
+            }
             injectedLogger = args[metadatas.scopedLoggerInjectableParam];
         }
         // If this is ExecutionContext based function (e.g. Guard, Interceptor) get Request from Context
-        if (type === 'guard') {
+        if (type === 'guard' || type === 'interceptor') {
             const context = args[0];
             if (context.getType() === 'http') {
                 const req = context.switchToHttp().getRequest();
-                route = new URL(( /* supporting FastifyRequest */req.raw ? req.raw.url : req.url)).pathname;
+                route = /* supporting FastifyRequest */ req.raw ? req.raw.url : req.url;
             }
         }
         // Start Log
         if (logged.options.callLogLevel !== 'skip') {
-            const callLogIdentifyMessage = type === 'route' || type === 'guard' || type === 'interceptor' ? createCallLogIdentifyMessage(type, key, route) : createCallLogIdentifyMessage(type, key);
+            const callLogIdentifyMessage = type === 'middleware' || type === 'guard' || type === 'interceptor' || type === 'route'
+                ? createCallLogIdentifyMessage('HIT', type, key, route)
+                : createCallLogIdentifyMessage('HIT', type, key);
             injectedLogger[logged.options.callLogLevel](`${callLogIdentifyMessage} ${metadatas.loggedParams && metadatas.loggedParams.length > 0
                 ? "WITH " +
                     metadatas.loggedParams.map(({ name, index, include, exclude }) => name +
@@ -162,9 +206,7 @@ function overrideBuild(type, originalFunction, baseLogger, metadatas, key, retur
                                         ? "WITH " + JSON.stringify(r)
                                         : "WITH " + r
                                     : "";
-                        injectedLogger[logged.options.returnLogLevel](route
+                        injectedLogger[logged.options.returnLogLevel](`${createCallLogIdentifyMessage('RETURNED', type, key, route)} ${resultLogged}`);
-                            ? `RETURNED HTTP ${route} (${key}) ${resultLogged}`
-                            : `RETURNED ${key} ${resultLogged}`);
                         return r;
                     });
                 }
@@ -186,9 +228,7 @@ function overrideBuild(type, originalFunction, baseLogger, metadatas, key, retur
                                     ? "WITH " + JSON.stringify(r)
                                     : "WITH " + r
                                 : "";
-                    injectedLogger[logged.options.returnLogLevel](route
+                    injectedLogger[logged.options.returnLogLevel](`${createCallLogIdentifyMessage('RETURNED', type, key, route)} ${resultLogged}`);
-                        ? `RETURNED HTTP ${route} (${key}) ${resultLogged}`
-                        : `RETURNED ${key} ${resultLogged}`);
                     return r;
                 }
             }
@@ -199,7 +239,7 @@ function overrideBuild(type, originalFunction, baseLogger, metadatas, key, retur
         catch (e) {
             // Error Log
             if (logged.options.errorLogLevel !== 'skip') {
-                injectedLogger[logged.options.errorLogLevel](`WHILE ${route ? `HTTP ${route} (${key})` : key} ERROR ${e}`);
+                injectedLogger[logged.options.errorLogLevel](`${createCallLogIdentifyMessage('ERROR', type, key, route)} ${e}`);
             }
             throw e;
         }
@@ -266,6 +306,10 @@ function LoggedRoute(route, options) {
         const httpMethod = Reflect.getMetadata("method", fn);
         const fullRoute = `${_target.constructor.name}::${route ?? httpPath}[${RevRequestMethod[httpMethod]}]`;
         const scopedLoggerInjectableParam = Reflect.getOwnMetadata(reflected_1.scopedLogger, _target, key);
+        // if @InjectLogger exists, fake nestjs as it is @Req()
+        if (scopedLoggerInjectableParam !== undefined) {
+            (0, reflected_1.createRouteParamDecorator)(0)()(_target, key, scopedLoggerInjectableParam);
+        }
         const loggedParams = Reflect.getOwnMetadata(reflected_1.loggedParam, _target, key);
         const returnsData = Reflect.getOwnMetadata(reflected_1.returns, fn);
         const overrideFunction = overrideBuild('route', fn, logger, {
@@ -307,7 +351,7 @@ function LoggedGuard(options) {
         const overrideFunction = overrideBuild('guard', fn, logger, {
             scopedLoggerInjectableParam,
             loggedParams: [],
-        }, key, returnsData, newMetadata);
+        }, _target.constructor.name, returnsData, newMetadata);
         _target[key] = overrideFunction;
         descriptor.value = overrideFunction;
         Reflect.defineMetadata(reflected_1.nestLoggedMetadata, newMetadata, _target, key);
@@ -343,7 +387,7 @@ function LoggedInterceptor(options) {
         const overrideFunction = overrideBuild('interceptor', fn, logger, {
             scopedLoggerInjectableParam,
             loggedParams: [],
-        }, key, returnsData, newMetadata);
+        }, _target.constructor.name, returnsData, newMetadata);
         _target[key] = overrideFunction;
         descriptor.value = overrideFunction;
         Reflect.defineMetadata(reflected_1.nestLoggedMetadata, newMetadata, _target, key);
@@ -354,3 +398,39 @@ function LoggedInterceptor(options) {
     };
 }
 exports.LoggedInterceptor = LoggedInterceptor;
+function LoggedMiddleware(options) {
+    return (_target, key, descriptor) => {
+        loggerInit(_target);
+        const logger = _target.logger;
+        const fn = descriptor.value;
+        if (!fn || typeof fn !== "function") {
+            logger.warn(`LoggedMiddleware decorator applied to non-function property: ${key}`);
+            return;
+        }
+        const logMetadata = Reflect.getOwnMetadata(reflected_1.nestLoggedMetadata, _target, key);
+        if (logMetadata) {
+            // already applied, override instead
+            logMetadata.updateOption(options);
+            return;
+        }
+        const newMetadata = new LoggedMetadata(options);
+        const all = Reflect.getMetadataKeys(fn).map((k) => [
+            k,
+            Reflect.getMetadata(k, fn),
+        ]);
+        const scopedLoggerInjectableParam = Reflect.getOwnMetadata(reflected_1.scopedLogger, _target, key);
+        const returnsData = Reflect.getOwnMetadata(reflected_1.returns, fn);
+        const overrideFunction = overrideBuild('middleware', fn, logger, {
+            scopedLoggerInjectableParam,
+            loggedParams: [],
+        }, _target.constructor.name, returnsData, newMetadata);
+        _target[key] = overrideFunction;
+        descriptor.value = overrideFunction;
+        Reflect.defineMetadata(reflected_1.nestLoggedMetadata, newMetadata, _target, key);
+        all.forEach(([k, v]) => {
+            Reflect.defineMetadata(k, v, _target[key]);
+            Reflect.defineMetadata(k, v, descriptor.value);
+        });
+    };
+}
+exports.LoggedMiddleware = LoggedMiddleware;

dist/lib/logger.d.ts

@@ -12,5 +12,6 @@ export declare class ScopedLogger extends Logger {
     error: (message: string) => void;
     fatal: (message: string) => void;
     static fromSuper(baseLogger: Logger, logger: ScopedLogger, scope: string): ScopedLogger;
-    static fromRoot(logger: Logger, scope: string): ScopedLogger;
+    static fromRoot(logger: Logger, scope: string, scopeId?: string): ScopedLogger;
+    static createScopeId(): string;
 }

dist/lib/logger.js

@@ -26,9 +26,12 @@ class ScopedLogger extends common_1.Logger {
         return new ScopedLogger(baseLogger, [...logger.scope, scope], logger.scopeId);
     }
     ;
-    static fromRoot(logger, scope) {
+    static fromRoot(logger, scope, scopeId) {
-        return new ScopedLogger(logger, [scope]);
+        return new ScopedLogger(logger, [scope], scopeId);
     }
     ;
+    static createScopeId() {
+        return createId();
+    }
 }
 exports.ScopedLogger = ScopedLogger;

dist/lib/reflected.d.ts

@@ -1,4 +1,6 @@
-import { PipeTransform, Type } from "@nestjs/common";
+import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
+import { ParamData, PipeTransform, Type } from "@nestjs/common";
+export declare function createRouteParamDecorator(paramtype: RouteParamtypes): (data?: ParamData) => ParameterDecorator;
 export type Path = string | string[];
 export type Paths = Path[];
 export interface IncludeExcludePath {

dist/lib/reflected.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Returns = exports.LoggedHeaders = exports.LoggedBody = exports.LoggedQuery = exports.LoggedParam = exports.Logged = exports.InjectLogger = exports.nestLoggedMetadata = exports.returns = exports.loggedParam = exports.scopedLogger = void 0;
+exports.Returns = exports.LoggedHeaders = exports.LoggedBody = exports.LoggedQuery = exports.LoggedParam = exports.Logged = exports.InjectLogger = exports.nestLoggedMetadata = exports.returns = exports.loggedParam = exports.scopedLogger = exports.createRouteParamDecorator = void 0;
 const route_paramtypes_enum_1 = require("@nestjs/common/enums/route-paramtypes.enum");
 const common_1 = require("@nestjs/common");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
@@ -11,6 +11,7 @@ function createRouteParamDecorator(paramtype) {
         Reflect.defineMetadata(ROUTE_ARGS_METADATA, (0, common_1.assignMetadata)(args, paramtype, index, data), target.constructor, key);
     };
 }
+exports.createRouteParamDecorator = createRouteParamDecorator;
 const createPipesRouteParamDecorator = (paramtype) => (data, ...pipes) => (target, key, index) => {
     const args = Reflect.getMetadata(ROUTE_ARGS_METADATA, target.constructor, key) || {};
     const hasParamData = (0, shared_utils_1.isNil)(data) || (0, shared_utils_1.isString)(data);

dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { ScopedLogger } from "./logger";
+export declare function getRequestLogger(functionName: string, req: any): ScopedLogger;

dist/lib/utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequestLogger = void 0;
+const common_1 = require("@nestjs/common");
+const logger_1 = require("./logger");
+const logged_1 = require("./logged");
+const logger = new common_1.Logger();
+function getRequestLogger(functionName, req) {
+    return new logger_1.ScopedLogger(logger, [functionName], req[logged_1.REQUEST_LOG_ID]);
+}
+exports.getRequestLogger = getRequestLogger;

dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestlogged",
-  "version": "3.2.0-beta.1",
+  "version": "3.2.0",
   "description": "A NestJS Logger Decorator Library",
   "main": "lib/index.js",
   "repository": "https://git.psw.kr/p-sw/nestlogged",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestlogged",
-  "version": "3.2.0-beta.1",
+  "version": "3.2.0",
   "description": "A NestJS Logger Decorator Library",
   "main": "./dist/lib/index.js",
   "repository": "https://git.psw.kr/p-sw/nestlogged",

src/index.ts

@@ -16,3 +16,6 @@ export {
   Logged,
   Returns
 } from "./reflected";
+export {
+  getRequestLogger
+} from './utils'

src/logged.ts

@@ -14,7 +14,8 @@ import {
   returns,
   nestLoggedMetadata,
   loggedParam,
-  scopedLogger
+  scopedLogger,
+  createRouteParamDecorator
 } from "./reflected";
 import { imObjectContainedLogSync, getItemByPathSync } from "./functions";
 import { RequestMethod } from "@nestjs/common";
@@ -164,28 +165,26 @@ class LoggedMetadata {
 type BuildType = 'route' | 'function' | 'guard' | 'interceptor' | 'middleware';
 
 const callLogIdentifyMessageDictionary: Record<BuildType, string> = {
-  route: 'HIT HTTP',
+  route: 'ENDPOINT',
-  function: 'CALL',
+  function: 'FUNCTION',
-  guard: 'HIT GUARD',
+  guard: 'GUARD',
-  interceptor: 'HIT INTERCEPTOR',
+  interceptor: 'INTERCEPTOR',
-  middleware: 'HIT MIDDLEWARE',
+  middleware: 'MIDDLEWARE',
 }
 
-function createCallLogIdentifyMessage(type: 'route', key: string, route: string)
+function createCallLogIdentifyMessage(message: 'HIT' | 'RETURNED' | 'ERROR', type: BuildType, key?: string, route?: string) {
-function createCallLogIdentifyMessage(type: 'guard' | 'interceptor' | 'middleware', route: string)
+  if (message === 'ERROR')
-function createCallLogIdentifyMessage(type: 'function', key: string)
+    return `ERROR WHILE ${callLogIdentifyMessageDictionary[type]} ${key} (${route}): `;
-function createCallLogIdentifyMessage(type: BuildType, key?: string, route?: string) {
+
-  if (type === 'route') 
+  if (type === 'guard' || type === 'interceptor' || type === 'middleware' || type === 'route')
-    return `${callLogIdentifyMessageDictionary[type]} ${route} (${key})`
+    return `${message} ${callLogIdentifyMessageDictionary[type]} ${key} (${route})`
-  if (type === 'guard' || type === 'interceptor' || type === 'middleware')
-    return `${callLogIdentifyMessageDictionary[type]} ${route}`
   if (type === 'function')
-    return `${callLogIdentifyMessageDictionary[type]} ${key}`;
+    return `${message} ${callLogIdentifyMessageDictionary[type]} ${key}`;
 
-  return callLogIdentifyMessageDictionary[type];
+  return `${message} ${callLogIdentifyMessageDictionary[type]}`;
 }
 
-const REQUEST_LOG_ID = '__nestlogged_request_log_id__';
+export const REQUEST_LOG_ID = '__nestlogged_request_log_id__';
 
 function overrideBuild<F extends Array<any>, R>(
   type: 'route',
@@ -240,21 +239,22 @@ function overrideBuild<F extends Array<any>, R>(
             let req = ctx.switchToHttp().getRequest();
             if (req[REQUEST_LOG_ID] === undefined) {
               req[REQUEST_LOG_ID] = ScopedLogger.createScopeId();
-            } else {
-              args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(baseLogger, key, req[REQUEST_LOG_ID]);
             }
+            args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(baseLogger, key, req[REQUEST_LOG_ID]);
           }
         } else if (type === 'middleware') {
           let req = args[0];
           if (req[REQUEST_LOG_ID] === undefined) {
             req[REQUEST_LOG_ID] = ScopedLogger.createScopeId();
-          } else {
-            args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(baseLogger, key, req[REQUEST_LOG_ID]);
           }
+          args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(baseLogger, key, req[REQUEST_LOG_ID]);
         } else if (type === 'route') {
-          // should use @Req
+          // args[metadatas.scopedLoggerInjectableParam] is now Request object, thanks to code in @LoggedRoute!!!!
-          // WTF how should I get the request id from request object???????????????????????????????????????????????????????????????
+          let req = args[metadatas.scopedLoggerInjectableParam];
-          // FUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCKFUCK
+          if (req[REQUEST_LOG_ID] === undefined) {
+            req[REQUEST_LOG_ID] = ScopedLogger.createScopeId();
+          }
+          args[metadatas.scopedLoggerInjectableParam] = ScopedLogger.fromRoot(baseLogger, key, req[REQUEST_LOG_ID]);
         }
       }
 
@@ -266,13 +266,16 @@ function overrideBuild<F extends Array<any>, R>(
       const context = args[0] as ExecutionContext;
       if (context.getType() === 'http') {
         const req = context.switchToHttp().getRequest();
-        route = new URL(<string>(/* supporting FastifyRequest */ req.raw ? req.raw.url : req.url)).pathname;
+        route = /* supporting FastifyRequest */ req.raw ? req.raw.url : req.url;
       }
     }
 
     // Start Log
     if (logged.options.callLogLevel !== 'skip') {
-      const callLogIdentifyMessage = type === 'route' || type === 'guard' || type === 'interceptor' ? createCallLogIdentifyMessage(type, key, route) : createCallLogIdentifyMessage(type, key)
+      const callLogIdentifyMessage = 
+        type === 'middleware' || type === 'guard' || type === 'interceptor' || type === 'route'
+          ? createCallLogIdentifyMessage('HIT', type, key, route)
+          : createCallLogIdentifyMessage('HIT', type, key);
       injectedLogger[logged.options.callLogLevel](
         `${callLogIdentifyMessage} ${metadatas.loggedParams && metadatas.loggedParams.length > 0
           ? "WITH " +
@@ -319,11 +322,7 @@ function overrideBuild<F extends Array<any>, R>(
                     : "WITH " + r
                   : "";
 
-            injectedLogger[logged.options.returnLogLevel](
+            injectedLogger[logged.options.returnLogLevel](`${createCallLogIdentifyMessage('RETURNED', type, key, route)} ${resultLogged}`);
-              route
-                ? `RETURNED HTTP ${route} (${key}) ${resultLogged}`
-                : `RETURNED ${key} ${resultLogged}`
-            );
             return r;
           })
         } else {
@@ -346,11 +345,7 @@ function overrideBuild<F extends Array<any>, R>(
                   : "WITH " + r
                 : "";
 
-          injectedLogger[logged.options.returnLogLevel](
+          injectedLogger[logged.options.returnLogLevel](`${createCallLogIdentifyMessage('RETURNED', type, key, route)} ${resultLogged}`);
-            route
-              ? `RETURNED HTTP ${route} (${key}) ${resultLogged}`
-              : `RETURNED ${key} ${resultLogged}`
-          );
           return r;
         }
       } else {
@@ -359,13 +354,11 @@ function overrideBuild<F extends Array<any>, R>(
     } catch (e) {
       // Error Log
       if (logged.options.errorLogLevel !== 'skip') {
-        injectedLogger[logged.options.errorLogLevel](
+        injectedLogger[logged.options.errorLogLevel](`${createCallLogIdentifyMessage('ERROR', type, key, route)} ${e}`);
-          `WHILE ${route ? `HTTP ${route} (${key})` : key} ERROR ${e}`
-        );
       }
       throw e;
     }
-  };
+  }
 }
 
 export function LoggedFunction<F extends Array<any>, R>(
@@ -499,6 +492,10 @@ export function LoggedRoute<F extends Array<any>, R>(route?: string, options?: P
       _target,
       key
     );
+    // if @InjectLogger exists, fake nestjs as it is @Req()
+    if (scopedLoggerInjectableParam !== undefined) {
+      createRouteParamDecorator(0)()(_target, key, scopedLoggerInjectableParam);
+    }
 
     const loggedParams: LoggedParamReflectData[] = Reflect.getOwnMetadata(
       loggedParam,

src/reflected.ts

@@ -4,7 +4,7 @@ import {isNil, isString} from "@nestjs/common/utils/shared.utils";
 
 const ROUTE_ARGS_METADATA = '__routeArguments__';
 
-function createRouteParamDecorator(paramtype: RouteParamtypes) {
+export function createRouteParamDecorator(paramtype: RouteParamtypes) {
   return (data?: ParamData): ParameterDecorator =>
     (target, key, index) => {
       const args =

src/utils.ts

@@ -0,0 +1,9 @@
+import { Logger } from "@nestjs/common";
+import { ScopedLogger } from "./logger";
+import { REQUEST_LOG_ID } from "./logged";
+
+const logger = new Logger();
+
+export function getRequestLogger(functionName: string, req: any): ScopedLogger {
+    return new ScopedLogger(logger, [functionName], req[REQUEST_LOG_ID])
+}