newrelic 13.19.2 → 13.20.0

package/lib/subscribers/azure-functions/azure-handler-base.js

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const Transaction = require('#agentlib/transaction/index.js')
+const { DESTINATIONS: DESTS } = Transaction
+
+module.exports = class AzureHandler {
+  constructor(subscriber) {
+    this.subscriber = subscriber
+    this.agent = subscriber.agent
+  }
+
+  handleColdStart(transaction) {
+    if (this.subscriber.coldStart === true) {
+      transaction.trace.attributes.addAttribute(DESTS.TRANS_COMMON, 'faas.coldStart', true)
+      this.subscriber.coldStart = false
+    }
+  }
+
+  createTransaction({ handlerArgs, ctx }) {
+    const [, context] = handlerArgs
+    const transaction = new Transaction(this.agent)
+    transaction.type = this.type
+    transaction.setPartialName(`AzureFunction/${context.functionName}`)
+    ctx = ctx.enterTransaction(transaction)
+    const newCtx = this.createSegment({ handlerArgs, ctx })
+    transaction.baseSegment = newCtx.segment
+    return newCtx
+  }
+
+  async handle({ thisArg, originalHandler, handlerArgs }) {
+    const ctx = this.agent.tracer.getContext()
+    if (ctx.transaction != null) {
+      return originalHandler.apply(thisArg, handlerArgs)
+    }
+
+    const [, context] = handlerArgs
+    const newCtx = this.createTransaction({ handlerArgs, ctx })
+    const transaction = newCtx?.transaction
+    this.addFaasAttributes(transaction, context)
+    const result = await this.runHandlerInContext({ originalHandler, ctx: newCtx, thisArg, handlerArgs })
+    this.handleColdStart(transaction)
+    return this.finalizeTransaction({ result, transaction })
+  }
+
+  runHandlerInContext({ originalHandler, ctx, thisArg, handlerArgs }) {
+    return this.agent.tracer.bindFunction(originalHandler, ctx).apply(thisArg, handlerArgs)
+  }
+
+  finalizeTransaction({ result, transaction }) {
+    transaction.end()
+    return result
+  }
+
+  addFaasAttributes(transaction, functionContext) {
+    transaction.trace.attributes.addAttribute(
+      DESTS.TRANS_COMMON,
+      'faas.invocation_id',
+      functionContext.invocationId ?? 'unknown'
+    )
+    transaction.trace.attributes.addAttribute(
+      DESTS.TRANS_COMMON,
+      'faas.name',
+      functionContext.functionName ?? 'unknown'
+    )
+    transaction.trace.attributes.addAttribute(
+      DESTS.TRANS_COMMON,
+      'faas.trigger',
+      this.mapTriggerType(functionContext)
+    )
+    transaction.trace.attributes.addAttribute(
+      DESTS.TRANS_COMMON,
+      'cloud.resource_id',
+      this.buildCloudResourceId(functionContext)
+    )
+  }
+
+  mapTriggerType(functionContext) {
+    const input = functionContext.options?.trigger?.type
+
+    // Input types are found at:
+    // https://github.com/Azure/azure-functions-nodejs-library/blob/138c021/src/trigger.ts
+    // https://learn.microsoft.com/en-us/azure/azure-functions/functions-triggers-bindings?tabs=isolated-process%2Cnode-v4%2Cpython-v2&pivots=programming-language-javascript#supported-bindings
+    switch (input) {
+      case 'httpTrigger': {
+        return 'http'
+      }
+
+      case 'timerTrigger': {
+        return 'timer'
+      }
+
+      case 'blobTrigger':
+      case 'cosmosDBTrigger':
+      case 'daprBindingTrigger':
+      case 'mysqlTrigger':
+      case 'queueTrigger':
+      case 'sqlTrigger': {
+        return 'datasource'
+      }
+
+      case 'daprTopicTrigger':
+      case 'eventGridTrigger':
+      case 'eventHubTrigger':
+      case 'kafkaTrigger':
+      case 'rabbitMQTrigger':
+      case 'redisListTrigger':
+      case 'redisPubSubTrigger':
+      case 'redisStreamTrigger':
+      case 'serviceBusTrigger':
+      case 'signalRTrigger':
+      case 'webPubSubTrigger': {
+        return 'pubsub'
+      }
+
+      default: {
+        return 'other'
+      }
+    }
+  }
+
+  buildCloudResourceId(functionContext) {
+    return [
+      '/subscriptions/',
+      this.subscriber.subscriptionId,
+      '/resourceGroups/',
+      this.subscriber.resourceGroup,
+      '/providers/Microsoft.Web/sites/',
+      this.subscriber.azureFunctionAppName,
+      '/functions/',
+      functionContext.functionName
+    ].join('')
+  }
+}

package/lib/subscribers/azure-functions/background-handler.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const AzureHandler = require('#agentlib/subscribers/azure-functions/azure-handler-base.js')
+const Transaction = require('#agentlib/transaction/index.js')
+const backgroundRecorder = require('#agentlib/metrics/recorders/other.js')
+const { TYPES } = Transaction
+
+module.exports = class BackgroundHandler extends AzureHandler {
+  constructor({ subscriber }) {
+    super(subscriber)
+    this.type = TYPES.BG
+  }
+
+  createSegment({ handlerArgs, ctx }) {
+    const [, context] = handlerArgs
+    const triggerType = context.options?.trigger?.type ?? 'unknown'
+    const methodName = triggerType.replace(/Trigger$/, '')
+    return this.subscriber.createSegment({
+      name: `${methodName}-trigger`,
+      recorder: backgroundRecorder,
+      ctx
+    })
+  }
+}

package/lib/subscribers/azure-functions/config.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+'use strict'
+
+const modName = '@azure/functions'
+const filePath = 'dist/azure-functions.js'
+const versionRange = '>=4.7.0'
+
+const generic = {
+  path: './azure-functions/index.js',
+  instrumentations: [
+    {
+      channelName: 'nr_generic',
+      module: { name: modName, versionRange, filePath },
+      functionQuery: {
+        functionName: 'generic',
+        kind: 'Sync'
+      }
+    }
+  ]
+}
+
+const logger = {
+  path: './azure-functions/logger.js',
+  instrumentations: [
+    {
+      channelName: 'nr_logger',
+      module: { name: modName, versionRange, filePath },
+      functionQuery: {
+        functionName: 'tryGetCoreApiLazy',
+        kind: 'Sync'
+      }
+    }
+  ]
+}
+
+module.exports = {
+  [modName]: [
+    generic,
+    logger
+  ]
+}

package/lib/subscribers/azure-functions/http-handler.js

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const AzureHandler = require('#agentlib/subscribers/azure-functions/azure-handler-base.js')
+const Transaction = require('#agentlib/transaction/index.js')
+const { TYPES } = Transaction
+const { Transform } = require('node:stream')
+const recordWeb = require('#agentlib/metrics/recorders/http.js')
+
+module.exports = class HttpHandler extends AzureHandler {
+  constructor({ subscriber }) {
+    super(subscriber)
+    this.type = TYPES.WEB
+  }
+
+  #initializeWeb(transaction, request) {
+    const absoluteUrl = request.url
+    const url = new URL(absoluteUrl)
+    const transport = url.protocol === 'https:' ? 'HTTPS' : 'HTTP'
+    const port = url.port || (transport === 'HTTPS' ? 443 : 80)
+    transaction.initializeWeb({ absoluteUrl, method: request.method, port, headers: request.headers, transport })
+  }
+
+  runHandlerInContext({ originalHandler, ctx, thisArg, handlerArgs }) {
+    const { transaction } = ctx
+    const [request] = handlerArgs
+    const self = this
+    function inContext() {
+      self.#initializeWeb(transaction, request)
+      return originalHandler.apply(this, arguments)
+    }
+
+    return this.agent.tracer.bindFunction(inContext, ctx).apply(thisArg, handlerArgs)
+  }
+
+  finalizeTransaction({ result, transaction }) {
+    transaction.finalizeWeb({ statusCode: result?.status, headers: result?.headers, end: false })
+    if (result?.body instanceof Transform) {
+      result.body.on('close', () => transaction.end())
+    } else {
+      transaction.end()
+    }
+    return result
+  }
+
+  createSegment({ handlerArgs, ctx }) {
+    const [request] = handlerArgs
+    return this.subscriber.createSegment({
+      name: request.url,
+      recorder: recordWeb,
+      ctx
+    })
+  }
+}

package/lib/subscribers/azure-functions/index.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const Subscriber = require('../base')
+const HttpHandler = require('#agentlib/subscribers/azure-functions/http-handler.js')
+const BackgroundHandler = require('#agentlib/subscribers/azure-functions/background-handler.js')
+
+module.exports = class AzureFunctionsSubscriber extends Subscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_generic', packageName: '@azure/functions' })
+    this.requireActiveTx = false
+    this.coldStart = true
+  }
+
+  handler(data, ctx) {
+    if (this.missingEnvVars) {
+      this.logger.warn(
+        {
+          data: {
+            expectedVars: ['WEBSITE_OWNER_NAME', 'WEBSITE_RESOURCE_GROUP', 'WEBSITE_SITE_NAME'],
+            found: { WEBSITE_OWNER_NAME: this.subscriptionId, WEBSITE_RESOURCE_GROUP: this.resourceGroup, WEBSITE_SITE_NAME: this.azureFunctionAppName }
+          }
+        },
+        'could not initialize azure functions instrumentation due to missing environment variables'
+      )
+      return ctx
+    }
+
+    const { arguments: args } = data
+    const [, options] = args
+    const self = this
+    const originalHandler = options.handler
+
+    args[1].handler = async function wrappedHandler(...handlerArgs) {
+      let handler
+      if (options?.return?.type === 'http') {
+        handler = new HttpHandler({ subscriber: self })
+      } else {
+        handler = new BackgroundHandler({ subscriber: self })
+      }
+      return handler.handle({ thisArg: this, originalHandler, handlerArgs })
+    }
+  }
+
+  get missingEnvVars() {
+    return !this.subscriptionId || !this.resourceGroup || !this.azureFunctionAppName
+  }
+
+  get subscriptionId() {
+    if (!process.env.WEBSITE_OWNER_NAME) {
+      return null
+    }
+
+    return process.env.WEBSITE_OWNER_NAME?.split('+').shift()
+  }
+
+  get resourceGroup() {
+    const { WEBSITE_RESOURCE_GROUP, WEBSITE_OWNER_NAME } = process.env
+    if (!WEBSITE_RESOURCE_GROUP && WEBSITE_OWNER_NAME) {
+      return WEBSITE_OWNER_NAME.split('+').pop().split('-Linux').shift()
+    }
+
+    return WEBSITE_RESOURCE_GROUP
+  }
+
+  get azureFunctionAppName() {
+    const { WEBSITE_SITE_NAME } = process.env
+    return WEBSITE_SITE_NAME
+  }
+}

package/lib/subscribers/azure-functions/logger.js

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const Subscriber = require('../base')
+const {
+  isApplicationLoggingEnabled,
+  isLogForwardingEnabled,
+  isMetricsEnabled,
+  incrementLoggingLinesMetrics
+} = require('#agentlib/util/application-logging.js')
+
+// Azure Functions uses 'information' as the context level for context.log and
+// context.info and uses 'warning' as the context level for context.warn.
+// These map to the NR standard names that LOGGING.LEVELS recognizes ('info', 'warn').
+const AZURE_TO_NR_LEVEL = {
+  information: 'info',
+  warning: 'warn'
+}
+
+module.exports = class AzureFunctionsSubscriber extends Subscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, channelName: 'nr_logger', packageName: '@azure/functions' })
+    this.logHookRegistered = false
+    this.events = ['end']
+  }
+
+  end(data) {
+    const coreApi = data.result
+    this.registerLogHook(coreApi)
+  }
+
+  registerLogHook(coreApi) {
+    if (this.logHookRegistered) {
+      return
+    }
+
+    this.logHookRegistered = true
+
+    if (!isApplicationLoggingEnabled(this.agent.config)) {
+      this.logger.debug('Application logging not enabled. Not auto capturing logs from Azure Functions.')
+      return
+    }
+
+    const agent = this.agent
+
+    coreApi.registerHook('log', (context) => {
+      const logLevel = AZURE_TO_NR_LEVEL[context.level] ?? context.level ?? 'info'
+
+      if (isLogForwardingEnabled(agent.config, agent)) {
+        const meta = agent.getLinkingMetadata(true)
+
+        const logData = {
+          message: context.message ?? 'unknown',
+          level: logLevel,
+          timestamp: Date.now(),
+          category: context.category ?? 'user',
+          ...meta
+        }
+
+        agent.logs.add(logData)
+      }
+
+      if (isMetricsEnabled(agent.config)) {
+        incrementLoggingLinesMetrics(logLevel, agent.metrics)
+      }
+    })
+  }
+}

package/lib/subscribers/connect/config.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const modName = 'connect'
+
+module.exports = {
+  [modName]: [
+    {
+      path: './connect/use.js',
+      instrumentations: [
+        {
+          channelName: 'nr_use',
+          module: {
+            name: modName,
+            filePath: 'index.js',
+            versionRange: '>=3.4.0'
+          },
+          functionQuery: {
+            expressionName: 'use',
+            kind: 'Sync'
+          }
+        },
+        {
+          channelName: 'nr_use',
+          module: {
+            name: modName,
+            filePath: 'lib/proto.js',
+            versionRange: '>=3.0.0 <3.4.0'
+          },
+          functionQuery: {
+            expressionName: 'use',
+            kind: 'Sync'
+          }
+        },
+      ]
+    }
+  ]
+}

package/lib/subscribers/connect/use.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const MiddlewareSubscriber = require('../middleware.js')
+
+module.exports = class CreateServerSubscriber extends MiddlewareSubscriber {
+  constructor({ agent, logger }) {
+    super({
+      agent,
+      logger,
+      channelName: 'nr_use',
+      packageName: 'connect',
+      system: 'Connect'
+    })
+  }
+
+  handler(data, ctx) {
+    const { arguments: args } = data
+    const [route, mw] = args
+    if (typeof route === 'string') {
+      data.arguments[1] = this.wrapper.wrap({ handler: mw, route })
+    } else {
+      data.arguments[0] = this.wrapper.wrap({ handler: route, route: '/' })
+    }
+    return ctx
+  }
+}

package/lib/subscribers/google-adk/agent-run-async.js

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const AiMonitoringSubscriber = require('../ai-monitoring/base')
+const LlmAgent = require('#agentlib/llm-events/ai-agent.js')
+const LlmErrorMessage = require('#agentlib/llm-events/error-message.js')
+const { AI: { GOOGLE_ADK } } = require('#agentlib/metrics/names.js')
+
+module.exports = class GoogleAdkAgentRunSubscriber extends AiMonitoringSubscriber {
+  constructor({ agent, logger }) {
+    super({
+      agent,
+      logger,
+      packageName: '@google/adk',
+      channelName: 'nr_agentRunAsync',
+      name: `${GOOGLE_ADK.AGENT}/runAsync/agent`,
+      trackingPrefix: GOOGLE_ADK.TRACKING_PREFIX
+    })
+    this.events = ['end']
+  }
+
+  handler(data, ctx) {
+    this.aiAgentName = data?.self?.name ?? 'agent'
+    this.name = `${GOOGLE_ADK.AGENT}/runAsync/${this.aiAgentName}`
+    return super.handler(data, ctx)
+  }
+
+  // BaseAgent.runAsync is an async generator. The tracePromise wrapper returns
+  // the generator object synchronously (it has no .then), so `asyncEnd` is
+  // never published. We use `end` instead, which fires right after the
+  // generator is created but before it is consumed by the caller.
+  end(data) {
+    const { agent, logger } = this
+    if (!this.enabled) {
+      logger.debug('Google ADK instrumentation is disabled, not instrumenting runAsync.')
+      return
+    }
+
+    const ctx = agent.tracer.getContext()
+    const { segment, transaction } = ctx
+    if (!(segment || transaction) || (transaction?.isActive() !== true)) {
+      return
+    }
+    segment.addSpanAttribute('subcomponent', `{"type": "APM-AI_AGENT", "name": "${this.aiAgentName}"}`)
+
+    const { result: generator } = data
+    if (generator && typeof generator[Symbol.asyncIterator] === 'function') {
+      this.#instrumentGenerator({ generator, ctx })
+    }
+  }
+
+  /**
+   * Wraps the async generator returned by BaseAgent.runAsync() so that
+   * child instrumentation (e.g. Gemini, FunctionTool) runs within the
+   * agent segment context. Records the LlmAgent event when the generator
+   * completes or throws.
+   *
+   * @param {object} params function parameters
+   * @param {object} params.ctx The NR async context to bind generator calls to
+   * @param {AsyncGenerator} params.generator The async generator from runAsync
+   */
+  #instrumentGenerator({ ctx, generator }) {
+    const self = this
+    const origNext = generator.next
+
+    generator.next = async function wrappedNext(...args) {
+      try {
+        // Bind to the segment context so that child instrumentation
+        // (e.g. Gemini) creates spans as children of this agent span.
+        const boundNext = self.agent.tracer.bindFunction(origNext, ctx)
+        const result = await boundNext.apply(this, args)
+        if (result?.done) {
+          self.#recordAgentEvent({ ctx, error: false })
+        }
+        return result
+      } catch (err) {
+        self.#recordAgentEvent({ ctx, error: true })
+        throw err
+      }
+    }
+  }
+
+  /**
+   * Records a Google ADK LlmAgent event.
+   *
+   * @param {object} params function parameters
+   * @param {object} params.ctx The active tracer context containing the segment and transaction
+   * @param {boolean} params.error Whether an error occurred
+   */
+  #recordAgentEvent({ ctx, error }) {
+    const { agent, aiAgentName } = this
+    const { segment, transaction } = ctx
+    segment.end()
+    const agentEvent = new LlmAgent({
+      agent,
+      segment,
+      transaction,
+      aiAgentName,
+      vendor: 'google_adk',
+      error: error || undefined
+    })
+
+    this.recordEvent({ type: 'LlmAgent', msg: agentEvent })
+
+    if (error) {
+      agent.errors.add(
+        transaction,
+        error,
+        new LlmErrorMessage({
+          response: {},
+          cause: error,
+          aiAgent: agentEvent
+        })
+      )
+    }
+  }
+}

package/lib/subscribers/google-adk/config.js

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const agentRunAsync = {
+  path: './google-adk/agent-run-async.js',
+  instrumentations: [
+    {
+      channelName: 'nr_agentRunAsync',
+      module: { name: '@google/adk', versionRange: '>=1.1.0', filePath: 'dist/cjs/agents/base_agent.js' },
+      functionQuery: {
+        className: 'BaseAgent',
+        methodName: 'runAsync',
+        kind: 'Async'
+      }
+    },
+    {
+      channelName: 'nr_agentRunAsync',
+      module: { name: '@google/adk', versionRange: '>=1.1.0', filePath: 'dist/esm/agents/base_agent.js' },
+      functionQuery: {
+        className: 'BaseAgent',
+        methodName: 'runAsync',
+        kind: 'Async'
+      }
+    }
+  ]
+}
+
+const toolRunAsync = {
+  path: './google-adk/tool-run-async.js',
+  instrumentations: [
+    {
+      channelName: 'nr_toolRunAsync',
+      module: { name: '@google/adk', versionRange: '>=1.1.0', filePath: 'dist/cjs/tools/function_tool.js' },
+      functionQuery: {
+        className: 'FunctionTool',
+        methodName: 'runAsync',
+        kind: 'Async'
+      }
+    },
+    {
+      channelName: 'nr_toolRunAsync',
+      module: { name: '@google/adk', versionRange: '>=1.1.0', filePath: 'dist/esm/tools/function_tool.js' },
+      functionQuery: {
+        className: 'FunctionTool',
+        methodName: 'runAsync',
+        kind: 'Async'
+      }
+    }
+  ]
+}
+
+module.exports = {
+  '@google/adk': [
+    agentRunAsync,
+    toolRunAsync
+  ]
+}