feat: add otel integration

Author: jlenon7

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/logger",
-  "version": "5.15.0",
+  "version": "5.16.0",
   "description": "The Athenna logging solution. Log in stdout, files and buckets.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",
@@ -63,6 +63,8 @@
   },
   "dependencies": {
     "@aws-lambda-powertools/logger": "^1.18.1",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api-logs": "^0.213.0",
     "cls-rtracer": "^2.6.3",
     "telegraf": "^4.16.3"
   },
@@ -72,6 +74,7 @@
     "@athenna/ioc": "^5.2.0",
     "@athenna/test": "^5.5.0",
     "@athenna/tsconfig": "^5.0.0",
+    "@opentelemetry/context-async-hooks": "^2.6.0",
     "@typescript-eslint/eslint-plugin": "^8.38.0",
     "@typescript-eslint/parser": "^8.38.0",
     "commitizen": "^4.3.1",

package.json

@@ -0,0 +1,58 @@
+/**
+ * @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 { Driver } from '#src/drivers/Driver'
+import { context } from '@opentelemetry/api'
+import { logs, SeverityNumber } from '@opentelemetry/api-logs'
+
+export class OtelDriver extends Driver {
+  public transport(level: string, message: any): void {
+    if (!this.couldBeTransported(level)) {
+      return
+    }
+
+    const logger = logs.getLogger('@athenna/logger')
+
+    logger.emit({
+      eventName: 'athenna.log',
+      severityNumber: this.getSeverityNumber(level),
+      severityText: level.toUpperCase(),
+      body: this.getBody(level, message),
+      attributes: {
+        'athenna.log.level': level,
+        'athenna.log.stream': this.getStreamTypeFor(level)
+      },
+      context: context.active()
+    })
+  }
+
+  private getBody(level: string, message: any) {
+    const formatted = this.format(level, message, true)
+
+    try {
+      return JSON.parse(formatted)
+    } catch {
+      return formatted
+    }
+  }
+
+  private getSeverityNumber(level: string): SeverityNumber {
+    const levels = {
+      trace: SeverityNumber.TRACE,
+      debug: SeverityNumber.DEBUG,
+      info: SeverityNumber.INFO,
+      success: SeverityNumber.INFO2,
+      warn: SeverityNumber.WARN,
+      error: SeverityNumber.ERROR,
+      fatal: SeverityNumber.FATAL
+    }
+
+    return levels[level] || SeverityNumber.INFO
+  }
+}

src/drivers/OtelDriver.ts

@@ -13,6 +13,7 @@ import { Driver } from '#src/drivers/Driver'
 import { FileDriver } from '#src/drivers/FileDriver'
 import { NullDriver } from '#src/drivers/NullDriver'
 import { LokiDriver } from '#src/drivers/LokiDriver'
+import { OtelDriver } from '#src/drivers/OtelDriver'
 import { SlackDriver } from '#src/drivers/SlackDriver'
 import { StackDriver } from '#src/drivers/StackDriver'
 import { LambdaDriver } from '#src/drivers/LambdaDriver'
@@ -32,6 +33,7 @@ export class DriverFactory {
     .set('file', { Driver: FileDriver })
     .set('null', { Driver: NullDriver })
     .set('loki', { Driver: LokiDriver })
+    .set('otel', { Driver: OtelDriver })
     .set('slack', { Driver: SlackDriver })
     .set('stack', { Driver: StackDriver })
     .set('lambda', { Driver: LambdaDriver })

src/factories/DriverFactory.ts

@@ -10,6 +10,7 @@
 import rTracer from 'cls-rtracer'
 
 import { hostname } from 'node:os'
+import { trace } from '@opentelemetry/api'
 import { Is, Color } from '@athenna/common'
 
 export abstract class Formatter {
@@ -57,7 +58,17 @@ export abstract class Formatter {
    * Get the trace id for formatter.
    */
   public traceId(): string | null {
-    return (rTracer.id() || null) as any
+    return (
+      trace.getActiveSpan()?.spanContext().traceId ||
+      ((rTracer.id() || null) as any)
+    )
+  }
+
+  /**
+   * Get the span id for formatter.
+   */
+  public spanId(): string | null {
+    return trace.getActiveSpan()?.spanContext().spanId || null
   }
 
   /**

src/formatters/Formatter.ts

@@ -18,7 +18,8 @@ export class JsonFormatter extends Formatter {
       time: Date.now(),
       pid: this.pid(),
       hostname: this.hostname(),
-      traceId: this.traceId()
+      traceId: this.traceId(),
+      spanId: this.spanId()
     }
 
     if (Is.String(message)) {

src/formatters/JsonFormatter.ts

@@ -37,6 +37,7 @@ export class RequestFormatter extends Formatter {
       path: ctx.request.baseUrl,
       createdAt: Date.now(),
       traceId: this.traceId(),
+      spanId: this.spanId(),
       data: ctx.data
     }
 

src/formatters/RequestFormatter.ts

@@ -70,10 +70,10 @@ export class Logger extends Macroable {
     const runtimeConfigs: any = Json.copy(this.runtimeConfigs)
 
     if (!runtimeConfigs.formatterConfig) {
-      runtimeConfigs.formatterConfig = {} 
+      runtimeConfigs.formatterConfig = {}
     }
 
-    runtimeConfigs.formatterConfig.defaults = Json.copy(defaults) 
+    runtimeConfigs.formatterConfig.defaults = Json.copy(defaults)
 
     logger.selection = {
       method: this.selection.method,
@@ -121,7 +121,10 @@ export class Logger extends Macroable {
     }
 
     configs.forEach(config => {
-      const driver = DriverFactory.fabricateVanilla({ ...config, ...this.runtimeConfigs })
+      const driver = DriverFactory.fabricateVanilla({
+        ...config,
+        ...this.runtimeConfigs
+      })
 
       this.drivers.push(driver)
     })

src/logger/Logger.ts

@@ -0,0 +1,85 @@
+/**
+ * @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 { OtelDriver } from '#src/drivers/OtelDriver'
+import { Test, AfterEach, BeforeEach, type Context } from '@athenna/test'
+import { context, ROOT_CONTEXT, trace, TraceFlags } from '@opentelemetry/api'
+import { logs, SeverityNumber, type LogRecord } from '@opentelemetry/api-logs'
+import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks'
+
+class FakeLogger {
+  public records: LogRecord[] = []
+
+  public emit(logRecord: LogRecord): void {
+    this.records.push(logRecord)
+  }
+}
+
+class FakeLoggerProvider {
+  public logger = new FakeLogger()
+
+  public getLogger() {
+    return this.logger
+  }
+}
+
+export default class OtelDriverTest {
+  @BeforeEach()
+  public async beforeEach() {
+    context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable())
+  }
+
+  @AfterEach()
+  public async afterEach() {
+    logs.disable()
+    context.disable()
+  }
+
+  @Test()
+  public async shouldEmitLogsUsingTheOpenTelemetryLoggerProvider({ assert }: Context) {
+    const provider = new FakeLoggerProvider()
+
+    logs.setGlobalLoggerProvider(provider as any)
+
+    const driver = new OtelDriver({ formatter: 'json' })
+
+    driver.transport('error', 'failed to retrieve user')
+
+    assert.lengthOf(provider.logger.records, 1)
+    assert.equal(provider.logger.records[0].severityNumber, SeverityNumber.ERROR)
+    assert.equal(provider.logger.records[0].severityText, 'ERROR')
+    assert.equal(provider.logger.records[0].attributes['athenna.log.level'], 'error')
+    assert.equal(provider.logger.records[0].attributes['athenna.log.stream'], 'stderr')
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    assert.equal(provider.logger.records[0].body.msg, 'failed to retrieve user')
+  }
+
+  @Test()
+  public async shouldEmitLogsWithTheActiveOtelContext({ assert }: Context) {
+    const provider = new FakeLoggerProvider()
+    const spanContext = {
+      traceId: '11111111111111111111111111111111',
+      spanId: '2222222222222222',
+      traceFlags: TraceFlags.SAMPLED
+    }
+
+    logs.setGlobalLoggerProvider(provider as any)
+
+    const driver = new OtelDriver({ formatter: 'json' })
+
+    context.with(trace.setSpanContext(ROOT_CONTEXT, spanContext), () => {
+      driver.transport('info', 'hello')
+    })
+
+    const emittedContext = provider.logger.records[0].context
+
+    assert.deepEqual(trace.getSpanContext(emittedContext), spanContext)
+  }
+}

tests/unit/drivers/OtelDriverTest.ts

@@ -38,7 +38,18 @@ export default class DriverFactoryTest {
   public async shouldBeAbleToListAllAvailableDrivers({ assert }: Context) {
     const drivers = DriverFactory.availableDrivers()
 
-    assert.deepEqual(drivers, ['file', 'null', 'loki', 'slack', 'stack', 'lambda', 'console', 'discord', 'telegram'])
+    assert.deepEqual(drivers, [
+      'file',
+      'null',
+      'loki',
+      'otel',
+      'slack',
+      'stack',
+      'lambda',
+      'console',
+      'discord',
+      'telegram'
+    ])
   }
 
   @Test()