Merge pull request #123 from AthennaIO/develop

feat(logger): add way to define default values to formatters

Author: jlenon7

.github/workflows/cd.yml

@@ -8,14 +8,17 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
     steps:
       - name: Checkout
         uses: actions/checkout@v2
         with:
           fetch-depth: 0
       - uses: actions/setup-node@v1
         with:
-          node-version: '20.x'
+          node-version: '21.x'
           registry-url: 'https://registry.npmjs.org'
 
       - name: Install dependencies
@@ -32,8 +35,7 @@ jobs:
         id: release
 
       - name: Publish to NPM Registry
-        run: cd build && npm publish --access public
+        run: cd build && npm publish --provenance --access public
         if: steps.release.outputs.released == 'true'
         env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
           name: Deploy

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/logger",
-  "version": "5.13.0",
+  "version": "5.14.0",
   "description": "The Athenna logging solution. Log in stdout, files and buckets.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",

package.json

@@ -13,6 +13,7 @@ import { Formatter } from '#src/formatters/Formatter'
 export class JsonFormatter extends Formatter {
   public format(message: any): string {
     const base: any = {
+      ...(this.configs.defaults || {}),
       level: this.level(),
       time: Date.now(),
       pid: this.pid(),

src/formatters/JsonFormatter.ts

@@ -9,7 +9,7 @@
 
 import { Config } from '@athenna/config'
 import { Driver } from '#src/drivers/Driver'
-import { Color, Macroable } from '@athenna/common'
+import { Color, Json, Macroable } from '@athenna/common'
 import { DriverFactory } from '#src/factories/DriverFactory'
 import { VANILLA_CHANNELS } from '#src/constants/VanillaChannels'
 
@@ -24,6 +24,21 @@ export class Logger extends Macroable {
    */
   private runtimeConfigs = {}
 
+  /**
+   * Default message content that should be included
+   * in every structured log emitted by this instance.
+   */
+  private messageDefaults = {}
+
+  /**
+   * Store the current logger strategy so create()
+   * can clone the logger preserving its behavior.
+   */
+  private selection: { type: 'channel' | 'vanilla'; values: any[] } = {
+    type: 'vanilla',
+    values: []
+  }
+
   public constructor() {
     super()
     this.channelOrVanilla(Config.get('logging.default'))
@@ -52,14 +67,36 @@ export class Logger extends Macroable {
     return this
   }
 
+  /**
+   * Create a new logger instance inheriting the current
+   * configuration and adding default message content.
+   */
+  public create(defaults: any = {}): Logger {
+    const logger = new Logger()
+
+    logger.runtimeConfigs = Json.copy(this.runtimeConfigs)
+    logger.messageDefaults = {
+      ...Json.copy(this.messageDefaults),
+      ...Json.copy(defaults || {})
+    }
+
+    return logger[this.selection.type](...Json.copy(this.selection.values))
+  }
+
   /**
    * Change the log channel.
    */
   public channel(...channels: string[]): Logger {
     this.drivers = []
+    this.selection = {
+      type: 'channel',
+      values: [...channels]
+    }
+
+    const runtimeConfigs = this.withDefaultFormatterConfig(this.runtimeConfigs)
 
     channels.forEach(channel => {
-      this.drivers.push(DriverFactory.fabricate(channel, this.runtimeConfigs))
+      this.drivers.push(DriverFactory.fabricate(channel, runtimeConfigs))
     })
 
     return this
@@ -72,15 +109,23 @@ export class Logger extends Macroable {
    */
   public vanilla(...configs: any[]): Logger {
     this.drivers = []
+    this.selection = {
+      type: 'vanilla',
+      values: Json.copy(configs)
+    }
 
     if (!configs.length) {
-      this.drivers.push(DriverFactory.fabricateVanilla())
+      this.drivers.push(
+        DriverFactory.fabricateVanilla(this.withDefaultFormatterConfig())
+      )
 
       return this
     }
 
     configs.forEach(config => {
-      this.drivers.push(DriverFactory.fabricateVanilla(config))
+      this.drivers.push(
+        DriverFactory.fabricateVanilla(this.withDefaultFormatterConfig(config))
+      )
     })
 
     return this
@@ -171,4 +216,25 @@ export class Logger extends Macroable {
 
     return Promise.all(promises)
   }
+
+  /**
+   * Attach message defaults to formatter configs so
+   * structured formatters can enrich the output.
+   */
+  private withDefaultFormatterConfig(configs: any = {}): any {
+    if (!Object.keys(this.messageDefaults).length) {
+      return configs
+    }
+
+    return {
+      ...configs,
+      formatterConfig: {
+        ...(configs.formatterConfig || {}),
+        defaults: {
+          ...((configs.formatterConfig || {}).defaults || {}),
+          ...this.messageDefaults
+        }
+      }
+    }
+  }
 }

src/logger/Logger.ts

@@ -0,0 +1,24 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Config } from '@athenna/config'
+import { Log, LoggerProvider } from '#src'
+import { Folder, Path } from '@athenna/common'
+
+await new Folder(Path.fixtures('config')).copy(Path.config())
+await Config.safeLoad(Path.config('logging.ts'))
+
+new LoggerProvider().register()
+
+const logger = Log.create({ namespace: 'UserService' }).config({ formatter: 'json' }).channel('application')
+
+logger.error('failed to retrieve user')
+
+await Folder.safeRemove(Path.config())
+await Folder.safeRemove(Path.storage())

tests/fixtures/transporters/loggerCreate.ts

@@ -38,4 +38,20 @@ export default class JsonFormatterTest {
       assert.isTrue(Is.Uuid(message.traceId))
     })
   }
+
+  @Test()
+  public async shouldBeAbleToFormatLogsToJsonFormatWithDefaults({ assert }: Context) {
+    const formatter = new JsonFormatter().config({
+      level: 'info',
+      defaults: {
+        namespace: 'UserService'
+      }
+    })
+
+    const message = JSON.parse(formatter.format('hello'))
+
+    assert.equal(message.msg, 'hello')
+    assert.equal(message.namespace, 'UserService')
+    assert.equal(message.level, 'info')
+  }
 }

tests/unit/formatters/JsonFormatterTest.ts

@@ -24,4 +24,18 @@ export default class LoggerTest {
       assert.isTrue(log.includes('hello'))
     })
   }
+
+  @Test()
+  public async shouldBeAbleToCreateLoggerWithDefaultMessageContent({ assert }: Context) {
+    const { stdout, stderr } = await Exec.node(Path.fixtures('transporters/loggerCreate.ts'))
+
+    const logs = [...stdout.split('\n').filter(l => l !== ''), ...stderr.split('\n').filter(l => l !== '')].filter(
+      v => !v.startsWith('(')
+    )
+    const message = JSON.parse(logs[0])
+
+    assert.equal(message.msg, 'failed to retrieve user')
+    assert.equal(message.level, 'error')
+    assert.equal(message.namespace, 'UserService')
+  }
 }