newrelic 13.0.0 → 13.2.0

package/lib/otel/context.js

@@ -9,9 +9,13 @@ const FakeSpan = require('./fake-span')
 const Context = require('../context-manager/context')
 
 module.exports = class OtelContext extends Context {
-  constructor(transaction, segment, parentContext) {
-    super(transaction, segment)
-    this._otelCtx = parentContext ? new Map(parentContext) : new Map()
+  constructor({ transaction, segment, otelContext, extras } = {}) {
+    super({ transaction, segment, extras })
+    this._otelCtx = otelContext ? new Map(otelContext) : new Map()
+  }
+
+  get otelCtx() {
+    return this._otelCtx
   }
 
   /**
@@ -23,11 +27,11 @@ module.exports = class OtelContext extends Context {
    * @param {Transaction} params.transaction active transaction
    * @returns {OtelContext} a newly constructed context
    */
-  enterSegment({ segment, transaction = this._transaction }) {
+  enterSegment({ segment, transaction = this.transaction }) {
     if (transaction?.agent?.otelSpanKey && segment) {
-      this._otelCtx.set(transaction.agent.otelSpanKey, new FakeSpan(segment, transaction))
+      this.otelCtx.set(transaction.agent.otelSpanKey, new FakeSpan(segment, transaction))
     }
-    return new this.constructor(transaction, segment, this._otelCtx)
+    return new this.constructor({ transaction, segment, otelContext: this.otelCtx, extras: this.extras })
   }
 
   /**
@@ -39,9 +43,9 @@ module.exports = class OtelContext extends Context {
    */
   enterTransaction(transaction) {
     if (transaction?.agent?.otelSpanKey) {
-      this._otelCtx.set(transaction.agent.otelSpanKey, new FakeSpan(transaction.trace.root, transaction))
+      this.otelCtx.set(transaction.agent.otelSpanKey, new FakeSpan(transaction.trace.root, transaction))
     }
-    return new this.constructor(transaction, transaction?.trace?.root, this._otelCtx)
+    return new this.constructor({ transaction, segment: transaction?.trace?.root, otelContext: this.otelCtx, extras: this.extras })
   }
 
   /**
@@ -52,7 +56,7 @@ module.exports = class OtelContext extends Context {
    * @returns {*} The stored value.
    */
   getValue(key) {
-    return this._otelCtx.get(key)
+    return this.otelCtx.get(key)
   }
 
   /**
@@ -69,12 +73,12 @@ module.exports = class OtelContext extends Context {
     if (value[otelSynthesis] && value[otelSynthesis].segment && value[otelSynthesis].transaction) {
       const { segment, transaction } = value[otelSynthesis]
       segment.start()
-      ctx = new this.constructor(transaction, segment, this._otelCtx)
+      ctx = new this.constructor({ transaction, segment, otelContext: this.otelCtx, extras: this.extras })
     } else {
-      ctx = new this.constructor(this._transaction, this._segment, this._otelCtx)
+      ctx = new this.constructor({ transaction: this.transaction, segment: this.segment, otelContext: this.otelCtx, extras: this.extras })
     }
 
-    ctx._otelCtx.set(key, value)
+    ctx.otelCtx.set(key, value)
     return ctx
   }
 
@@ -86,8 +90,8 @@ module.exports = class OtelContext extends Context {
    * @returns {OtelContext} The context object.
    */
   deleteValue(key) {
-    const ctx = new this.constructor(this._transaction, this._segment, this._otelCtx)
-    ctx._otelCtx.delete(key)
+    const ctx = new this.constructor({ transaction: this._transaction, segment: this._segment, otelContext: this.otelCtx, extras: this.extras })
+    ctx.otelCtx.delete(key)
     return ctx
   }
 }

package/lib/otel/logs/bootstrap-logs.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+module.exports = bootstrapOtelLogs
+
+const logsApi = require('@opentelemetry/api-logs')
+const logsSdk = require('@opentelemetry/sdk-logs')
+const defaultLogger = require('#agentlib/logger.js').child({ component: 'otel-logs' })
+const {
+  isApplicationLoggingEnabled,
+  isLogForwardingEnabled,
+  isMetricsEnabled,
+  incrementLoggingLinesMetrics
+} = require('#agentlib/util/application-logging.js')
+
+const NewRelicLoggerProvider = require('./proxying-provider.js')
+const NoOpExporter = require('./no-op-exporter.js')
+const normalizeTimestamp = require('./normalize-timestamp.js')
+const severityToString = require('./severity-to-string.js')
+
+/**
+ * Sets up the OTEL logging system and instruments it in such a fashion
+ * that logs are shipped to New Relic when logs forwarding is enabled.
+ *
+ * The API, as of 2025-07, is in development. We should expect changes that
+ * will require significant refactoring here. For example, we might need to
+ * accept instances of various components, e.g. record processors, in order
+ * for customer apps to work as they expect.
+ *
+ * @param {object} params Factory function parameters.
+ * @param {Agent} params.agent The Node.js agent instance.
+ * @param {object} [params.logger] An agent logger instance.
+ */
+function bootstrapOtelLogs({ agent, logger = defaultLogger } = {}) {
+  if (isApplicationLoggingEnabled(agent.config) === false) {
+    logger.info('application logging disabled, skipping otel logs setup')
+    return
+  }
+
+  agent.metrics
+    .getOrCreateMetric('Supportability/Nodejs/OpenTelemetryBridge/Logs')
+    .incrementCallCount()
+
+  const exporter = new NoOpExporter()
+  const processor = new logsSdk.BatchLogRecordProcessor(exporter)
+  const otelProvider = new logsSdk.LoggerProvider({
+    processors: [processor]
+  })
+  const provider = new NewRelicLoggerProvider({
+    agent,
+    provider: otelProvider,
+    emitHandler: nrEmitHandler
+  })
+  logsApi.logs.setGlobalLoggerProvider(provider)
+
+  function nrEmitHandler(record) {
+    const level = severityToString(record.severityNumber ?? 0)
+    if (isMetricsEnabled(agent.config) === true) {
+      incrementLoggingLinesMetrics(level, agent.metrics)
+    }
+
+    // TODO: if we decide to support local decorating, implement it here
+
+    if (isLogForwardingEnabled(agent.config, agent) === true) {
+      const meta = agent.getLinkingMetadata(true)
+      const timestamp = normalizeTimestamp(record.timestamp)
+      const logData = {
+        message: record.body,
+        level,
+        timestamp,
+        ...record.attributes,
+        ...meta
+      }
+
+      agent.logs.add(logData)
+    }
+  }
+
+  agent.emit('otelLogsBootstrapped')
+}

package/lib/otel/logs/no-op-exporter.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const { ExportResultCode } = require('@opentelemetry/core')
+
+/**
+ * @see https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_sdk-node.logs.LogRecordExporter.html
+ */
+class NewRelicNoOpExporter {
+  export(_, done) {
+    if (typeof done === 'function') {
+      done(ExportResultCode.SUCCESS)
+    }
+  }
+
+  shutdown() {
+    return Promise.resolve()
+  }
+}
+
+module.exports = NewRelicNoOpExporter

package/lib/otel/logs/normalize-timestamp.js

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+module.exports = normalizeTimestamp
+
+const {
+  isTimeInputHrTime
+} = require('@opentelemetry/core')
+
+/**
+ * Returns a normalized epoch in milliseconds based upon the value provided
+ * to the logger's `emit` method (if it was provided). The emit method receives
+ * a `LogRecord` instance. In the upstream code, a `LogRecord` is supposed to
+ * have a nanosecond epoch delta. But we are receiving it from user code. So
+ * it is possible for the value to be a variety of different kinds.
+ *
+ * @see https://github.com/open-telemetry/opentelemetry-js/blob/99dde77/api/src/common/Time.ts#L39
+ * @see https://github.com/open-telemetry/opentelemetry-js/blob/99dde77/packages/opentelemetry-core/src/common/time.ts#L61-L83
+ *
+ * @param {number[]|number|Date|undefined} input The value from the logger.
+ *
+ * @returns {number}
+ */
+function normalizeTimestamp(input) {
+  if (typeof input === 'number' && input >= 10_000_000_000_000_000) {
+    // Looks like a nanosecond epoch delta.
+    return Math.floor(input / 1_000_000)
+  }
+
+  if (typeof input === 'number' && input >= 100_000_000_000_000) {
+    // Looks like a microsecond epoch delta.
+    return Math.floor(input / 1_000)
+  }
+
+  if (typeof input === 'number' && input >= 100_000_000_000) {
+    // Looks like a millisecond epoch delta.
+    return input
+  }
+
+  if (isTimeInputHrTime(input) === true) {
+    // It's unclear why upstream tries to support a `process.hrtime()` value.
+    // Such tuples are relative to an arbitrary point in time, not the Unix
+    // epoch. So there's no way to determine an actual wall clock time and date
+    // from such input. For lack of a better solution, we'll return the
+    // current epoch in this case.
+    return Date.now()
+  }
+
+  if (Object.getPrototypeOf(input) === Date.prototype) {
+    return input.getTime()
+  }
+
+  // We don't know what they've given us, so just return the current time.
+  return Date.now()
+}

package/lib/otel/logs/proxying-provider.js

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const symLogPatched = Symbol('nr.log.patched')
+
+/**
+ * Provides a logger provider that proxies to another logger provider.
+ * This allows us to intercept loggers as they are retrieved so that we can
+ * patch their `emit` method to do what we need.
+ *
+ * @see https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api-logs.LoggerProvider.html
+ */
+class NewRelicLoggerProvider {
+  #provider
+  #emitHandler
+
+  constructor({ provider, emitHandler }) {
+    this.#provider = provider
+    this.#emitHandler = emitHandler
+  }
+
+  getLogger(name, version, options) {
+    const logger = this.#provider.getLogger(name, version, options)
+    const emit = logger.emit
+    const handler = this.#emitHandler
+
+    // Logger has already been patched, so just return it.
+    if (logger[symLogPatched] === true) {
+      return logger
+    }
+
+    logger.emit = function nrEmitWrapper(record) {
+      handler(record)
+      return emit.apply(this, arguments)
+    }
+
+    logger[symLogPatched] = true
+    return logger
+  }
+}
+
+module.exports = NewRelicLoggerProvider

package/lib/otel/logs/severity-to-string.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+module.exports = severityToString
+
+const SEV_UNKNOWN = 'unknown'
+const SEV_TRACE = 'trace'
+const SEV_DEBUG = 'debug'
+const SEV_INFO = 'info'
+const SEV_WARN = 'warn'
+const SEV_ERROR = 'error'
+const SEV_FATAL = 'fatal'
+const severityMap = new Map([
+  [0, SEV_UNKNOWN],
+  [1, SEV_TRACE],
+  [2, SEV_TRACE],
+  [3, SEV_TRACE],
+  [4, SEV_TRACE],
+  [5, SEV_DEBUG],
+  [6, SEV_DEBUG],
+  [7, SEV_DEBUG],
+  [8, SEV_DEBUG],
+  [9, SEV_INFO],
+  [10, SEV_INFO],
+  [11, SEV_INFO],
+  [12, SEV_INFO],
+  [13, SEV_WARN],
+  [14, SEV_WARN],
+  [15, SEV_WARN],
+  [16, SEV_WARN],
+  [17, SEV_ERROR],
+  [18, SEV_ERROR],
+  [19, SEV_ERROR],
+  [20, SEV_ERROR],
+  [21, SEV_FATAL],
+  [22, SEV_FATAL],
+  [23, SEV_FATAL],
+  [24, SEV_FATAL]
+])
+
+/**
+ * Converts the OTEL severity number to a recognizable string.
+ *
+ * @see https://github.com/open-telemetry/opentelemetry-specification/blob/c041658/specification/logs/data-model.md?plain=1#L292-L299
+ *
+ * @param {number} severityNumber The number to convert.
+ *
+ * @returns {string} The known string.
+ */
+function severityToString(severityNumber) {
+  return severityMap.get(severityNumber) ?? SEV_UNKNOWN
+}

package/lib/otel/metrics/bootstrap-metrics.js

@@ -52,7 +52,7 @@ function bootstrapOtelMetrics(agent) {
 
     const meter = getMeter.apply(provider, args)
     const proto = Object.getPrototypeOf(meter)
-    const methods = Object.getOwnPropertyNames(proto).filter(name => name.startsWith('create'))
+    const methods = Object.getOwnPropertyNames(proto).filter((name) => name.startsWith('create'))
     const originals = {}
     for (const method of methods) {
       originals[method] = meter[method]

package/lib/otel/setup.js

@@ -6,6 +6,7 @@
 'use strict'
 
 const opentelemetry = require('@opentelemetry/api')
+const logsApi = require('@opentelemetry/api-logs')
 const { BasicTracerProvider } = require('@opentelemetry/sdk-trace-base')
 
 const NrSpanProcessor = require('./span-processor')
@@ -16,6 +17,7 @@ const defaultLogger = require('../logger').child({ component: 'opentelemetry-bri
 const createOtelLogger = require('./logger')
 const interceptSpanKey = require('./span-key-interceptor')
 const bootstrapMetrics = require('./metrics/bootstrap-metrics')
+const bootstrapLogs = require('./logs/bootstrap-logs')
 
 function setupOtel(agent, logger = defaultLogger) {
   if (agent.config.opentelemetry_bridge.enabled !== true) {
@@ -25,8 +27,18 @@ function setupOtel(agent, logger = defaultLogger) {
     return
   }
 
+  // When bridge mode is enabled, our context manager must utilize the OTEL
+  // context manager. Otherwise, traces within, e.g. logs, will not be
+  // captured correctly. The internal OTEL logger also must be configured
+  // for the OTEL context manager to generate diagnostics messages that get
+  // delivered to the correct place.
+  createOtelLogger(logger, agent.config)
+  interceptSpanKey(agent)
+  opentelemetry.context.setGlobalContextManager(new ContextManager(agent))
+  opentelemetry.propagation.setGlobalPropagator(new TracePropagator(agent))
+
   if (agent.config.opentelemetry_bridge.traces.enabled === true) {
-    bootstrapTraces(agent, logger)
+    bootstrapTraces(agent)
   } else {
     logger.debug('`opentelemetry_bridge.traces` is not enabled, skipping')
   }
@@ -37,14 +49,18 @@ function setupOtel(agent, logger = defaultLogger) {
     logger.debug('`opentelemetry_bridge.metrics` is not enabled, skipping')
   }
 
+  if (agent.config.opentelemetry_bridge.logs.enabled === true) {
+    bootstrapLogs({ agent })
+  } else {
+    logger.debug('`opentelemetry_bridge.logs` is not enabled, skipping')
+  }
+
   agent.metrics
     .getOrCreateMetric('Supportability/Nodejs/OpenTelemetryBridge/Setup')
     .incrementCallCount()
 }
 
-function bootstrapTraces(agent, logger) {
-  createOtelLogger(logger, agent.config)
-
+function bootstrapTraces(agent) {
   opentelemetry.trace.setGlobalTracerProvider(new BasicTracerProvider({
     sampler: new NrSampler(),
     spanProcessors: [new NrSpanProcessor(agent)],
@@ -53,10 +69,6 @@ function bootstrapTraces(agent, logger) {
     }
   }))
 
-  interceptSpanKey(agent)
-  opentelemetry.context.setGlobalContextManager(new ContextManager(agent))
-  opentelemetry.propagation.setGlobalPropagator(new TracePropagator(agent))
-
   agent.metrics
     .getOrCreateMetric('Supportability/Nodejs/OpenTelemetryBridge/Traces')
     .incrementCallCount()
@@ -71,6 +83,7 @@ function teardownOtel(agent) {
   opentelemetry.context.disable()
   opentelemetry.propagation.disable()
   opentelemetry.diag.disable()
+  logsApi.logs.disable()
 }
 
 module.exports = {

package/lib/patch-module.js

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const { create } = require('@apm-js-collab/code-transformer')
+const Module = require('node:module')
+const parse = require('module-details-from-path')
+const getPackageVersion = require('./util/get-package-version')
+const logger = require('./logger').child({ component: 'ModulePatch' })
+
+class ModulePatch {
+  constructor({ packages = new Set(), instrumentations = [] } = {}) {
+    this.packages = packages
+    this.instrumentator = create(instrumentations)
+    this.transformers = new Map()
+    this.resolve = Module._resolveFilename
+    this.compile = Module.prototype._compile
+  }
+
+  /**
+   * Patches the Node.js module class methods that are responsible for resolving filePaths and compiling code.
+   * If a module is found that has an instrumentator, it will transform the code before compiling it
+   * with tracing channel methods.
+   */
+  patch() {
+    const self = this
+    Module._resolveFilename = function wrappedResolveFileName() {
+      const resolvedName = self.resolve.apply(this, arguments)
+      const resolvedModule = parse(resolvedName)
+      if (resolvedModule && self.packages.has(resolvedModule.name)) {
+        const version = getPackageVersion(resolvedModule.basedir, resolvedModule.name)
+        const transformer = self.instrumentator.getTransformer(resolvedModule.name, version, resolvedModule.path)
+        if (transformer) {
+          self.transformers.set(resolvedName, transformer)
+        }
+      }
+      return resolvedName
+    }
+
+    Module.prototype._compile = function wrappedCompile(...args) {
+      const [content, filename] = args
+      if (self.transformers.has(filename)) {
+        const transformer = self.transformers.get(filename)
+        try {
+          const transformedCode = transformer.transform(content, 'unknown')
+          args[0] = transformedCode
+        } catch (error) {
+          logger.error({ error }, `Error transforming module ${filename}`)
+        } finally {
+          transformer.free()
+        }
+      }
+
+      return self.compile.apply(this, args)
+    }
+  }
+
+  /**
+   * Clears all the transformers and restores the original Module methods that were wrapped.
+   * **Note**: This is intended to be used in testing only.
+   */
+  unpatch() {
+    this.transformers.clear()
+    Module._resolveFilename = this.resolve
+    Module.prototype._compile = this.compile
+  }
+}
+
+module.exports = ModulePatch

package/lib/serverless/aws-lambda.js

@@ -54,9 +54,7 @@ class AwsLambda {
   }
 
   _detectEventType(event) {
-    const pathMatch = (obj, path) => {
-      return get(obj, path, null) !== null
-    }
+    const pathMatch = (obj, path) => get(obj, path, null) !== null
 
     for (const typeInfo of Object.values(EVENT_SOURCE_INFO)) {
       if (typeInfo.required_keys.every((path) => pathMatch(event, path))) {

package/lib/shim/webframework-shim/middleware-mounter.js

@@ -34,9 +34,7 @@ function wrapMounter(spec, shim, fn, fnName) {
         routeIdx = null
         route = null
       } else if (shim.isArray(route)) {
-        route = route.map((routeArg) => {
-          return shim._routeParser.call(this, shim, fn, fnName, routeArg)
-        })
+        route = route.map((routeArg) => shim._routeParser.call(this, shim, fn, fnName, routeArg))
       } else {
         route = shim._routeParser.call(this, shim, fn, fnName, route)
       }

package/lib/shimmer.js

@@ -23,7 +23,9 @@ let pkgsToHook = []
 const NAMES = require('./metrics/names')
 const symbols = require('./symbols')
 const { unsubscribe } = require('./instrumentation/undici')
-const { setupOtel, teardownOtel } = require('./otel/setup')
+const subscriptions = require('./subscriber-configs')
+const createSubscriberConfigs = require('./subscribers/create-config')
+const ModulePatch = require('./patch-module')
 
 /**
  * Unwrapping is only likely to be used by test code, and is a fairly drastic
@@ -329,14 +331,32 @@ const shimmer = (module.exports = {
     }
 
     pkgsToHook = []
-    teardownOtel(agent)
+    if (agent?.config?.opentelemetry_bridge?.enabled === true) {
+      // We must lazy load the method in order to support stripping of the
+      // `@opentelemetry` packages for slim builds.
+      require('./otel/setup').teardownOtel(agent)
+    }
     unsubscribe()
+    if (this._subscribers) {
+      shimmer.teardownSubscribers()
+    }
+    if (this._modulePatch) {
+      this._modulePatch.unpatch()
+    }
   },
 
   bootstrapInstrumentation: function bootstrapInstrumentation(agent) {
+    const subscriberConfigs = createSubscriberConfigs(subscriptions)
+    this._modulePatch = new ModulePatch(subscriberConfigs)
+    this._modulePatch.patch()
     shimmer.registerCoreInstrumentation(agent)
     shimmer.registerThirdPartyInstrumentation(agent)
-    setupOtel(agent)
+    shimmer.setupSubscribers(agent)
+    if (agent?.config?.opentelemetry_bridge?.enabled === true) {
+      // We must lazy load the method in order to support stripping of the
+      // `@opentelemetry` packages for slim builds.
+      require('./otel/setup').setupOtel(agent)
+    }
   },
 
   registerInstrumentation: function registerInstrumentation(opts) {
@@ -371,6 +391,35 @@ const shimmer = (module.exports = {
 
   registeredInstrumentations: new InstrumentationTracker(),
 
+  setupSubscribers: function setupSubscribers(agent) {
+    this._subscribers = {}
+    for (const subscriberConfigList of Object.values(subscriptions)) {
+      for (const subscriberConfig of subscriberConfigList) {
+        const Subscriber = require(`./subscribers/${subscriberConfig.path}`)
+        const subscriber = new Subscriber({ agent, logger })
+        if (subscriber.enabled === false) {
+          logger.debug(
+            'Skipping subscriber %s because it is disabled in the config',
+            subscriber.id
+          )
+          continue
+        }
+
+        subscriber.enable()
+        subscriber.subscribe()
+        this._subscribers[subscriber.id] = subscriber
+      }
+    }
+  },
+
+  teardownSubscribers: function teardownSubscribers() {
+    for (const subscriber of Object.values(this._subscribers)) {
+      subscriber.disable()
+      subscriber.unsubscribe()
+    }
+    this._subscribers = {}
+  },
+
   /**
    * NOT FOR USE IN PRODUCTION CODE
    *
@@ -432,8 +481,7 @@ const shimmer = (module.exports = {
   isInstrumented(moduleName, resolvedName) {
     const allItems = shimmer.registeredInstrumentations.getAllByName(moduleName)
     const items = allItems.filter(
-      (item) =>
-        item.instrumentation.resolvedName === resolvedName && item.meta.instrumented === true
+      (item) => item.instrumentation.resolvedName === resolvedName && item.meta.instrumented === true
     )
     return items.length === allItems.length
   },
@@ -669,12 +717,12 @@ function _firstPartyInstrumentation(agent, fileName, shim, nodule, moduleName) {
  * to load the module), as well as the `onRequire` and `onError` hooks to
  * attach to the module.
  *
- * @param {object} agent
+ * @param {object} agent agent instance
  * @param {object} nodule The newly loaded module.
  * @param {string} name The simple name used to load the module.
  * @param {string} resolvedName The full file system path to the module.
- * @param {object} [esmResolver]
- * @returns {*|Object|undefined}
+ * @param {object} [esmResolver] If the module was loaded via ESM
+ * @returns {*|Object|undefined} The instrumented module, or the original
  * @private
  */
 function _postLoad(agent, nodule, name, resolvedName, esmResolver) {

package/lib/subscriber-configs.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+// The expected export of these files is:
+// 'package-name': [ { path: 'subscriberPath', instrumentations: [] }, ... ]
+const subscribers = {
+  ...require('./subscribers/elasticsearch/config'),
+  ...require('./subscribers/ioredis/config'),
+  ...require('./subscribers/mcp-sdk/config'),
+  ...require('./subscribers/pino/config'),
+}
+
+module.exports = subscribers