nest-logger-bundle 0.1.6 → 1.1.2

package/README.md

@@ -10,22 +10,17 @@
     <img alt="Snyk Vulnerabilities for npm package" src="https://img.shields.io/snyk/vulnerabilities/npm/nest-logger-bundle" />
   </a>
   <img alt="Libraries.io" src="https://img.shields.io/librariesio/release/npm/nest-logger-bundle">
+  <img alt="Supported Language: Typescript" src="https://img.shields.io/npm/types/typescript" />
   <img alt="Supported platforms: Express & Fastify" src="https://img.shields.io/badge/platforms-Express%20%26%20Fastify-green" />
 </p>
 
 ## Description
 
-This library made to be used with <a href="http://nodejs.org" target="blank">Nest.js</a> it offers more flexibility for controlling logs in the application. The strongest point is that it offers a way to pack all the logs originating from an request or some asynchronous flow into a single bundle, also later it provides ways to transport the bundles to some cloud observability service.
+This library made to be used with <a href="http://nodejs.org" target="blank">Nest.js</a> it offers more flexibility for controlling logs in the application. The strongest point is that it offers a way to pack all the logs originating from an request or some asynchronous flow into a single bundle, you can also decide what to do with this bundle as well as regular logs.
 
-For example, in a request several logs can occur and organizing this later or finding yourself in the middle of so many logs becomes a complicated task, with the LoggerBundle all the logs that occur in that request will be packed in a bundle and this bundle shows exactly the order that these logs were displayed in a tree, you can even create branches of these logs using the `enter()/ exit()` methods as will be explained later. This bundle will include a lot of useful information, such as the request that originated these logs and in the log tree you will be able to see a time profiling telling you how long it took in each branch tree.
+For example, in a request several logs can occur and organizing this later or finding yourself in the middle of so many logs becomes a complicated task, with the `LoggerBundle` all the logs that occur in that request will be packed in a bundle and this bundle shows exactly the order that these logs were occurred using a tree, you can even create branches of these logs using the `enter()/ exit()` methods as will be explained later. This bundle will include a lot of useful information, such as the request that originated these logs and in the log tree you will be able to see a time profiling telling you how long it took in each branch tree.
 
-Don't worry if some function of a service calls other functions of other services that contain another injected LoggerBundle, because it can find itself within the current context of the request, so no matter how many different services interact, the output will be in the same bundle.
-
-________________
-
-## Internal Dependencies
-
-You don't need to install any extra dependencies. Internally this library is also made using some bases that are made on top of the <a href="https://github.com/pinojs/pino" target="blank">pino</a>, but I have plans to expose this dependencies in the future and leave the user free to choose which one to use.
+Inside it works based on a context, be it a request or an asynchronous flow, so you can inject the `LoggerBundle` into any desired service and all calls between these services work correctly, so all logs occurring in a given request will be packed in the same bundle.
 
 ________________
 
@@ -35,25 +30,32 @@ ________________
 $ npm i --save nest-logger-bundle
 ```
 
-## Samples
 
 ________________
 
+## Internal Dependencies
+
+You don't need to install any extra dependencies. Internally this library is also made using some bases that are made on top of the <a href="https://github.com/pinojs/pino" target="blank">pino</a>. If you need to use some transporter you will need to configure the streams, for that, follow this [section](#streams)
+
+________________
+
+## Samples
+
 If you want to see some usage examples use this repo <a href="https://github.com/pedrohcdo/nest-logger-bundle-samples" target="blank">NestLoggerBundleSamples</a>, In it you will find some projects with some use cases, the codes are commented for a better understanding.
 
-> If you want to see an simple example of how to configure it, see the test project [Example](test).
+> But if you want to see an simple example of how to configure it, see the test project [Example](test).
 
 ________________
 
 ## How to use
 
-First we need to import the NestLoggerModule module in the module we want to use. Follow the minimum configuration:
+First we need to import the LoggerBundleModule module in the module we want to use. Follow the minimum configuration:
 
 ```ts
 import { Global, Module } from '@nestjs/common';
 import { APP_FILTER, APP_INTERCEPTOR } from '@nestjs/core';
 import {
-  NestLoggerModule,
+  LoggerBundleModule,
   LoggerExceptionFilter,
   LoggerHttpInterceptor
 } from 'nest-logger-bundle';
@@ -65,7 +67,7 @@ import {
   imports: [
     // .. imports
 
-   NestLoggerModule.forRoot({})
+   LoggerBundleModule.forRoot({})
   ],
 
   providers: [
@@ -79,7 +81,7 @@ import {
     },
   ],
 
-  exports: [NestLoggerModule /**, ... others exports */],
+  exports: [LoggerBundleModule /**, ... others exports */],
 })
 export class GlobalModule {}
 
@@ -87,7 +89,7 @@ export class GlobalModule {}
 For the LoggerBundle to work correctly, it needs some points to be handled, for that there are two classes that are used to handle requests and errors, they are: `LoggerExceptionFilter` and `LoggerHttpInterceptor`.
 These classes need to be used in the global-scoped filters and interceptors like the example to be work across the whole application. `Remember to provide this filter and interceptor as in the example above in a global module or in the main module of your application.`
 
-> If you already have a global scope filter or interceptor, follow the [tutorial](#custom-filter-and-interceptor)
+> If you already have a global scope filter or interceptor on your project, follow the [tutorial](#custom-filter-and-interceptor)
 
 ### Injecting LoggerBundle
 
@@ -98,7 +100,7 @@ To inject the Logger in some injectable service of your project follow the examp
 export class SampleUserService {
 
   constructor(
-    private logService: NestLoggerService
+    private logService: LoggerBundleService
   ) {
     this.logService.setContextToken(SampleService.name)
   }
@@ -143,12 +145,17 @@ export class SampleUserService {
 
 > Remembering that the name of the current service can be acquired by `<Class>.name`, so you can change the name of the context of the LoggerBundle right at the beginning using as shown in the example above: `this.logService.setContextToken(SampleService.name)`
 
-If the `SampleUserService.createUser(email, username)` function is called, the log structure that will be generated will be like the example below:
+________________
+
+## Bundle Structure
+
+
+The bundle is generated at the end of a flow such as a request, after that the generated bundle is dispatched according to the parameters passed in the module configuration (`the complete configuration can be seen here `[Setting-up](#setting-up)). Para demonstrar como é a estrutura do bundle vamos usar o exemplo acima [Injecting LoggerBundle](#injecting-loggerbundle), if the `SampleUserService.createUser(email, username)` function is called, the bundle structure that will be generated will be like the example below:
 
 ```json
 {
   logs: {
-    "profiling": "6ms",
+    "profiling": <duration>,
     "name": "root",
     "logs": [
       {
@@ -157,7 +164,7 @@ If the `SampleUserService.createUser(email, username)` function is called, the l
         "context": "SampleService"
       },
       {
-        "profiling": "0ms",
+        "profiling": <duration>,
         "name": "creating user",
         "logs": [
           {
@@ -166,7 +173,7 @@ If the `SampleUserService.createUser(email, username)` function is called, the l
             "context": "SampleService"
           },
           {
-            "profiling": "0ms",
+            "profiling": <duration>,
             "name": "finding user by email ",
             "logs": [
               {
@@ -189,27 +196,27 @@ If the `SampleUserService.createUser(email, username)` function is called, the l
     "requestDuration": <duration>,
     "method": "GET",
     "path": "/sample/create-user/teste%40teste.com/Teste%20123",
-    "ip": <ip>
-  },
-  tags: {
-    "test": "test 123"
+    "ip": <ip>,
+    tags: {
+      "test": "test 123"
+    },
   },
   req: <request object>,
   res: <response object>
 }
 ```
 
-The log will display 5 objects, they are:
+The bundle will contain these 5 objects
 
 | Object | Description 
 | :--- | :----:
-| `logs` | A bundle containing the entire log tree including a time profiling between each log.
-| `context` | The context in which this log bundle was created, containing information such as api path, method..
-| `tags` | The tags created in this context
-| `req` | The body of the request that originated this bundle
-| `res` | If it is a complete request context here you will be able to see the response of that request
+| ***logs*** | A object containing the entire `logs` tree including a time profiling between each log.
+| ***context*** | The `context` in which this log bundle was created, containing information such as api path, method..
+| ***context.tags*** | The `tags` created in this context
+| ***req*** | The body of the `request` that originated this bundle
+| ***res*** | If it is a complete request context here you will be able to see the `response` of that request
 
-The generated bundle follows the following structure, where the `logs` array can contain more log nodes like the example
+The generated logs tree follows the following structure, where the `logs` array can contain more log nodes like the example
 
 ```ts
 {
@@ -235,7 +242,7 @@ The generated bundle follows the following structure, where the `logs` array can
 }
 ```
 
-There are some methods available for use in NestLoggerService, here is a list of them
+There are some methods available for use in LoggerBundleService, here is a list of them
 
 - Log Methods <br/>
   ```ts
@@ -258,10 +265,10 @@ There are some methods available for use in NestLoggerService, here is a list of
   fatal(...args)
   ```
 
-  Where all log levels follow the same argument model, there are thre call combinations, here is an example with `log()` level
+  Where all log levels follow the same argument model, there are three call combinations, here is an example with `log()` level
 
   ```ts
-  // The first way is sending a text that can contain special characters for formatting and then the arguments referring to the formatting.
+  // The first way is sending a text that can contain special characters of printf-like format for formatting (see https://github.com/pinojs/quick-format-unescaped), then the next arguments are the values ​​referring to the provided formatting..
   this.logService.log("message to format %d %d", 10, 20)
 
   // The second form precedes an object that will be merged together with the formatted message
@@ -277,9 +284,9 @@ There are some methods available for use in NestLoggerService, here is a list of
 
   | Method | Description 
   | :--- | :----:
-  | `enter(`branchName`)` | This method creates a node in the log tree where the '`branchName`' is an string that will be the name of the subtree of logs
-  | `exit()` | This method closes the current subtree, remembering that the same amount opened with `enter()` must be closed with `exit()`
-  | `putTag(`tagName, tagValue`)` | Where the '`tagName`' and '`tagValue`' are strings. This method adds a tag in the current context, the tags have no direct relation with the `enter()` and `exit()` methods, so regardless of the current state of the tree, the tags will be added separately in the bundle.
+  | ***enter(`branchName`)*** | This method creates a node in the log tree where the '`branchName`' is an string that will be the name of the subtree of logs
+  | ***exit()*** | This method closes the current subtree, remembering that the same amount opened with `enter()` must be closed with `exit()`
+  | ***putTag(`tagName, tagValue`)*** | Where the '`tagName`' and '`tagValue`' are strings. This method adds a tag in the current context, the tags have no direct relation with the `enter()` and `exit()` methods, so regardless of the current state of the tree, the tags will be added separately in the bundle.
 
 - Async Methods
 
@@ -287,19 +294,19 @@ There are some methods available for use in NestLoggerService, here is a list of
 
   | Method | Description 
   | :--- | :----:
-  |  `createAsyncLogger()` | Creates an asynchronous LoggerBundle, where the responsibility for transporting the bundle is on your side
+  |  ***createAsyncLogger()*** | Creates an asynchronous LoggerBundle, where the responsibility for transporting the bundle is on your side
 
 ______
 
 ## Setting-up
 
-  The NestLoggerModule provides two ways of configuration, they are:
+  The LoggerBundleModule provides two ways of configuration, they are:
 
 - *Statically Config*<br/>
   If you want to configure it statically, just use
   
   ```ts
-  NestLoggerModule.forRoot({
+  LoggerBundleModule.forRoot({
     // ... params
   })
   ```
@@ -308,9 +315,9 @@ ______
   In case you want to pass the settings asynchronously
   
   ```ts
-  NestLoggerModule.forRootAsync({
+  LoggerBundleModule.forRootAsync({
     isGlobal: boolean, // 
-    useFactory: (config: ConfigService): NestLoggerParams => {
+    useFactory: (config: ConfigService): LoggerBundleParams => {
       return {
         // ... params
       }
@@ -319,18 +326,22 @@ ______
   })
   ```
 
-You must provide the desired parameters for the LoggerBundle, the parameters follow the following schema
+You must provide the desired parameters for the LoggerBundleModule, the parameters follow the following schema
 
 ```ts
 // default config
 {
-  pinoStream: {
+  loggers: {
     type: 'default',
     prettyPrint: {
+      mode: LoggerBundleParamsLogggerMode, // DEFAULT IS LOG_BUNDLE
       disabled: boolean,
       options: pino.PrettyOptions,
     },
-    streams: pinoms.Streams,
+    streams: {
+      mode: LoggerBundleParamsLogggerMode, // DEFAULT IS LOG_BUNDLE
+      pinoStreams: pinoms.Streams
+    },
     timestamp: {
       format: {
         template: string,
@@ -342,9 +353,7 @@ You must provide the desired parameters for the LoggerBundle, the parameters fol
   // You can change this
   contextBundle: {
     strategy: {
-      onDispatch: NestLoggerDispatchStrategy,
-      level: NestLoggerLevelStrategy,
-      onError: NestLoggerOnErrorStrategy,
+      level: LoggerBundleLevelStrategy
     },
   }
 }
@@ -352,17 +361,18 @@ You must provide the desired parameters for the LoggerBundle, the parameters fol
 ```ts
 // custom config
 {
-  pinoStream: {
+  loggers: {
     type: 'custom',
-    logger: pino.Logger
+    logger: pino.Logger,
+    level?: string,
+    bundleLogger: pino.Logger
+    lineLogger?: pino.Logger
   },
 
   // You can change this
   contextBundle: {
     strategy: {
-      onDispatch: NestLoggerDispatchStrategy,
-      level: NestLoggerLevelStrategy,
-      onError: NestLoggerOnErrorStrategy,
+      level: LoggerBundleLevelStrategy
     },
   }
 }
@@ -370,81 +380,129 @@ You must provide the desired parameters for the LoggerBundle, the parameters fol
 
 Below is the description of each parameter
 
-- **NestLoggerParams**<br/>
+- **LoggerBundleParams**<br/>
 
   | Param | Description 
   | :--- | :----:
-  | `pinoStream`: NestLoggerParamsPinoStream \| NestLoggerParamsCustomPino | The NestLoggerBundle uses the `pino-multi-stream ` to transport the logs to several different destinations at the same time, for that it is necessary to use the `type: 'default'` so some parameters of `NestLoggerParamsPinoStream` will be provided, but if you choose to use a `type: 'custom'` some parameters of `NestLoggerParamsCustomPino` will be provided and you can use a pin logger configured in your own way.
-  |  `contextBundle`: NestLoggerParamsContextBundle | Here you can configure some behaviors related to how the bundle is created, for example, configure what the bundle's marjoritary level will be..
+  | ***loggers***?: LoggerBundleParamsStream \| LoggerBundleParamsCustom | The LoggerBundle uses the `pino-multi-stream ` to transport the logs to several different destinations at the same time, if you want to use the default implementation that makes managing these logs very easy use type `'default'` so some parameters of `LoggerBundleParamsStream` will be provided, but if you choose to use a type `'custom'` some parameters of `LoggerBundleParamsCustom` will be provided and you can use a `pino` logger configured in your own way.
+  |  ***contextBundle***?: LoggerBundleParamsContextBundle | Here you can configure some behaviors related to how the bundle is created, for example, configure what the bundle's marjoritary level will be..
+  |  ***forRoutes***?: (string \| Type<any> \| RouteInfo)[] | Pattern based routes are supported as well. For instance, the asterisk is used as a wildcard, and will match any combination of characters, for more datails see [NestJS-Middlewares](https://docs.nestjs.com/middleware), the default is `[{ path: '*', method: RequestMethod.ALL }]`
 
-- **NestLoggerParamsPinoStream**<br/>
-  If you choose to use the default configuration in `NestLoggerParams`, using '`{ type: 'default', ... }`' the options for these parameters will be provided
+- **LoggerBundleParamsStream**<br/>
+  If you choose to use the default configuration in `LoggerBundleParams`, using '`{ type: 'default', ... }`' the options for these parameters will be provided
   > It is worth remembering that it is recommended to use this configuration if you do not have the need to create your own configuration.
 
   | Param | Description 
   | :--- | :----:
-  | `type: 'default'` | For the options to follow this pattern you must set the type to `'default'`
-  | `prettyPrint`: NestLoggerParamsPrettyStream | Here you can configure `prettyStream`, choosing to disable it if necessary and also provide your `pin.PrettyOptions`
-  | `streams`: pinoms.Streams | You can also tell which streams you want pinoms handles, you can find implementations of various transporters that can be used here https://github.com/pinojs/pino/blob/master/docs/transports.md#legacy
-  | `timestamp`: NestLoggerParamsPinoTimestamp | You can also configure how the timestamp will be formatted in the logs informing a template and a timezone, the template is created with the help of `dayjs` to assemble the desired string you can use the symbols informed here https://day.js.org/docs/en/display/format
+  | ***type***: `'default'` | For the options to follow this pattern you must set the type to `'default'`
+  | ***prettyPrint***?: LoggerBundleParamsPretty | Here you can configure `prettyStream`, choosing to disable it if necessary and also provide your `pin.PrettyOptions`
+  | ***streams***?: LoggerBundleParamsStreams | Here you can configure `streams`, choosing to disable it if necessary and also provide your own transporter
+  | ***timestamp***?: LoggerBundleParamsTimestamp | To configure how the timestamp will be formatted or even disable it, use these settings
+
+  ###  Related Params
+    
+    - **LoggerBundleParamsPretty**<br/>
 
-    - **NestLoggerParamsPrettyStream**<br/>
+      | Param | Description 
+      | :--- | :----:
+      | ***mode***?: LoggerBundleParamsLogggerMode | Here you can choose the mode that `prettyStream` will display the logs, the default value is `LoggerBundleParamsLogggerMode.LOG_BUNDLE`, so the bundle will be logged.
+      | ***disabled***?: boolean | If you want to disable the `prettyStream` you can pass `false` in this option `(remembering that, as it will be disabled the 'options' will not have any effects)`
+      | ***options***?: pino.PrettyOptions | Here you can pass some options provided by `pin`, like `{colorize: true}`
 
+    - **LoggerBundleParamsStreams**<br/>
+    
       | Param | Description 
       | :--- | :----:
-      | `disabled`: boolean | If you want to disable the `prettyStream` you can pass `false` in this option `(remembering that, as it will be disabled the 'options' will not have any effects)`
-      | `options`: pino.PrettyOptions | Here you can pass some options provided by `pin`, like `{colorize: true}`
+      | ***mode***?: LoggerBundleParamsLogggerMode | Here you can choose the mode that `streams` will display the logs, the default value is `LoggerBundleParamsLogggerMode.LOG_BUNDLE`, so the bundle will be logged.
+      | ***pinoStreams***?: pinoms.Streams | You can also tell which `streams` you want pinoms handles, you can find implementations of various transporters that can be used here https://github.com/pinojs/pino/blob/master/docs/transports.md#legacy
+
+    - **LoggerBundleParamsLogggerMode**<br/>
+
+      There are two types of modes used in the `prettyPrint` and `streams` settings, they are:
+
+      | Enum | Description 
+      | :--- | :----:
+      | ***LoggerBundleParamsLogggerMode.LOG_BUNDLE*** | Indicates that the log will be sent to the destination as a bundle `(this is the default behavior of all destinations)`
+      | ***LoggerBundleParamsLogggerMode.LOG_LINE*** | Indicates that the log will be sent to the destination as log lines
 
     - **pinoms.Streams**<br/>
 
-      Here is an example of how to use a transport `(In this example, datadog is used)`
-      > To find more transporters, have a look at the pino repository in this section [Legacy](https://github.com/pinojs/pino/blob/master/docs/transports.md#legacy)
-
-      ```ts
-        import datadog from 'pino-datadog';
-
-        // ... 
-        NestLoggerModule.forRootAsync({
-          useFactory: async (config: ConfigService): Promise<NestLoggerParams> => {
-            const datadogStream = await datadog.createWriteStream({
-              apiKey: config.get('datadog.apiKey'),
-              service: config.get('datadog.serviceName'),
-            });
-
-            return {
-              // ...
-              pinoStream: {
-                type: 'default',
-                streams: [
-                  {
-                    stream: datadogStream,
-                  },
-                ],
-              },
-            };
-          },
-          inject: [ConfigService],
-        }),
+      Here you can set some streams to transport your logs, check these examples of how to use [Streams](#streams)
+
+    - **LoggerBundleParamsTimestamp**<br/>
 
-      ```
+      | Param | Description 
+      | :--- | :----:
+      | ***disabled***: boolean | If necessary, you can also disable the timestamp.
+      | ***format***: LoggerBundleParamsPinoTimestampFormat | You can also configure how the timestamp will be formatted in the logs informing a template and a timezone, the template is created with the help of `dayjs` to assemble the desired string you can use the symbols informed here [Day.js](https://day.js.org/docs/en/display/format)
 
-    - **NestLoggerParamsPinoTimestamp**<br/>
+    - **LoggerBundleParamsPinoTimestampFormat**<br/>
 
       | Param | Description 
       | :--- | :----:
-      | `template`: string | To format the timezone your way, use a string that follows the pattern informed here [dayjs-formar](https://day.js.org/docs/en/display/format), eg: `'DD/MM/YYYY - HH:mm:ss.SSS'`
-      | `timezone`: string | Inform the timezone, you can find the valid timezones here [IANA database](https://www.iana.org/time-zones)
+      | ***template***: string | To format the timezone your way, use a string that follows the pattern informed here [dayjs-formar](https://day.js.org/docs/en/display/format), eg: `'DD/MM/YYYY - HH:mm:ss.SSS'`
+      | ***timezone***: string | Inform the timezone, you can find the valid timezones here [IANA database](https://www.iana.org/time-zones)
+
+
 
+- **LoggerBundleParamsCustom**<br/>
+  But if you choose to use the custom configuration in `LoggerBundleParams`, using '`{ type: 'custom', ... }`' the options for these parameters will be provided
 
+  | Param | Description 
+  | :--- | :----:
+  | ***type***: `'custom'` | For the options to follow this pattern you must set the type to `'custom'`
+  | ***bundleLogger***: pino.Logger | This logger will be used to log bundles only
+  | ***lineLogger***?: pino.Logger | This logger will be used to log only line logs (which are common logs)
 
-- **NestLoggerParamsCustomPino**<br/>
-  But if you choose to use the default configuration in `NestLoggerParamsCustomPino`, using '`{ type: 'custom', ... }`' the options for these parameters will be provided
+- **LoggerBundleParamsContextBundle**<br/>
+  Here you can configure bundle-related behaviors, such as the `strategy` used to dispatch the bundle to the loggers
 
   | Param | Description 
   | :--- | :----:
-  | `type: 'custom'` | For the options to follow this pattern you must set the type to `'custom'`
-  | `logger`: pino.Logger | You can pass a logger that was configured your way
+  | ***strategy***?: LoggerBundleParamsContextBundleStrategy | Strategy used to dispatch the bundle to the loggers
+
+  ###  Related Params
 
+  - **LoggerBundleParamsContextBundleStrategy**<br/>
+  Below are the settings available for these strategies
+
+    | Param | Description 
+    | :--- | :----:
+    | ***level***?: LoggerBundleLevelStrategy | This strategy defines what will be the main level of the bundle, as the bundle will contain a tree of logs, it can contain several logs with several levels, so to define the main level, the configuration provided here is used to decide the best level, the default strategy is `LoggerBundleLevelStrategy.MAJOR_LEVEL`
+
+### Streams
+
+Probably at some point you may need to transport your logs, for example to some
+observability service in the cloud, here is an example of how to configure this using the `streams` parameter to send the logs to Datadog service `(In this example, datadog transporter is used)`
+> To find more transporters and how to install their dependencies, have a look at the pino repository in this section [Legacy](https://github.com/pinojs/pino/blob/master/docs/transports.md#legacy)
+
+```ts
+  import datadog from 'pino-datadog';
+
+  // ... 
+  LoggerBundleModule.forRootAsync({
+    useFactory: async (config: ConfigService): Promise<LoggerBundleParams> => {
+      const datadogStream = await datadog.createWriteStream({
+        apiKey: config.get('datadog.apiKey'),
+        service: config.get('datadog.serviceName'),
+      });
+
+      return {
+        // ...
+        pinoStream: {
+          type: 'default',
+          streams: [
+            {
+              stream: datadogStream,
+            },
+          ],
+        },
+      };
+    },
+    inject: [ConfigService],
+  }),
+
+```
 
 ### Custom Filter and Interceptor
 
@@ -514,13 +572,13 @@ import { GlobalInterceptor } from './example-http-interceptor.ts'
 In case you need to call some asynchronous function and not block the execution with `await` this can create a point of failure for the `LoggerBundle`, this failure is not serious but it can create confusion when interpreting the logs, this happens because a request that originated this call can end before the async function finishes, so when the request is finished the `LoggerBundle` assembles a bundle and transports it, so the async call that can still be loose and calling logging in will not be packaged in the same bundle, these logs they would be lost. For this there is a function that creates an asynchronous `LoggerBundle` and transfers you the responsibility of transporting the log at the end of the asynchronous flow. An example of usage is shown below
 
 ```ts
-import { AsyncLoggerService, NestLoggerService } from 'nest-logger-bundle';
+import { AsyncLoggerService, LoggerBundleService } from 'nest-logger-bundle';
 
 @Injectable()
 export class SampleUserService {
 
   constructor(
-    private logService: NestLoggerService
+    private logService: LoggerBundleService
   ) {
     this.logService.setContextToken(SampleService.name)
   }
@@ -553,8 +611,8 @@ export class SampleUserService {
 
 ## Stay in touch
 
-- Author - [Pedro Henrique C.](https://github.com/pedrohcdo)
+- Author - [Pedro Henrique C.](https://twitter.com/pedrohcdo)
 
 ## License
 
-NestLoggerBundle is [MIT licensed](LICENSE).
+NestLoggerBundle is [Apache License 2.0](LICENSE).

package/dist/lib/bundle/context/async-logger-context.service.d.ts

@@ -1,19 +1,19 @@
 import { ModuleRef } from '@nestjs/core';
 import pino from 'pino';
-import { NestLoggerParams } from '../../nest-logger.params';
-export declare class NestAsyncLoggerContext {
+import { LoggerBundleParams } from '../../nest-logger.params';
+export declare class BundleAsyncLoggerContext {
     private params;
     private bundleLogger;
     private moduleRef;
     private detachedContext;
-    constructor(params: NestLoggerParams, bundleLogger: pino.Logger, moduleRef: ModuleRef);
+    constructor(params: LoggerBundleParams, bundleLogger: pino.Logger, moduleRef: ModuleRef);
     getCurrent(): {
         logger: import("pino").Logger<import("pino").LoggerOptions>;
         reqId: any;
         loggerBundle: any;
     };
     dispatchCurrentLoggerBundle(message: string): void;
-    dispatchCurrentLoggerBundle(innerObject: unknown, message?: string): void;
+    dispatchCurrentLoggerBundle(exception: unknown, message?: string): void;
     hasContext(): boolean;
-    createDetachedContext(): Promise<NestAsyncLoggerContext>;
+    createDetachedContext(): Promise<BundleAsyncLoggerContext>;
 }

package/dist/lib/bundle/context/async-logger-context.service.js

@@ -14,9 +14,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var NestAsyncLoggerContext_1;
+var BundleAsyncLoggerContext_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NestAsyncLoggerContext = void 0;
+exports.BundleAsyncLoggerContext = void 0;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const pino_1 = __importDefault(require("pino"));
@@ -24,7 +24,7 @@ const nest_logger_module_definition_1 = require("../../nest-logger.module-defini
 const nest_logger_params_1 = require("../../nest-logger.params");
 const logger_bundle_service_1 = require("../logger-bundle.service");
 const async_logger_hook_1 = require("./async-logger.hook");
-let NestAsyncLoggerContext = NestAsyncLoggerContext_1 = class NestAsyncLoggerContext {
+let BundleAsyncLoggerContext = BundleAsyncLoggerContext_1 = class BundleAsyncLoggerContext {
     constructor(params, bundleLogger, moduleRef) {
         this.params = params;
         this.bundleLogger = bundleLogger;
@@ -36,36 +36,33 @@ let NestAsyncLoggerContext = NestAsyncLoggerContext_1 = class NestAsyncLoggerCon
         if (!this.hasContext()) {
             return null;
         }
-        const fromStore = async_logger_hook_1.NestLoggerStorage.getStore();
+        const fromStore = async_logger_hook_1.BundleLoggerStorage.getStore();
         return {
             logger: fromStore.logger,
             reqId: fromStore.reqId,
             loggerBundle: fromStore.loggerContext,
         };
     }
-    dispatchCurrentLoggerBundle(innerObject, message) {
-        var _a, _b, _c;
+    dispatchCurrentLoggerBundle(exceptionOrMessage, message) {
         if (!this.hasContext()) {
             return;
         }
         const { logger, loggerBundle } = this.getCurrent();
-        if (((_c = (_b = (_a = this.params) === null || _a === void 0 ? void 0 : _a.contextBundle) === null || _b === void 0 ? void 0 : _b.strategy) === null || _c === void 0 ? void 0 : _c.onDispatch) === nest_logger_params_1.NestLoggerDispatchStrategy.DISPATCH) {
-            const { object, level } = loggerBundle.build();
-            const childLogger = logger.child(object);
-            if (message)
-                childLogger[level](innerObject, message);
-            else
-                childLogger[level](innerObject);
-            childLogger.flush();
-        }
+        const { object, level } = loggerBundle.build();
+        const childLogger = logger.child(object);
+        if (message)
+            childLogger[level](exceptionOrMessage, message);
+        else
+            childLogger[level](exceptionOrMessage);
+        childLogger.flush();
         loggerBundle.expireNow();
     }
     hasContext() {
-        return !!async_logger_hook_1.NestLoggerStorage.getStore();
+        return !!async_logger_hook_1.BundleLoggerStorage.getStore();
     }
     async createDetachedContext() {
-        const context = await this.moduleRef.create(NestAsyncLoggerContext_1);
-        const detachedLoggerBundle = await this.moduleRef.create(logger_bundle_service_1.NestLoggerBundle);
+        const context = await this.moduleRef.create(BundleAsyncLoggerContext_1);
+        const detachedLoggerBundle = await this.moduleRef.create(logger_bundle_service_1.LoggerBundle);
         let getFrom;
         if (this.detachedContext) {
             getFrom = this.detachedContext;
@@ -91,11 +88,11 @@ let NestAsyncLoggerContext = NestAsyncLoggerContext_1 = class NestAsyncLoggerCon
         return context;
     }
 };
-NestAsyncLoggerContext = NestAsyncLoggerContext_1 = __decorate([
+BundleAsyncLoggerContext = BundleAsyncLoggerContext_1 = __decorate([
     (0, common_1.Injectable)({}),
     __param(0, (0, common_1.Inject)(nest_logger_module_definition_1.MODULE_OPTIONS_TOKEN)),
     __param(1, (0, common_1.Inject)(nest_logger_params_1.BUNDLE_LOGGER_PROVIDER_TOKEN)),
     __metadata("design:paramtypes", [Object, Object, core_1.ModuleRef])
-], NestAsyncLoggerContext);
-exports.NestAsyncLoggerContext = NestAsyncLoggerContext;
+], BundleAsyncLoggerContext);
+exports.BundleAsyncLoggerContext = BundleAsyncLoggerContext;
 //# sourceMappingURL=async-logger-context.service.js.map

package/dist/lib/bundle/context/async-logger-context.service.js.map

@@ -1 +1 @@
-{"version":3,"file":"async-logger-context.service.js","sourceRoot":"","sources":["../../../../lib/src/bundle/context/async-logger-context.service.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"async-logger-context.service.js","sourceRoot":"","sources":["../../../../lib/src/bundle/context/async-logger-context.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,2CAAoD;AACpD,uCAAyC;AACzC,gDAAwB;AACxB,uFAA2E;AAC3E,iEAGkC;AAClC,oEAAwD;AACxD,2DAA0D;AAM1D,IAAa,wBAAwB,gCAArC,MAAa,wBAAwB;IAQpC,YACuC,MAA0B,EAClB,YAAyB,EAC/D,SAAoB;QAFU,WAAM,GAAN,MAAM,CAAoB;QAClB,iBAAY,GAAZ,YAAY,CAAa;QAC/D,cAAS,GAAT,SAAS,CAAW;IAC1B,CAAC;IAEJ,UAAU;QACT,IAAI,IAAI,CAAC,eAAe;YAAE,OAAO,IAAI,CAAC,eAAe,CAAC;QAEtD,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE;YACvB,OAAO,IAAI,CAAC;SACZ;QAED,MAAM,SAAS,GAAG,uCAAmB,CAAC,QAAQ,EAAE,CAAC;QAEjD,OAAO;YACN,MAAM,EAAE,SAAS,CAAC,MAAM;YACxB,KAAK,EAAE,SAAS,CAAC,KAAK;YACtB,YAAY,EAAE,SAAS,CAAC,aAAa;SACrC,CAAC;IACH,CAAC;IAKD,2BAA2B,CAAC,kBAA2B,EAAE,OAAgB;QACxE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE;YACvB,OAAO;SACP;QAED,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAGnD,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,YAAY,CAAC,KAAK,EAAE,CAAC;QAG/C,MAAM,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACzC,IAAI,OAAO;YAAE,WAAW,CAAC,KAAK,CAAC,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC;;YACxD,WAAW,CAAC,KAAK,CAAC,CAAC,kBAAkB,CAAC,CAAC;QAC5C,WAAW,CAAC,KAAK,EAAE,CAAC;QAGpB,YAAY,CAAC,SAAS,EAAE,CAAC;IAC1B,CAAC;IAED,UAAU;QACT,OAAO,CAAC,CAAC,uCAAmB,CAAC,QAAQ,EAAE,CAAC;IACzC,CAAC;IAMD,KAAK,CAAC,qBAAqB;QAC1B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,0BAAwB,CAAC,CAAC;QACtE,MAAM,oBAAoB,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,oCAAY,CAAC,CAAC;QAEvE,IAAI,OAIH,CAAC;QAEF,IAAI,IAAI,CAAC,eAAe,EAAE;YACzB,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC;SAC/B;aAAM,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE;YAC7B,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;SAC5B;aAAM;YACN,OAAO,GAAG;gBACT,MAAM,EAAE,IAAI,CAAC,YAAY;gBACzB,YAAY,EAAE,IAAI;gBAClB,KAAK,EAAE,WAAW;aAClB,CAAC;SACF;QAED,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;QAEhD,IAAI,YAAY;YAAE,oBAAoB,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;QAE9D,OAAO,CAAC,eAAe,GAAG;YACzB,MAAM;YACN,YAAY,EAAE,oBAAoB;YAClC,KAAK;SACL,CAAC;QAEF,OAAO,OAAO,CAAC;IAChB,CAAC;CACD,CAAA;AA/FY,wBAAwB;IADpC,IAAA,mBAAU,EAAC,EAAE,CAAC;IAUZ,WAAA,IAAA,eAAM,EAAC,oDAAoB,CAAC,CAAA;IAC5B,WAAA,IAAA,eAAM,EAAC,iDAA4B,CAAC,CAAA;qDAClB,gBAAS;GAXjB,wBAAwB,CA+FpC;AA/FY,4DAAwB"}