Pino log sending via `@opentelemetry/instrumentation-pino` does not work with `@adonisjs/logger@7.x` due to IITM named export limitation

[jbsn94]

Description

After upgrading from AdonisJS v6 to v7, OTEL logs are no longer exported to our collector (SigNoz), while traces and metrics continue to work normally. This affects both production apps using Node.js 24.

The root cause is that @adonisjs/logger@7.1.0 imports pino as a named export in its bundled file (logger-Btq_FVdY.js):

import { pino, multistream, destination, ... } from "pino";

The @opentelemetry/instrumentation-pino patches the pino module via import-in-the-middle (IITM):

if (isESM) {
    if (module.pino) module.pino = patchedPino;
    module.default = patchedPino;
}

However, IITM has a known, unfixed limitation where reassignments to named exports are not visible to importing modules (nodejs/import-in-the-middle#38, open since Nov 2023). This means the patched pino function never reaches @adonisjs/logger, so the OTelPinoStream (responsible for log sending) is never added to the logger's stream.

Why traces and metrics are unaffected

Signal	Mechanism	Relies on IITM?
Traces	instrumentation-http uses Node.js native diagnostic_channel	No
Metrics	Collected automatically by Node.js runtime instrumentations	No
Logs	instrumentation-pino patches pino module via IITM	Yes

Versions

Package	Version
@adonisjs/otel	1.2.1
@adonisjs/logger	7.1.0
@adonisjs/core	7.0.1
import-in-the-middle	3.0.0
@opentelemetry/instrumentation-pino	0.58.0
@opentelemetry/auto-instrumentations-node	0.70.1
pino	10.3.1
Node.js	24

Approaches tried and discarded

1. pino-opentelemetry-transport as a pino transport target

Pino transports run in worker threads. The pino-opentelemetry-transport (via otlp-logger) creates a new LoggerProvider in the worker thread and calls logs.setGlobalLoggerProvider(), which overwrites the LoggerProvider configured by @adonisjs/otel in the main thread, breaking traces.

2. Explicit instrumentation-pino configuration

Setting disableLogSending: false explicitly doesn't help since the underlying IITM named export limitation prevents the patch from reaching the logger.

3. Downgrading @adonisjs/otel version

The IITM limitation (#38) affects all IITM versions (v2 and v3), so no version of @adonisjs/otel avoids this.

Suggested fix

The otel_provider could bypass IITM entirely by directly patching the pino logger instance after the app boots. Since the provider has access to the AdonisJS container, it can get the already-created pino instance and manually add the OTelPinoStream via pino.multistream:

// In otel_provider.js — during ready() hook
import { logs } from '@opentelemetry/api-logs'
import pino from 'pino'

const logger = app.container.make('logger')
const pinoInstance = logger.pino
const origStream = pinoInstance[pino.symbols.streamSym]

const otelStream = new OTelPinoStream({
  messageKey: pinoInstance[pino.symbols.messageKeySym],
  levels: pinoInstance.levels,
  // ...
})

pinoInstance[pino.symbols.streamSym] = pino.multistream([
  { level: 0, stream: origStream },
  { level: 0, stream: otelStream },
], { levels: pinoInstance.levels.values })

This would be transparent to users — no changes to config/logger.ts needed.

Alternatively, a simpler fix could be made in @adonisjs/logger: change the bundled import from import { pino } from "pino" (named) to import pino from "pino" (default), which IITM can patch correctly.

Reproduction

1. Create an AdonisJS v7 app with @adonisjs/otel configured with destinations.otlp({ signals: ['traces', 'logs', 'metrics'] })
2. Set OTEL_ENABLED=true and point to an OTLP collector
3. Make HTTP requests — traces and metrics appear in the collector, but no logs

Related issues

• nodejs/import-in-the-middle#38 — Root cause: named export reassignments not propagating
• nodejs/import-in-the-middle#171 — Related: duplicate exports incorrectly excluded

[Julien-R44]

Thanks, will try to reproduce. But all I can say for now is that I already have 4/5 apps running on AdonisJS v7 with OTEL, and I havent run into this issue at all

Just one question: are you using syncDestination() in config/logger.ts? If so, try removing it temporarily just to see whether that changes anything

[jbsn94]

Workaround: Manual OTel log destination via pino.multistream

While this isn't fixed upstream, here's how I solved it on my side by bypassing instrumentation-pino entirely and wiring OTel log emission directly into pino's multistream.

Overview

The approach has three parts:

1. Disable the broken instrumentation-pino log sending and correlation in the OTel config
2. Create a custom pino Writable stream (OtelLogStream) that parses JSON log lines and emits them as OTel LogRecords using @opentelemetry/api-logs
3. Create a custom mixin that injects trace correlation fields (trace_id, span_id, trace_flags) from the active span context

Since both the stream and the mixin run in the main thread, they have direct access to the LoggerProvider configured by @adonisjs/otel — no worker thread issues like with pino-opentelemetry-transport.

1. OTel config — disable instrumentation-pino

// config/otel.ts
import { defineConfig, destinations } from '@adonisjs/otel'

const otelConfig = defineConfig({
  instrumentations: {
    // Disable the broken IITM-based log sending and correlation.
    // We handle both manually via OtelLogStream and createOtelLogMixin.
    '@opentelemetry/instrumentation-pino': {
      disableLogSending: true,
      disableLogCorrelation: true,
    },
  },
  destinations: {
    signoz: destinations.otlp({
      signals: ['traces', 'logs', 'metrics'],
    }),
  },
})

export default otelConfig

2. Custom OTel log destination + mixin

// pino_otel_destination.ts
import { Writable } from 'node:stream'
import { logs, SeverityNumber } from '@opentelemetry/api-logs'
import { trace, context, isSpanContextValid } from '@opentelemetry/api'

const OTEL_SEV_NUM_FROM_PINO_LEVEL: Record<number, SeverityNumber> = {
  10: SeverityNumber.TRACE,
  20: SeverityNumber.DEBUG,
  30: SeverityNumber.INFO,
  40: SeverityNumber.WARN,
  50: SeverityNumber.ERROR,
  60: SeverityNumber.FATAL,
}

const EXTRA_SEV_NUMS: SeverityNumber[] = [
  SeverityNumber.TRACE2, SeverityNumber.TRACE3, SeverityNumber.TRACE4,
  SeverityNumber.DEBUG2, SeverityNumber.DEBUG3, SeverityNumber.DEBUG4,
  SeverityNumber.INFO2,  SeverityNumber.INFO3,  SeverityNumber.INFO4,
  SeverityNumber.WARN2,  SeverityNumber.WARN3,  SeverityNumber.WARN4,
  SeverityNumber.ERROR2, SeverityNumber.ERROR3, SeverityNumber.ERROR4,
  SeverityNumber.FATAL2, SeverityNumber.FATAL3, SeverityNumber.FATAL4,
]

function severityNumberFromPinoLevel(level: number): SeverityNumber {
  const sev = OTEL_SEV_NUM_FROM_PINO_LEVEL[level]
  if (sev !== undefined) return sev

  const relativeLevelWeight = (level - 10) / (70 - 10)
  const otelSevIdx = Math.floor(relativeLevelWeight * EXTRA_SEV_NUMS.length)
  const cappedIdx = Math.min(EXTRA_SEV_NUMS.length - 1, Math.max(0, otelSevIdx))
  return EXTRA_SEV_NUMS[cappedIdx]
}

function millisToHrTime(millis: number): [number, number] {
  const seconds = Math.trunc(millis / 1000)
  const nanos = Math.trunc((millis % 1000) * 1_000_000)
  return [seconds, nanos]
}

const DEFAULT_LEVELS = {
  labels: { 10: 'trace', 20: 'debug', 30: 'info', 40: 'warn', 50: 'error', 60: 'fatal' },
  values: { trace: 10, debug: 20, info: 30, warn: 40, error: 50, fatal: 60 },
}

/**
 * Writable stream that receives serialized JSON log lines from pino
 * and emits them as OpenTelemetry LogRecords.
 *
 * Runs in the main thread so it has access to the global LoggerProvider.
 */
class OtelLogStream extends Writable {
  #messageKey: string
  #levels: { labels: Record<number, string> }
  #otelLogger = logs.getLogger('@m1/adonisjs', '0.0.1')

  lastLevel: number = 30

  constructor(messageKey: string, levels: { labels: Record<number, string> }) {
    super()
    this.#messageKey = messageKey
    this.#levels = levels
  }

  override _write(
    chunk: Buffer | string,
    _encoding: BufferEncoding,
    callback: (error?: Error | null) => void
  ): void {
    if (!chunk) { callback(); return }

    let recObj: Record<string, unknown>
    try {
      recObj = JSON.parse(typeof chunk === 'string' ? chunk : chunk.toString())
    } catch { callback(); return }

    if (recObj === null || typeof recObj !== 'object') { callback(); return }

    const {
      time,
      [this.#messageKey]: body,
      level: _level, hostname: _hostname, pid: _pid,
      trace_id: _traceId, span_id: _spanId, trace_flags: _traceFlags,
      ...attributes
    } = recObj

    let timestamp = typeof time === 'number' ? time : Date.now()
    if (isNaN(timestamp)) { attributes['time'] = time; timestamp = Date.now() }

    const timestampHrTime = millisToHrTime(timestamp)

    this.#otelLogger.emit({
      timestamp: timestampHrTime,
      observedTimestamp: timestampHrTime,
      severityNumber: severityNumberFromPinoLevel(this.lastLevel),
      severityText: this.#levels.labels[this.lastLevel],
      body: body as string,
      attributes: attributes as Record<string, string | number | boolean>,
    })

    callback()
  }
}

/**
 * Mixin that injects trace correlation fields from the active OTel span.
 */
export function createOtelLogMixin() {
  return function otelMixin(): Record<string, string> {
    const span = trace.getSpan(context.active())
    if (!span) return {}

    const spanContext = span.spanContext()
    if (!isSpanContextValid(spanContext)) return {}

    return {
      trace_id: spanContext.traceId,
      span_id: spanContext.spanId,
      trace_flags: `0${spanContext.traceFlags.toString(16)}`,
    }
  }
}

/**
 * Creates a pino destination that sends logs to both stdout and
 * the OTel LoggerProvider via multistream.
 */
export function createOtelLogDestination(
  multistream: (...args: any[]) => any,
  pinoDestination: (...args: any[]) => any,
  options?: {
    messageKey?: string
    levels?: { labels: Record<number, string>; values: Record<string, number> }
  }
) {
  const levels = options?.levels ?? DEFAULT_LEVELS
  const messageKey = options?.messageKey ?? 'msg'

  const otelStream = new OtelLogStream(messageKey, levels)
  ;(otelStream as unknown as Record<symbol, boolean>)[Symbol.for('pino.metadata')] = true

  const stdoutStream = pinoDestination(1)

  return multistream(
    [
      { level: 0, stream: stdoutStream },
      { level: 0, stream: otelStream },
    ],
    { levels: levels.values }
  )
}

3. Logger config — use the custom destination and mixin

// config/logger.ts
import env from '#start/env'
import app from '@adonisjs/core/services/app'
import { defineConfig, destination, multistream, targets } from '@adonisjs/core/logger'
import { otelLoggingPreset } from '@adonisjs/otel/helpers'
import { createOtelLogDestination, createOtelLogMixin } from './pino_otel_destination.js'

const isOtelEnabled = app.inProduction && env.get('OTEL_ENABLED', false)

const loggerConfig = defineConfig({
  default: 'app',

  loggers: {
    app: {
      enabled: true,
      name: env.get('APP_NAME'),
      level: env.get('LOG_LEVEL'),
      ...(isOtelEnabled && {
        destination: createOtelLogDestination(multistream, destination),
        mixin: createOtelLogMixin(),
      }),
      transport: {
        targets: targets()
          .pushIf(!app.inProduction, targets.pretty({ ...otelLoggingPreset() }))
          .pushIf(app.inProduction && !isOtelEnabled, targets.file({ destination: 1 }))
          .toArray(),
      },
    },
  },
})

export default loggerConfig

How it works

• OtelLogStream is a Writable stream that receives serialized JSON from pino, parses each line, maps pino severity levels to OTel SeverityNumber, and emits log records via @opentelemetry/api-logs. It uses Symbol.for('pino.metadata') so pino sets lastLevel on the stream before each write, giving us access to the numeric level.

• createOtelLogMixin replaces the trace correlation that instrumentation-pino would normally inject. It reads the active span context and adds trace_id, span_id, and trace_flags to every log entry, preserving log-to-trace correlation in the collector.

• createOtelLogDestination combines a standard stdout destination with the OtelLogStream into a single pino.multistream, so logs go to both the console and the OTel collector.

Since everything runs in the main thread, the OtelLogStream uses the same LoggerProvider that @adonisjs/otel configures — no conflicts with worker-thread-based transports.

Result

Traces, metrics, and logs all appear correctly in SigNoz with proper correlation. This workaround is transparent to the rest of the app — no changes needed outside of the logger and OTel config files.

[jbsn94]

Thanks, will try to reproduce. But all I can say for now is that I already have 4/5 apps running on AdonisJS v7 with OTEL, and I havent run into this issue at all

Just one question: are you using syncDestination() in config/logger.ts? If so, try removing it temporarily just to see whether that changes anything

I was using syncDestination only for dev, like this:
destination: !app.inProduction ? await syncDestination() : undefined,

[jbsn94]

Thanks, will try to reproduce. But all I can say for now is that I already have 4/5 apps running on AdonisJS v7 with OTEL, and I havent run into this issue at all

Just one question: are you using syncDestination() in config/logger.ts? If so, try removing it temporarily just to see whether that changes anything

This is how was my config/logger.ts before this fix:

import env from '#start/env'
import app from '@adonisjs/core/services/app'
import { defineConfig, syncDestination, targets } from '@adonisjs/core/logger'
import { otelLoggingPreset } from '@adonisjs/otel/helpers'

const loggerConfig = defineConfig({
  /**
   * Default logger name used by ctx.logger and app logger calls.
   */
  default: 'app',

  loggers: {
    app: {
      /**
       * Toggle this logger on/off.
       */
      enabled: true,

      /**
       * Logger name shown in log records.
       */
      name: env.get('APP_NAME'),

      /**
       * Minimum level to output (trace, debug, info, warn, error, fatal).
       */
      level: env.get('LOG_LEVEL'),

      /**
       * Use sync destination in non-production for immediate flush.
       */
      destination: !app.inProduction ? await syncDestination() : undefined,

      /**
       * Configure where logs are written.
       */
      transport: {
        targets: targets()
          .pushIf(!app.inProduction, targets.pretty({ ...otelLoggingPreset() }))
          .pushIf(app.inProduction, targets.file({ destination: 1 }))
          .toArray(),
      },
    },
  },
})

export default loggerConfig

/**
 * Inferring types for the list of loggers you have configured
 * in your application.
 */
declare module '@adonisjs/core/types' {
  export interface LoggersList extends InferLoggers<typeof loggerConfig> {}
}

[Julien-R44]

Okay. but does it works without syncDestination ?

[jbsn94]

Okay. but does it works without syncDestination ?

No, still the same, i don't know if this is important but for deploy i'm using pm2 with this config:

const path = require('path')

module.exports = {
  apps: [
    {
      name: 'auth',
      script: './bin/server.js',
      cwd: path.join(__dirname, 'apps/auth/build'),
      instances: 1,
      exec_mode: 'fork',
      autorestart: true,
      max_memory_restart: '512M',
      env: {
        NODE_ENV: 'production',
      },
    },
    {
      name: 'view',
      script: './bin/server.js',
      cwd: path.join(__dirname, 'apps/view/build'),
      instances: 1,
      exec_mode: 'fork',
      autorestart: true,
      max_memory_restart: '512M',
      env: {
        NODE_ENV: 'production',
      },
    },
  ],
}

I'm using monorepo and pnpm.overrides to keep all adonisjs projects with the same package versions.

[jbsn94]

i also tried to remove destination for dev and prod, and keep the same problem

[jbsn94]

What is stranger to me is when i was using @adonisjs/otel with version 1.2.0 with adonisjs V6 and node 22 was working, the @adonisjs/otel 1.2.1 it is only TS improvements, what make more diference is the upgrade but i had another project created from startkit command with version 7 and had the same problem, both i'm using nodejs 24, could be nodejs 24 a problem?