newrelic 13.7.0 → 13.8.1

package/NEWS.md

@@ -1,3 +1,41 @@
+### v13.8.1 (2025-12-15)
+
+#### Bug fixes
+
+* Updated AWS Lambda instrumentation to skip wrapping handler callback if not present ([#3602](https://github.com/newrelic/node-newrelic/pull/3602)) ([d56e27d](https://github.com/newrelic/node-newrelic/commit/d56e27d5764b4c0a7d513fffa3310148d7cebea6))
+
+#### Documentation
+
+* Updated compatibility report ([#3596](https://github.com/newrelic/node-newrelic/pull/3596)) ([ed24527](https://github.com/newrelic/node-newrelic/commit/ed24527cfd2e836de67a769cbeaa63683b207506))
+
+### v13.8.0 (2025-12-11)
+
+#### Features
+
+* Added support for `@langchain/aws` ([#3563](https://github.com/newrelic/node-newrelic/pull/3563)) ([56c4a78](https://github.com/newrelic/node-newrelic/commit/56c4a782c7e05d94dc78ec0bd5eed19bfcc8a835))
+* Additional support for partial granularity traces (Not available for production use)
+    * Added partial granularity tracking metrics ([#3566](https://github.com/newrelic/node-newrelic/pull/3566)) ([061f0fc](https://github.com/newrelic/node-newrelic/commit/061f0fca7e61b24fe08cb55538df4c4326c7dd69))
+    * updated `AlwaysOn` sampler to set priority to 3 for full trace and 2 for partial trace ([#3577](https://github.com/newrelic/node-newrelic/pull/3577)) ([e7bcff4](https://github.com/newrelic/node-newrelic/commit/e7bcff4364b5ea8a8af7a7ee58ff05e9e2edb977))
+    * Updated the span generation process ([#3585](https://github.com/newrelic/node-newrelic/pull/3585)) ([74777d5](https://github.com/newrelic/node-newrelic/commit/74777d5f7bfc182f5e36480a9bce1b67db13ce45))
+
+#### Code refactoring
+
+* Converted AWS Bedrock's `LlmError` to use `LlmErrorMessage` ([#3567](https://github.com/newrelic/node-newrelic/pull/3567)) ([8b2bb42](https://github.com/newrelic/node-newrelic/commit/8b2bb428eb3830b7cee4fa30e77a9562628fdd01))
+* Updated `@google/genai` instrumentation to subscribe to events emitted ([#3467](https://github.com/newrelic/node-newrelic/pull/3467)) ([e8d9ba1](https://github.com/newrelic/node-newrelic/commit/e8d9ba188b4399604c6410b2fca406f8d7f338b5))
+* Updated `bunyan` instrumentation to subscribe to events emitted ([#3589](https://github.com/newrelic/node-newrelic/pull/3589)) ([f1e5f12](https://github.com/newrelic/node-newrelic/commit/f1e5f129594a4c3acd8075604bae52013555cf52))
+
+#### Documentation
+
+* Updated compatibility report ([#3592](https://github.com/newrelic/node-newrelic/pull/3592)) ([7455533](https://github.com/newrelic/node-newrelic/commit/7455533e64d88233adf5aa0246261417049c2122))
+
+#### Miscellaneous chores
+
+* Refactor span link serialization ([#3574](https://github.com/newrelic/node-newrelic/pull/3574)) ([103044d](https://github.com/newrelic/node-newrelic/commit/103044d25a968649bdb0e39df054757163cd986f))
+
+#### Tests
+
+* Moved mock aws bedrock server creation to `test/lib/aws-server-stubs/index.js` ([#3593](https://github.com/newrelic/node-newrelic/pull/3593)) ([270df81](https://github.com/newrelic/node-newrelic/commit/270df8109a2adbcb3ff405030e2be7104bee6511))
+
 ### v13.7.0 (2025-12-08)
 
 #### Features

package/lib/instrumentation/aws-sdk/v3/bedrock.js

@@ -8,7 +8,7 @@ const {
   LlmChatCompletionMessage,
   LlmChatCompletionSummary,
   LlmEmbedding,
-  LlmError,
+  LlmErrorMessage,
   BedrockCommand,
   BedrockResponse,
   StreamHandler
@@ -174,8 +174,13 @@ function recordChatCompletionMessages({
   recordEvent({ agent, type: 'LlmChatCompletionSummary', msg: summary })
 
   if (err) {
-    const llmError = new LlmError({ bedrockResponse, err, summary })
-    agent.errors.add(transaction, err, llmError)
+    const llmErrorMessage = new LlmErrorMessage(
+      { response: bedrockResponse,
+        cause: err,
+        summary,
+        useNameAsCode: true }
+    )
+    agent.errors.add(transaction, err, llmErrorMessage)
   }
 }
 
@@ -221,8 +226,13 @@ function recordEmbeddingMessage({
   }
 
   if (err) {
-    const llmError = new LlmError({ bedrockResponse, err, embedding: embeddings.length === 1 ? embeddings[0] : undefined })
-    agent.errors.add(transaction, err, llmError)
+    const llmErrorMessage = new LlmErrorMessage(
+      { response: bedrockResponse,
+        cause: err,
+        embedding: embeddings.length === 1 ? embeddings[0] : undefined,
+        useNameAsCode: true }
+    )
+    agent.errors.add(transaction, err, llmErrorMessage)
   }
 }
 
@@ -293,14 +303,7 @@ function getBedrockSpec({ commandName }, shim, _original, _name, args) {
             onComplete: handleResponse,
             passThroughParams
           })
-          response.output = {
-            ...response.output ?? {},
-            output: {
-              message: {
-                content: handler.generator(handleResponse)
-              }
-            }
-          }
+          response.output.stream = handler.generator(handleResponse)
         } else {
           const handler = new StreamHandler({
             stream: response.output.body,

package/lib/instrumentation/langchain/runnable.js

@@ -153,7 +153,12 @@ function wrapNextHandler({ shim, output, segment, transaction, request, metadata
             shim
           })
         } else {
-          content += result.value
+          if (typeof result?.value?.content === 'string') {
+            // if result.value is a AIMessageChunk
+            content += result.value.content
+          } else {
+            content += result.value
+          }
         }
         return result
       } catch (error) {

package/lib/instrumentations.js

@@ -11,7 +11,6 @@ const InstrumentationDescriptor = require('./instrumentation-descriptor')
 module.exports = function instrumentations() {
   return {
     '@azure/functions': { type: InstrumentationDescriptor.TYPE_GENERIC },
-    '@google/genai': { type: InstrumentationDescriptor.TYPE_GENERIC },
     '@grpc/grpc-js': { module: './instrumentation/grpc-js' },
     '@hapi/hapi': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     '@hapi/vision': { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
@@ -21,7 +20,6 @@ module.exports = function instrumentations() {
     '@redis/client': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     'aws-sdk': { module: './instrumentation/aws-sdk' },
     bluebird: { type: InstrumentationDescriptor.TYPE_PROMISE },
-    bunyan: { type: InstrumentationDescriptor.TYPE_GENERIC },
     connect: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     fastify: { type: InstrumentationDescriptor.TYPE_WEB_FRAMEWORK },
     'generic-pool': { type: InstrumentationDescriptor.TYPE_GENERIC },

package/lib/llm-events/aws-bedrock/index.js

@@ -12,7 +12,7 @@ module.exports = {
   LlmChatCompletionSummary: require('./chat-completion-summary'),
   LlmEmbedding: require('./embedding'),
   LlmEvent: require('./event'),
-  LlmError: require('./error'),
+  LlmErrorMessage: require('../error-message'),
   StreamHandler: require('./stream-handler'),
   ConverseStreamHandler: require('./converse-stream-handler')
 }

package/lib/llm-events/error-message.js

@@ -12,8 +12,8 @@
 module.exports = class LlmErrorMessage {
   /**
    * @param {object} params Constructor parameters
-   * @param {object} [params.response] Instance of an incoming message.
-   * @param {object} [params.cause] An instance of the OpenAI error object.
+   * @param {object} params.response Instance of an incoming message.
+   * @param {object} params.cause An instance of the LLM error object.
    * @param {LlmChatCompletionSummary} [params.summary] Details about the
    * conversation if it was a chat completion conversation.
    * @param {LlmEmbedding} [params.embedding] Details about the conversation
@@ -21,34 +21,46 @@ module.exports = class LlmErrorMessage {
    * @param {LlmVectorStoreSearch} [params.vectorsearch] Details about the vector
    * search if it was a vector search event.
    * @param {LlmTool} [params.tool] Details about the tool event if it was a tool event.
+   * @param {boolean} [params.useNameAsCode] defaults to false, only Bedrock sets it to true so far
    */
-  constructor({ response, cause, summary, embedding, vectorsearch, tool } = {}) {
-    // For @google/genai only, cause does not have the `error` or `status` fields,
-    // but it does have `message` with the info we need. So, we need to parse
-    // the relevant fields from cause.message to get `status` and `error`.
-    let parsedError
-    const isGeminiVendor = embedding?.vendor === 'gemini' || summary?.vendor === 'gemini'
-    if (isGeminiVendor && cause?.message) {
-      try {
-        // Extract the JSON portion of the cause.message
-        const jsonStartIndex = cause.message.indexOf('{')
-        const jsonString = cause.message.substring(jsonStartIndex)
-        parsedError = JSON.parse(jsonString)?.error
-      } catch {
-        parsedError = undefined
-      }
-    }
-    this['http.statusCode'] = response?.status ?? cause?.status ?? parsedError?.code
+  constructor({ response, cause, summary = {}, embedding = {}, vectorsearch = {}, tool = {}, useNameAsCode = false } = {}) {
+    this['http.statusCode'] = response?.statusCode ?? response?.status ?? cause?.status
     this['error.message'] = cause?.message
-    this['error.code'] = response?.code ?? cause?.error?.code ?? parsedError?.code
+    this['error.code'] = response?.code ?? cause?.error?.code
+    if (useNameAsCode) {
+      this['error.code'] = cause?.name
+    }
     this['error.param'] = response?.param ?? cause?.error?.param
     this.completion_id = summary?.id
     this.embedding_id = embedding?.id
     this.vector_store_id = vectorsearch?.id
     this.tool_id = tool?.id
+
+    if (embedding?.vendor === 'gemini' || summary?.vendor === 'gemini') {
+      this._handleGemini(cause)
+    }
   }
 
   get [Symbol.toStringTag]() {
     return 'LlmErrorMessage'
   }
+
+  /**
+   * For `@google/genai` only, `cause` does not have the `error` or `status` fields,
+   * but it does have `message` with the info we need. So, we need to parse
+   * the relevant fields from cause.message to get `status` and `error`.
+   * @param {object} cause error object
+   */
+  _handleGemini(cause) {
+    if (cause?.message) {
+      try {
+        const jsonStartIndex = cause.message.indexOf('{')
+        const jsonString = cause.message.substring(jsonStartIndex)
+        const parsedError = JSON.parse(jsonString)?.error
+
+        this['http.statusCode'] = parsedError?.code
+        this['error.code'] = parsedError?.code
+      } catch { }
+    }
+  }
 }

package/lib/metrics/names.js

@@ -291,11 +291,16 @@ const DISTRIBUTED_TRACE = {
 
 const SPAN_EVENT_PREFIX = 'SpanEvent/'
 
+const PARTIAL_GRANULARITY = 'DistributedTrace/PartialGranularity'
+
 const SPAN_EVENTS = {
   SEEN: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'TotalEventsSeen',
   SENT: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'TotalEventsSent',
   DROPPED: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'Discarded',
-  LIMIT: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'Limit'
+  LIMIT: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'Limit',
+  PARTIAL_PREFIX: SUPPORTABILITY.PREFIX + PARTIAL_GRANULARITY,
+  KEPT: '/Span/Kept',
+  INSTRUMENTED: '/Span/Instrumented',
 }
 
 const INFINITE_TRACING = {

package/lib/samplers/always-on-sampler.js

@@ -9,7 +9,7 @@ class AlwaysOnSampler extends Sampler {
   applySamplingDecision({ transaction, partialType }) {
     if (!transaction) return
     transaction.partialType = partialType
-    transaction.priority = 2.0
+    transaction.priority = partialType ? 2.0 : 3.0
     transaction.sampled = true
   }
 }

package/lib/samplers/index.js

@@ -10,6 +10,7 @@ const AlwaysOffSampler = require('./always-off-sampler')
 const AlwaysOnSampler = require('./always-on-sampler')
 const TraceIdRatioBasedSampler = require('./ratio-based-sampler')
 const logger = require('../logger').child({ component: 'samplers' })
+const { PARTIAL_TYPES } = require('../transaction')
 
 /**
  * Manages the different samplers used for distributed tracing sampling decisions.
@@ -30,7 +31,7 @@ class Samplers {
   constructor(agent) {
     this.fullEnabled = agent.config.distributed_tracing.enabled && agent.config.distributed_tracing.sampler.full_granularity.enabled
     this.partialEnabled = agent.config.distributed_tracing.enabled && agent.config.distributed_tracing.sampler.partial_granularity.enabled
-    this.partialType = agent.config.distributed_tracing.sampler.partial_granularity.type
+    this.partialType = PARTIAL_TYPES[agent.config.distributed_tracing.sampler.partial_granularity.type.toUpperCase()]
     this.adaptiveSampler = null
     this.root = this.determineSampler({ agent, sampler: 'root' })
     this.remoteParentSampled = this.determineSampler({ agent, sampler: 'remote_parent_sampled' })

package/lib/samplers/ratio-based-sampler.js

@@ -13,7 +13,6 @@ const Sampler = require('./sampler')
 class TraceIdRatioBasedSampler extends Sampler {
   /**
    * @param {object} opts Sampler options.
-   * @param {Agent} opts.agent - The New Relic agent instance.
    * @param {number} opts.ratio - The sampling ratio (0 to 1).
    */
   constructor(opts) {

package/lib/serverless/aws-lambda.js

@@ -200,14 +200,13 @@ class AwsLambda {
         return handler.apply(this, args)
       }
 
-      const event = args[0]
-      const context = args[2]
+      const [event, responseStream, context] = args
       logger.trace('In stream handler, lambda function name', context?.functionName)
       const { segment, txnEnder } = awsLambda.createSegment({ context, event, transaction, recorder: recordBackground })
       args[1] = awsLambda.wrapStreamAndCaptureError(
         transaction,
         txnEnder,
-        args[1]
+        responseStream
       )
 
       let res
@@ -238,8 +237,7 @@ class AwsLambda {
         return handler.apply(this, args)
       }
 
-      const event = args[0]
-      const context = args[1]
+      const [event, context, callback] = args
       logger.trace('Lambda function name', context?.functionName)
       const isApiGatewayLambdaProxy = apiGateway.isLambdaProxyEvent(event)
       logger.trace('Is this Lambda event an API Gateway or ALB web proxy?', isApiGatewayLambdaProxy)
@@ -256,16 +254,24 @@ class AwsLambda {
         setWebRequest(transaction, webRequest)
         resultProcessor = getApiGatewayLambdaProxyResultProcessor(transaction)
       }
-      const cbIndex = args.length - 1
-      args[cbIndex] = awsLambda.wrapCallbackAndCaptureError(
-        transaction,
-        txnEnder,
-        args[cbIndex],
-        resultProcessor
-      )
+
+      if (typeof callback === 'function') {
+        logger.trace('Wrapping Lambda handler callback')
+        const cbIndex = args.length - 1
+        args[cbIndex] = awsLambda.wrapCallbackAndCaptureError(
+          transaction,
+          txnEnder,
+          callback,
+          resultProcessor
+        )
+      } else {
+        logger.trace('Lambda handler callback not present, skip wrapping')
+      }
 
       // context.{done,fail,succeed} are all considered deprecated by
       // AWS, but are considered functional.
+      // TODO: Remove when we drop Node.js 22
+      // see: https://aws.amazon.com/blogs/compute/node-js-24-runtime-now-available-in-aws-lambda/
       context.done = awsLambda.wrapCallbackAndCaptureError(transaction, txnEnder, context.done)
       context.fail = awsLambda.wrapCallbackAndCaptureError(transaction, txnEnder, context.fail)
       shim.wrap(context, 'succeed', function wrapSucceed(shim, original) {

package/lib/spans/span-event-aggregator.js

@@ -35,8 +35,23 @@ class SpanEventAggregator extends EventAggregator {
       reservoir_size: events.limit,
       events_seen: events.seen
     }
+
     const eventData = events.toArray()
-    return [this.runId, metrics, eventData]
+    const eventsPayload = []
+    for (const event of eventData) {
+      eventsPayload.push(event)
+
+      if (event.spanLinks.length > 0) {
+        Array.prototype.push.apply(eventsPayload, event.spanLinks)
+        delete event.spanLinks
+      }
+    }
+
+    return [this.runId, metrics, eventsPayload]
+  }
+
+  toString() {
+    return 'SpanEventAggregator'
   }
 
   start() {
@@ -75,16 +90,22 @@ class SpanEventAggregator extends EventAggregator {
 
       return false
     }
-    const span = SpanEvent.fromSegment({ segment, transaction, parentId, isRoot, inProcessSpans: this.inProcessSpans })
 
-    if (span) {
-      this.add(span, transaction.priority)
-    }
+    const span = SpanEvent.fromSegment({ segment, transaction, parentId, isRoot, inProcessSpans: this.inProcessSpans })
 
-    if (segment.spanLinks.length > 0) {
-      for (const link of segment.spanLinks) {
-        this.add(link, transaction.priority)
+    // Do not add span to aggregator if it is part of a partial trace
+    // We need to reparent spans or in the case of `compact`, associate
+    // all exit spans dropped to the same entity as `nr.ids` and `nr.durations`
+    if (transaction.partialType) {
+      const prefix = `${this._metricNames.PARTIAL_PREFIX}/${transaction.partialType}`
+      this._metrics.getOrCreateMetric(prefix).incrementCallCount()
+      this._metrics.getOrCreateMetric(`${prefix}${this._metricNames.INSTRUMENTED}`).incrementCallCount()
+      transaction.trace.addSpan({ span, id: segment.id, parentId })
+      if (span) {
+        this._metrics.getOrCreateMetric(`${prefix}${this._metricNames.KEPT}`).incrementCallCount()
       }
+    } else if (span) {
+      this.add(span, transaction.priority)
     }
   }
 

package/lib/spans/span-event.js

@@ -13,6 +13,7 @@ const { addSpanKind, isEntryPointSpan, reparentSpan, shouldCreateSpan, HTTP_LIBR
 const EMPTY_USER_ATTRS = Object.freeze(Object.create(null))
 const SERVER_ADDRESS = 'server.address'
 const logger = require('../logger').child({ component: 'span-event' })
+const { PARTIAL_TYPES } = require('../transaction')
 
 /**
  * This keeps a static list of attributes that are used by
@@ -85,6 +86,10 @@ class SpanEvent {
     }
   }
 
+  get parentId() {
+    return this.intrinsics.parentId
+  }
+
   getIntrinsicAttributes() {
     return this.intrinsics
   }
@@ -180,13 +185,13 @@ class SpanEvent {
     const attributes = span.attributes
     const attrKeys = Object.keys(attributes)
     const entityRelationshipAttrs = SPAN_ENTITY_RELATIONSHIP_ATTRIBUTES.filter((item) => attrKeys.includes(item))
-    if (partialType === 'reduced') {
+    if (partialType === PARTIAL_TYPES.REDUCED) {
       if (entityRelationshipAttrs.length === 0) {
         logger.trace('Span %s does not contain any entity relationship attributes %j and trace is partial granularity type: %s, dropping span.', span.intrinsics.name, span.attributes, partialType)
         return null
       }
       logger.trace('Span %s contains entity relationship attributes and trace is partial granularity type: %s, keeping span unchanged.', span.intrinsics.name, partialType)
-    } else if (partialType === 'essential') {
+    } else if (partialType === PARTIAL_TYPES.ESSENTIAL) {
       const attributesToKeep = Object.create(null)
       for (const item in attributes) {
         if (entityRelationshipAttrs.includes(item) || item.startsWith('error.')) {
@@ -216,6 +221,7 @@ class SpanEvent {
     } else {
       span = new SpanEvent(attributes, customAttributes)
     }
+    span.spanLinks = segment.spanLinks ?? []
     return span
   }
 

package/lib/spans/streaming-span-event-aggregator.js

@@ -47,6 +47,10 @@ class StreamingSpanEventAggregator extends Aggregator {
     this.inProcessSpans = agent.config.distributed_tracing.in_process_spans.enabled
   }
 
+  toString() {
+    return 'StreamingSpanEventAggregator'
+  }
+
   /**
    * Start streaming spans to the collector.
    *

package/lib/subscriber-configs.js

@@ -9,10 +9,12 @@
 // 'package-name': [ { path: 'subscriberPath', instrumentations: [] }, ... ]
 const subscribers = {
   ...require('./subscribers/amqplib/config'),
+  ...require('./subscribers/bunyan/config'),
   ...require('./subscribers/cassandra-driver/config'),
   ...require('./subscribers/elasticsearch/config'),
   ...require('./subscribers/express/config'),
   ...require('./subscribers/fastify/config'),
+  ...require('./subscribers/google-genai/config'),
   ...require('./subscribers/ioredis/config'),
   ...require('./subscribers/mcp-sdk/config'),
   ...require('./subscribers/mysql/config'),

package/lib/subscribers/application-logs.js

@@ -21,6 +21,10 @@ class ApplicationLogsSubscriber extends Subscriber {
     return super.enabled && isApplicationLoggingEnabled(this.config)
   }
 
+  isLogForwardingEnabled() {
+    return isLogForwardingEnabled(this.config, this.agent)
+  }
+
   /**
    * The intent of this method is to create a module usage metric
    * but only once. You should call this in your handler.
@@ -48,7 +52,7 @@ class ApplicationLogsSubscriber extends Subscriber {
   }
 
   forwardLogLine(data) {
-    if (isLogForwardingEnabled(this.config, this.agent)) {
+    if (this.isLogForwardingEnabled()) {
       const ctx = this.agent.tracer.getContext()
       const formatLogLine = this.reformatLogLine(data, ctx)
       this.agent.logs.add(formatLogLine)

package/lib/subscribers/bunyan/base.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const ApplicationLogsSubscriber = require('../application-logs')
+
+class BunyanBaseSubscriber extends ApplicationLogsSubscriber {
+  NAME_FROM_LEVEL = {
+    10: 'trace',
+    20: 'debug',
+    30: 'info',
+    40: 'warn',
+    50: 'error',
+    60: 'fatal'
+  }
+
+  constructor({ agent, logger, channelName }) {
+    super({ agent, logger, packageName: 'bunyan', channelName })
+  }
+}
+
+module.exports = BunyanBaseSubscriber

package/lib/subscribers/bunyan/config.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+module.exports = {
+  bunyan: [
+    {
+      path: './bunyan',
+      instrumentations: [
+        {
+          channelName: 'nr_logger',
+          module: { name: 'bunyan', versionRange: '>=1.8.12', filePath: 'lib/bunyan.js' },
+          functionQuery: {
+            functionName: 'Logger',
+            kind: 'Sync'
+          }
+        }
+      ]
+    },
+    {
+      path: './bunyan/emit',
+      instrumentations: [
+        {
+          channelName: 'nr_emit',
+          module: { name: 'bunyan', versionRange: '>=1.8.12', filePath: 'lib/bunyan.js' },
+          functionQuery: {
+            expressionName: '_emit',
+            kind: 'Sync'
+          }
+        }
+      ]
+    }
+  ]
+}

package/lib/subscribers/bunyan/emit.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const BunyanSubscriber = require('./base')
+const { truncate } = require('../../util/application-logging')
+
+class BunyanEmitSubscriber extends BunyanSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_emit' })
+  }
+
+  handler(data, ctx) {
+    const [line] = data.arguments
+    if (!line) {
+      return ctx
+    }
+
+    this.incrementLinesMetric(this.NAME_FROM_LEVEL[line.level])
+    const decoratedLine = this.decorateLogLine()
+    if (decoratedLine) {
+      line.message = truncate(line.msg) + decoratedLine
+      data.arguments[0] = line
+    }
+    return ctx
+  }
+}
+
+module.exports = BunyanEmitSubscriber

package/lib/subscribers/bunyan/index.js

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const BunyanSubscriber = require('./base')
+const { truncate } = require('../../util/application-logging')
+
+class BunyanLoggerSubscriber extends BunyanSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_logger' })
+    this.events = ['end']
+  }
+
+  handler(data, ctx) {
+    this.createModuleUsageMetric('bunyan')
+    return ctx
+  }
+
+  end(data) {
+    const self = this
+    if (this.isLogForwardingEnabled()) {
+      const logger = data.self
+      logger.addStream({
+        name: 'NRLogForwarder',
+        type: 'raw',
+        level: logger.level(),
+        stream: {
+          write: function nrLogWrite(logLine) {
+            self.forwardLogLine(logLine)
+          }
+        }
+      })
+    }
+  }
+
+  reformatLogLine(logLine) {
+    // shallow copy, since we're modifying things
+    const newLog = Object.assign({}, logLine)
+    newLog.timestamp = Date.now()
+    newLog.level = this.NAME_FROM_LEVEL[logLine.level]
+
+    // put log message into a consistent spot and ensure it's not too long
+    newLog.message = truncate(newLog.msg)
+
+    // tidy up the error output to help with max length restrictions
+    if (newLog.err) {
+      newLog['error.message'] = truncate(newLog.err.message)
+      newLog['error.stack'] = truncate(newLog.err.stack)
+      newLog['error.class'] =
+        newLog.err.name === 'Error' ? newLog.err.constructor.name : newLog.err.name
+      // clear out the old error message
+      delete newLog.err
+    }
+
+    // Add the metadata to the object being logged
+    const metadata = this.agent.getLinkingMetadata(true)
+    return Object.assign({}, newLog, metadata)
+  }
+}
+
+module.exports = BunyanLoggerSubscriber