newrelic 12.17.0 → 12.18.0

package/NEWS.md

@@ -1,32 +1,56 @@
-### v12.17.0 (2025-04-02)
-
-#### Features
-
-* Azure Function utilization ([#3017](https://github.com/newrelic/node-newrelic/pull/3017)) ([80ab93e](https://github.com/newrelic/node-newrelic/commit/80ab93ee5599800a823e3828f9730d5421b460c2))
-* Support honoring W3C `traceparent` sampled flag ([#3009](https://github.com/newrelic/node-newrelic/pull/3009)) ([d903413](https://github.com/newrelic/node-newrelic/commit/d903413a6216dae2cde3e6b6366c3a390d4ed4cd))
-  * By default the agent will not honor the `traceparent` sampled flag.
-  * To control how sampling works with `traceparent` set the following in config: 
-    * `distributed_tracing.sampler.remote_parent_sampled`(when the traceparent sampled flag is `01`) 
-        * `always_on`: the agent will sample spans
-        * `always_off`: the agent will not sample spans
-        * `default`: the agent will rely on existing priority sampling to make its decisions
-    * `distributed_tracing.sampler.remote_parent_not_sampled`(when the traceparent sampled flag is `00`)
-        * `always_on`: the agent will sample spans
-        * `always_off`: the agent will not sample spans
-        * `default`: the agent will rely on existing priority sampling to make its decisions
-
-#### Code refactoring
-
-* Updated otel bridge to centralize mapping rules for a given span attribute to accomondate semantic convention spec updates ([#3010](https://github.com/newrelic/node-newrelic/pull/3010)) ([c20c36b](https://github.com/newrelic/node-newrelic/commit/c20c36bbe0f63ab18fbbe85ad4bfaa3b80f1475d))
-
-#### Documentation
-
-* Updated compatibility report ([#3013](https://github.com/newrelic/node-newrelic/pull/3013)) ([8fab715](https://github.com/newrelic/node-newrelic/commit/8fab715581ccc5da7118884a0080557891329daa))
-
-#### Tests
-
-* Pinned `openai@4.90.0` to work with `@langchain/openai` ([#3019](https://github.com/newrelic/node-newrelic/pull/3019)) ([eaa3db0](https://github.com/newrelic/node-newrelic/commit/eaa3db0a556a19c44a05926dc339ea7bcbc9cebd))
-
+### v12.18.0 (2025-04-14)
+
+#### Features
+
+* Support Azure functions background trigger types ([#3028](https://github.com/newrelic/node-newrelic/pull/3028)) ([3bf17b0](https://github.com/newrelic/node-newrelic/commit/3bf17b03abaa713c1f9ad544c54c24a6374359c2))
+* Support Azure functions HTTP trigger type ([#3021](https://github.com/newrelic/node-newrelic/pull/3021)) ([90d894b](https://github.com/newrelic/node-newrelic/commit/90d894bf1eb4a48f4b7f314ae22eef2cc76c32b9))
+
+#### Bug fixes
+
+* Updated span streamer to properly retry failed batches and handle flushing batch queue every 5 seconds ([#3033](https://github.com/newrelic/node-newrelic/pull/3033)) ([7db0e7c](https://github.com/newrelic/node-newrelic/commit/7db0e7ca929d54858addd5255b46507f82333045))
+
+#### Code refactoring
+
+* Update otel bridge rules synthesizer to properly handle consumer kind rules ([#3003](https://github.com/newrelic/node-newrelic/pull/3003)) ([3295dd1](https://github.com/newrelic/node-newrelic/commit/3295dd12bbebb708f3eeca2ad32fbc157a892fec))
+
+#### Documentation
+
+* Updated compatibility report ([#3020](https://github.com/newrelic/node-newrelic/pull/3020)) ([ce32b67](https://github.com/newrelic/node-newrelic/commit/ce32b6754383b6b1fe95d1d37759810b4caaf34c))
+
+#### Miscellaneous chores
+
+* Fixed prisma CI issues ([#3031](https://github.com/newrelic/node-newrelic/pull/3031)) ([1349cae](https://github.com/newrelic/node-newrelic/commit/1349cae4d87941e4f55dffc2445c90e73d823bbc))
+* Improved logging within utilization detection ([#3034](https://github.com/newrelic/node-newrelic/pull/3034)) ([b47bd46](https://github.com/newrelic/node-newrelic/commit/b47bd46ad144723ac62192eb9cc474ddd1fce98d))
+
+### v12.17.0 (2025-04-02)
+
+#### Features
+
+* Azure Function utilization ([#3017](https://github.com/newrelic/node-newrelic/pull/3017)) ([80ab93e](https://github.com/newrelic/node-newrelic/commit/80ab93ee5599800a823e3828f9730d5421b460c2))
+* Support honoring W3C `traceparent` sampled flag ([#3009](https://github.com/newrelic/node-newrelic/pull/3009)) ([d903413](https://github.com/newrelic/node-newrelic/commit/d903413a6216dae2cde3e6b6366c3a390d4ed4cd))
+  * By default the agent will not honor the `traceparent` sampled flag.
+  * To control how sampling works with `traceparent` set the following in config: 
+    * `distributed_tracing.sampler.remote_parent_sampled`(when the traceparent sampled flag is `01`) 
+        * `always_on`: the agent will sample spans
+        * `always_off`: the agent will not sample spans
+        * `default`: the agent will rely on existing priority sampling to make its decisions
+    * `distributed_tracing.sampler.remote_parent_not_sampled`(when the traceparent sampled flag is `00`)
+        * `always_on`: the agent will sample spans
+        * `always_off`: the agent will not sample spans
+        * `default`: the agent will rely on existing priority sampling to make its decisions
+
+#### Code refactoring
+
+* Updated otel bridge to centralize mapping rules for a given span attribute to accomondate semantic convention spec updates ([#3010](https://github.com/newrelic/node-newrelic/pull/3010)) ([c20c36b](https://github.com/newrelic/node-newrelic/commit/c20c36bbe0f63ab18fbbe85ad4bfaa3b80f1475d))
+
+#### Documentation
+
+* Updated compatibility report ([#3013](https://github.com/newrelic/node-newrelic/pull/3013)) ([8fab715](https://github.com/newrelic/node-newrelic/commit/8fab715581ccc5da7118884a0080557891329daa))
+
+#### Tests
+
+* Pinned `openai@4.90.0` to work with `@langchain/openai` ([#3019](https://github.com/newrelic/node-newrelic/pull/3019)) ([eaa3db0](https://github.com/newrelic/node-newrelic/commit/eaa3db0a556a19c44a05926dc339ea7bcbc9cebd))
+
 ### v12.16.1 (2025-03-24)
 
 #### Features

package/THIRD_PARTY_NOTICES.md

@@ -91,7 +91,7 @@ code, the source code can be found at [https://github.com/newrelic/node-newrelic
 
 ### @grpc/grpc-js
 
-This product includes source derived from [@grpc/grpc-js](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js) ([v1.12.4](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js/tree/v1.12.4)), distributed under the [Apache-2.0 License](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js/blob/v1.12.4/LICENSE):
+This product includes source derived from [@grpc/grpc-js](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js) ([v1.13.2](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js/tree/v1.13.2)), distributed under the [Apache-2.0 License](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js/blob/v1.13.2/LICENSE):
 
 ```
                                  Apache License
@@ -509,7 +509,7 @@ This product includes source derived from [@grpc/proto-loader](https://github.co
 
 ### @newrelic/security-agent
 
-This product includes source derived from [@newrelic/security-agent](https://github.com/newrelic/csec-node-agent) ([v2.3.1](https://github.com/newrelic/csec-node-agent/tree/v2.3.1)), distributed under the [UNKNOWN License](https://github.com/newrelic/csec-node-agent/blob/v2.3.1/LICENSE):
+This product includes source derived from [@newrelic/security-agent](https://github.com/newrelic/csec-node-agent) ([v2.4.0](https://github.com/newrelic/csec-node-agent/tree/v2.4.0)), distributed under the [UNKNOWN License](https://github.com/newrelic/csec-node-agent/blob/v2.4.0/LICENSE):
 
 ```
 ## New Relic Software License v1.0
@@ -1271,7 +1271,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 ### import-in-the-middle
 
-This product includes source derived from [import-in-the-middle](https://github.com/nodejs/import-in-the-middle) ([v1.13.0](https://github.com/nodejs/import-in-the-middle/tree/v1.13.0)), distributed under the [Apache-2.0 License](https://github.com/nodejs/import-in-the-middle/blob/v1.13.0/LICENSE):
+This product includes source derived from [import-in-the-middle](https://github.com/nodejs/import-in-the-middle) ([v1.13.1](https://github.com/nodejs/import-in-the-middle/tree/v1.13.1)), distributed under the [Apache-2.0 License](https://github.com/nodejs/import-in-the-middle/blob/v1.13.1/LICENSE):
 
 ```
                                  Apache License
@@ -1615,7 +1615,7 @@ IN THE SOFTWARE.
 
 ### require-in-the-middle
 
-This product includes source derived from [require-in-the-middle](https://github.com/elastic/require-in-the-middle) ([v7.4.0](https://github.com/elastic/require-in-the-middle/tree/v7.4.0)), distributed under the [MIT License](https://github.com/elastic/require-in-the-middle/blob/v7.4.0/LICENSE):
+This product includes source derived from [require-in-the-middle](https://github.com/elastic/require-in-the-middle) ([v7.5.0](https://github.com/elastic/require-in-the-middle/tree/v7.5.0)), distributed under the [MIT License](https://github.com/elastic/require-in-the-middle/blob/v7.5.0/LICENSE):
 
 ```
 The MIT License (MIT)
@@ -1701,7 +1701,7 @@ SOFTWARE.
 
 ### @aws-sdk/client-s3
 
-This product includes source derived from [@aws-sdk/client-s3](https://github.com/aws/aws-sdk-js-v3) ([v3.714.0](https://github.com/aws/aws-sdk-js-v3/tree/v3.714.0)), distributed under the [Apache-2.0 License](https://github.com/aws/aws-sdk-js-v3/blob/v3.714.0/LICENSE):
+This product includes source derived from [@aws-sdk/client-s3](https://github.com/aws/aws-sdk-js-v3) ([v3.726.1](https://github.com/aws/aws-sdk-js-v3/tree/v3.726.1)), distributed under the [Apache-2.0 License](https://github.com/aws/aws-sdk-js-v3/blob/v3.726.1/LICENSE):
 
 ```
                                 Apache License
@@ -1910,7 +1910,7 @@ This product includes source derived from [@aws-sdk/client-s3](https://github.co
 
 ### @aws-sdk/s3-request-presigner
 
-This product includes source derived from [@aws-sdk/s3-request-presigner](https://github.com/aws/aws-sdk-js-v3) ([v3.714.0](https://github.com/aws/aws-sdk-js-v3/tree/v3.714.0)), distributed under the [Apache-2.0 License](https://github.com/aws/aws-sdk-js-v3/blob/v3.714.0/LICENSE):
+This product includes source derived from [@aws-sdk/s3-request-presigner](https://github.com/aws/aws-sdk-js-v3) ([v3.726.1](https://github.com/aws/aws-sdk-js-v3/tree/v3.726.1)), distributed under the [Apache-2.0 License](https://github.com/aws/aws-sdk-js-v3/blob/v3.726.1/LICENSE):
 
 ```
                                 Apache License
@@ -3770,7 +3770,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ### eslint
 
-This product includes source derived from [eslint](https://github.com/eslint/eslint) ([v9.17.0](https://github.com/eslint/eslint/tree/v9.17.0)), distributed under the [MIT License](https://github.com/eslint/eslint/blob/v9.17.0/LICENSE):
+This product includes source derived from [eslint](https://github.com/eslint/eslint) ([v9.18.0](https://github.com/eslint/eslint/tree/v9.18.0)), distributed under the [MIT License](https://github.com/eslint/eslint/blob/v9.18.0/LICENSE):
 
 ```
 Copyright OpenJS Foundation and other contributors, <www.openjsf.org>

package/lib/config/default.js

@@ -1197,7 +1197,14 @@ defaultConfig.definition = () => ({
       port: {
         formatter: int,
         default: 443
-      }
+      },
+      /**
+       * For testing only. This allows the connection to an insecure gRPC server.
+       */
+      insecure: {
+        formatter: boolean,
+        default: false
+      },
     },
     span_events: {
       /**
@@ -1206,6 +1213,13 @@ defaultConfig.definition = () => ({
       queue_size: {
         formatter: int,
         default: 10000
+      },
+      /**
+       * Size of batches to post to 8T server
+       */
+      batch_size: {
+        formatter: int,
+        default: 750
       }
     },
     batching: {

package/lib/grpc/connection.js

@@ -62,6 +62,7 @@ class GrpcConnection extends EventEmitter {
 
     const traceObserverConfig = infiniteTracingConfig.trace_observer
     this._endpoint = this.getTraceObserverEndpoint(traceObserverConfig)
+    this._insecureConnection = traceObserverConfig.insecure
 
     this._client = null
     this.stream = null
@@ -202,11 +203,13 @@ class GrpcConnection extends EventEmitter {
 
   _disconnect() {
     logger.trace('Disconnecting from gRPC endpoint.')
+    this._setState(connectionStates.disconnected)
 
     if (this.stream) {
       this.stream.removeAllListeners()
 
       const oldStream = this.stream
+
       this.stream.on('status', function endStreamStatusHandler(grpcStatus) {
         logger.trace('End stream status received [%s]: %s', grpcStatus.code, grpcStatus.details)
 
@@ -228,8 +231,6 @@ class GrpcConnection extends EventEmitter {
 
       this.stream = null
     }
-
-    this._setState(connectionStates.disconnected)
   }
 
   /**
@@ -374,12 +375,10 @@ class GrpcConnection extends EventEmitter {
 
     const traceApi = protoDescriptor.com.newrelic.trace.v1
 
-    const credentials = this._generateCredentials(grpc)
-
-    // If you want to use mock server use insecure creds
-    // const credentials = grpc.credentials.createInsecure()
+    const credentials = this._insecureConnection ? grpc.credentials.createInsecure() : this._generateCredentials(grpc)
 
     const opts = {}
+
     if (this._compression) {
       // 2 = gzip compression
       // see: https://github.com/grpc/grpc-node/blob/master/packages/grpc-js/src/compression-algorithms.ts#L21
@@ -393,6 +392,27 @@ class GrpcConnection extends EventEmitter {
         .incrementCallCount()
     }
 
+    // this defines retries of writes to stream if it fails with `UNAVAILABLE` or `INTERNAL`
+    const serviceConfig = {
+      methodConfig: [
+        {
+          name: [
+            {
+              service: 'com.newrelic.trace.v1.IngestService'
+            }
+          ],
+          retryPolicy: {
+            maxAttempts: 10,
+            initialBackoff: '0.1s',
+            maxBackoff: '1s',
+            backoffMultiplier: 2,
+            retryableStatusCodes: ['UNAVAILABLE', 'INTERNAL']
+          }
+        }
+      ]
+    }
+    opts['grpc.service_config'] = JSON.stringify(serviceConfig)
+
     return new traceApi.IngestService(endpoint, credentials, opts)
   }
 }

package/lib/instrumentation/@azure/functions.js

@@ -0,0 +1,311 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const defaultLogger = require('../../logger').child({ component: 'azure-functions' })
+const urltils = require('../../util/urltils')
+const headerProcessing = require('../../header-processing')
+const synthetics = require('../../synthetics')
+
+const backgroundRecorder = require('../../metrics/recorders/other.js')
+const recordWeb = require('../../metrics/recorders/http')
+
+const {
+  DESTINATIONS: DESTS,
+  TYPES
+} = require('../../transaction/index.js')
+
+const {
+  WEBSITE_OWNER_NAME,
+  WEBSITE_RESOURCE_GROUP,
+  WEBSITE_SITE_NAME
+} = process.env
+const SUBSCRIPTION_ID = WEBSITE_OWNER_NAME?.split('+').shift()
+const RESOURCE_GROUP_NAME = WEBSITE_RESOURCE_GROUP ?? WEBSITE_OWNER_NAME?.split('+').pop().split('-Linux').shift()
+const AZURE_FUNCTION_APP_NAME = WEBSITE_SITE_NAME
+
+let coldStart = true
+let _agent
+let _logger
+
+module.exports = function initialize(agent, azureFunctions, _moduleName, shim, { logger = defaultLogger } = {}) {
+  _agent = agent
+  _logger = logger
+  if (!SUBSCRIPTION_ID || !RESOURCE_GROUP_NAME || !AZURE_FUNCTION_APP_NAME) {
+    logger.warn(
+      {
+        data: {
+          expectedVars: ['WEBSITE_OWNER_NAME', 'WEBSITE_RESOURCE_GROUP', 'WEBSITE_SITE_NAME'],
+          found: { WEBSITE_OWNER_NAME, WEBSITE_RESOURCE_GROUP, WEBSITE_SITE_NAME }
+        },
+      },
+      'could not initialize azure functions instrumentation due to missing environment variables'
+    )
+    return
+  }
+
+  const httpMethods = ['http', 'get', 'put', 'post', 'patch', 'deleteRequest']
+  shim.wrap(azureFunctions.app, httpMethods, wrapAzureHttpMethods)
+
+  const backgroundMethods = [
+    'cosmosDB',
+    'eventGrid',
+    'eventHub',
+    'mySql',
+    'serviceBusQueue',
+    'serviceBusTopic',
+    'sql',
+    'storageBlob',
+    'storageQueue',
+    'timer',
+    'warmup',
+    'webPubSub'
+  ]
+  shim.wrap(azureFunctions.app, backgroundMethods, wrapAzureBackgroundMethods)
+}
+
+function wrapAzureHttpMethods(shim, appMethod) {
+  return async function wrappedAzureHttpMethod(...args) {
+    // If the app doesn't need an options object, the user can pass the
+    // handler function as the second argument
+    // (e.g. `app.get('name', handler)`).
+    // See https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-node?tabs=javascript%2Cwindows%2Cazure-cli&pivots=nodejs-model-v4#registering-a-function
+    let handler
+    if (typeof args[1] === 'function') {
+      handler = args[1]
+      args[1] = { handler }
+    } else {
+      handler = args[1].handler
+    }
+
+    const tracer = shim.tracer
+    args[1].handler = tracer.transactionProxy(async function wrappedHandler(...args) {
+      const [request, context] = args
+      const ctx = tracer.getContext()
+      const tx = tracer.getTransaction()
+
+      // Set the transaction name according to our spec (category + function name).
+      tx.setPartialName(`AzureFunction/${context.functionName}`)
+
+      const url = new URL(request.url)
+      const segment = tracer.createSegment({
+        name: request.url,
+        recorder: recordWeb,
+        parent: ctx.segment,
+        transaction: tx
+      })
+      segment.start()
+
+      const transport = url.protocol === 'https:' ? 'HTTPS' : 'HTTP'
+      tx.type = TYPES.WEB
+      tx.baseSegment = segment
+      tx.parsedUrl = url
+      tx.url = urltils.obfuscatePath(_agent.config, url.pathname)
+      tx.verb = request.method
+      if (url.port === '') {
+        tx.port = transport === 'HTTPS' ? '443' : '80'
+      } else {
+        tx.port = url.port
+      }
+
+      tx.trace.attributes.addAttribute(
+        DESTS.TRANS_EVENT | DESTS.ERROR_EVENT,
+        'request.uri',
+        tx.url
+      )
+      segment.addSpanAttribute('request.uri', tx.url)
+      if (request.method != null) {
+        segment.addSpanAttribute('request.method', request.method)
+      }
+      addAttributes({ transaction: tx, functionContext: context })
+
+      const queueTimeStamp = headerProcessing.getQueueTime(_logger, request.headers)
+      if (queueTimeStamp) {
+        tx.queueTime = Date.now() - queueTimeStamp
+      }
+
+      synthetics.assignHeadersToTransaction(_agent.config, tx, request.headers)
+      if (_agent.config.distributed_tracing.enabled === true) {
+        tx.acceptDistributedTraceHeaders(transport, request.headers)
+      }
+
+      const newContext = ctx.enterSegment({ segment })
+      const boundHandler = tracer.bindFunction(handler, newContext)
+
+      const result = await boundHandler(...args)
+      // Responses should have a shape as described at:
+      // https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-node?tabs=javascript%2Cwindows%2Cazure-cli&pivots=nodejs-model-v4#http-response
+      if (result.status) {
+        tx.trace.attributes.addAttribute(
+          DESTS.TRANS_COMMON,
+          'http.statusCode',
+          result.status
+        )
+      }
+
+      if (coldStart === true) {
+        tx.trace.attributes.addAttribute(DESTS.TRANS_COMMON, 'faas.coldStart', true)
+        coldStart = false
+      }
+
+      tx.end()
+      return result
+    })
+
+    await appMethod(...args)
+  }
+}
+
+function wrapAzureBackgroundMethods(shim, appMethod) {
+  return async function wrappedAzureBackgroundMethod(...args) {
+    let handler
+    if (typeof args[1] === 'function') {
+      handler = args[1]
+      args[1] = { handler }
+    } else {
+      handler = args[1].handler
+    }
+
+    const tracer = shim.tracer
+    args[1].handler = tracer.transactionProxy(async function wrappedHandler(...args) {
+      const [, context] = args
+      const ctx = tracer.getContext()
+      const tx = tracer.getTransaction()
+
+      tx.setPartialName(`AzureFunction/${context.functionName}`)
+
+      const segment = tracer.createSegment({
+        name: `${appMethod}-trigger`,
+        recorder: backgroundRecorder,
+        parent: ctx.segment,
+        transaction: tx
+      })
+      segment.start()
+
+      tx.type = TYPES.BG
+      tx.baseSegment = segment
+      addAttributes({ transaction: tx, functionContext: context })
+
+      const newContext = ctx.enterSegment({ segment })
+      const boundHandler = tracer.bindFunction(handler, newContext)
+
+      const result = await boundHandler(...args)
+      if (coldStart === true) {
+        tx.trace.attributes.addAttribute(DESTS.TRANS_COMMON, 'faas.coldStart', true)
+        coldStart = false
+      }
+
+      tx.end()
+      return result
+    })
+
+    await appMethod(...args)
+  }
+}
+
+/**
+ * Add required New Relic attributes to the transaction.
+ *
+ * @param {object} params Function parameters.
+ * @param {Transaction} params.transaction The transaction to update.
+ * @param {object} params.functionContext The function invocation context
+ * provided by the Azure functions runtime.
+ */
+function addAttributes({ 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',
+    mapTriggerType({ functionContext })
+  )
+  transaction.trace.attributes.addAttribute(
+    DESTS.TRANS_COMMON,
+    'cloud.resource_id',
+    buildCloudResourceId({ functionContext })
+  )
+}
+
+/**
+ * Inspects the provided function invocation context and returns a recognized
+ * trigger type suitable for sending to the collector as `faas.trigger`.
+ *
+ * @param {object} params Function parameters
+ * @param {object} params.functionContext The function context as provided by
+ * the Azure functions runtime.
+ *
+ * @returns {string} A string appropriate for New Relic.
+ */
+function 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'
+    }
+  }
+}
+
+function buildCloudResourceId({ functionContext }) {
+  return [
+    '/subscriptions/',
+    SUBSCRIPTION_ID,
+    '/resourceGroups/',
+    RESOURCE_GROUP_NAME,
+    '/providers/Microsoft.Web/sites/',
+    AZURE_FUNCTION_APP_NAME,
+    '/functions/',
+    functionContext.functionName
+  ].join('')
+}
+
+module.exports.internals = {
+  addAttributes,
+  mapTriggerType,
+  buildCloudResourceId
+}

package/lib/instrumentations.js

@@ -10,6 +10,7 @@ const InstrumentationDescriptor = require('./instrumentation-descriptor')
 // Return a new copy of this array every time we're called
 module.exports = function instrumentations() {
   return {
+    '@azure/functions': { type: InstrumentationDescriptor.TYPE_GENERIC },
     '@elastic/elasticsearch': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     '@opensearch-project/opensearch': { type: InstrumentationDescriptor.TYPE_DATASTORE },
     '@grpc/grpc-js': { module: './instrumentation/grpc-js' },

package/lib/otel/rules.js

@@ -46,6 +46,7 @@ class Rule {
   static OTEL_SPAN_KIND_SERVER = 'server'
   static OTEL_SPAN_KIND_CLIENT = 'client'
   static OTEL_SPAN_KIND_PRODUCER = 'producer'
+  static OTEL_SPAN_KIND_CONSUMER = 'consumer'
   static OTEL_SPAN_KIND_INTERNAL = 'internal'
 
   #name
@@ -87,10 +88,6 @@ class Rule {
     return this.#spanKinds.includes(Rule.OTEL_SPAN_KIND_CLIENT)
   }
 
-  get isConsumer() {
-    return this.#spanKinds.includes('consumer')
-  }
-
   get isInternalRule() {
     return this.#spanKinds.includes('internal')
   }
@@ -99,8 +96,12 @@ class Rule {
     return this.#spanKinds.includes(Rule.OTEL_SPAN_KIND_PRODUCER)
   }
 
+  get isConsumerRule() {
+    return this.#spanKinds.includes(Rule.OTEL_SPAN_KIND_CONSUMER)
+  }
+
   get isServerRule() {
-    return this.#spanKinds.includes(Rule.OTEL_SPAN_KIND_SERVER) || this.isConsumer
+    return this.#spanKinds.includes(Rule.OTEL_SPAN_KIND_SERVER)
   }
 
   /**
@@ -129,7 +130,9 @@ class Rule {
 
 class RulesEngine {
   #serverRules = new Map()
+  #consumerRules = new Map()
   #fallbackServerRules = new Map()
+  #fallbackConsumerRules = new Map()
   #clientRules = new Map()
   #fallbackClientRules = new Map()
   #fallbackInternalRules = new Map()
@@ -142,6 +145,8 @@ class RulesEngine {
       if (/fallback/i.test(rule.name) === true) {
         if (rule.isServerRule === true) {
           this.#fallbackServerRules.set(rule.name, rule)
+        } else if (rule.isConsumerRule === true) {
+          this.#fallbackConsumerRules.set(rule.name, rule)
         } else if (rule.isClientRule === true) {
           this.#fallbackClientRules.set(rule.name, rule)
         } else if (rule.isProducerRule === true) {
@@ -154,6 +159,8 @@ class RulesEngine {
 
       if (rule.isServerRule === true) {
         this.#serverRules.set(rule.name, rule)
+      } else if (rule.isConsumerRule === true) {
+        this.#consumerRules.set(rule.name, rule)
       } else if (rule.isClientRule === true) {
         this.#clientRules.set(rule.name, rule)
       }
@@ -174,8 +181,7 @@ class RulesEngine {
 
     // eslint-disable-next-line sonarjs/no-labels, no-labels
     detector: switch (otelSpan.kind) {
-      case SpanKind.SERVER:
-      case SpanKind.CONSUMER: {
+      case SpanKind.SERVER: {
         for (const rule of this.#serverRules.values()) {
           if (rule.matches(otelSpan) === true) {
             result = rule
@@ -192,6 +198,23 @@ class RulesEngine {
         break
       }
 
+      case SpanKind.CONSUMER: {
+        for (const rule of this.#consumerRules.values()) {
+          if (rule.matches(otelSpan) === true) {
+            result = rule
+            // eslint-disable-next-line no-labels
+            break detector
+          }
+        }
+        for (const rule of this.#fallbackConsumerRules.values()) {
+          if (rule.matches(otelSpan) === true) {
+            result = rule
+            break
+          }
+        }
+        break
+      }
+
       case SpanKind.CLIENT: {
         for (const rule of this.#clientRules.values()) {
           if (rule.matches(otelSpan) === true) {

package/lib/spans/base-span-streamer.js

@@ -25,14 +25,14 @@ class BaseSpanStreamer {
     // 'connected' indicates a safely writeable stream.
     // May still be mid-connect to gRPC server.
     this.connection.on('connected', (stream) => {
-      logger.info('Span streamer connected')
+      logger.trace('Span streamer connected, flushing queue')
       this.stream = stream
       this._writable = true
       this.sendQueue()
     })
 
     this.connection.on('disconnected', () => {
-      logger.info('Span streamer disconnected')
+      logger.trace('Span streamer disconnected')
       this.stream = null
       this._writable = false
     })
@@ -52,9 +52,10 @@ class BaseSpanStreamer {
   write(span) {
     this._metrics.getOrCreateMetric(NAMES.SEEN).incrementCallCount()
 
-    // If not writeable (because of backpressure) queue the span
+    // If not writable (because of backpressure) queue the span
     if (!this._writable) {
       if (this.spans.length < this.queue_size) {
+        logger.trace('stream not writable, add spans to queue')
         this.addToQueue(span)
         return
       }
@@ -78,16 +79,17 @@ class BaseSpanStreamer {
    *  span, a drain event handler is setup to continue writing when possible.
    *
    * @param {*} data spans or span
-   * @param {number} [spanLen] number of spans sent in a stream(defaults to 1)
    */
-  send(data, spanLen = 1) {
+  send(data) {
+    const spans = data?.spans?.length || 1
+    this._writable = this.stream.write(data)
+    this._metrics.getOrCreateMetric(NAMES.SENT).incrementCallCount(spans)
+
     // false indicates the stream has reached the highWaterMark
     // and future writes should be avoided until drained. written items,
     // including the one that returned false, will still be buffered.
-    this._writable = this.stream.write(data)
-    this._metrics.getOrCreateMetric(NAMES.SENT).incrementCallCount(spanLen)
-
     if (!this._writable) {
+      logger.trace('Stream is not writable, adding a drain listener to flush queue when it is writable.')
       const waitDrainStart = Date.now()
       const onDrain = this.drain.bind(this, waitDrainStart)
       this.stream.once('drain', onDrain)
@@ -112,7 +114,6 @@ class BaseSpanStreamer {
 
     // Once the 'drain' event fires we can begin writing to the stream again
     this._writable = true
-
     this.sendQueue()
   }
 

package/lib/spans/batch-span-streamer.js

@@ -9,22 +9,11 @@ const logger = require('../logger').child({ component: 'batch-span-streamer' })
 const BaseSpanStreamer = require('./base-span-streamer')
 
 class BatchSpanStreamer extends BaseSpanStreamer {
-  constructor(licenseKey, connection, metrics, queueSize) {
+  constructor(licenseKey, connection, metrics, queueSize, batchSize) {
     super(licenseKey, connection, metrics, queueSize)
     this.sendTimer = null
-    this.batchSize = 750
-    this.connection.on('connected', () => {
-      logger.debug('Setting up batch interval')
-      this.sendTimer = setInterval(this.sendQueue.bind(this), 5000)
-      this.sendTimer.unref()
-    })
-
-    this.connection.on('disconnected', () => {
-      logger.debug('Clearing batch interval')
-      if (this.sendTimer) {
-        clearInterval(this.sendTimer)
-      }
-    })
+    this.batchSize = batchSize
+    this.queueInterval = 5000
   }
 
   addToQueue(span) {
@@ -35,6 +24,11 @@ class BatchSpanStreamer extends BaseSpanStreamer {
    * or drops it depending on stream/queue state
    */
   write(span) {
+    const currTime = Date.now()
+
+    if (!this.time) {
+      this.time = currTime
+    }
     super.write(span)
 
     if (!this._writable) {
@@ -43,18 +37,29 @@ class BatchSpanStreamer extends BaseSpanStreamer {
 
     this.addToQueue(span)
 
-    if (this.spans.length < this.queue_size) {
-      return
+    if (this.batchReady(currTime)) {
+      this.sendQueue()
+      this.time = currTime
     }
+  }
 
-    this.sendQueue()
+  /**
+   *  The Infinite Tracing trace observer will treat spans that are more than 10 seconds apart as not belonging to the same group.
+   *  It is therefore recommended that the agent perform a RecordSpanBatch request when either a target maximum batch size is reached or 5 seconds have elapsed since the creation of a batch (giving precedence to whichever of these events takes place first).
+   *  Otherwise, delayed recording of spans will lead to their being discarded.
+   *
+   * @param {number} currTime timestamp in milliseconds
+   * @returns {boolean} if a batch can we sent
+   */
+  batchReady(currTime) {
+    return this.spans.length >= this.batchSize || currTime - this.time >= this.queueInterval
   }
 
   /**
-   * Chunks the span queue into n per batch(currently at 750).
+   * Chunks the span queue into n per batch.
    * The avg span is generally 1kb, picking an option slightly under to avoid
    * being over 1MB uncompressed limit being imposed on the gRPC server.
-   * Since the processing happens asyc it'll be very hard to split further
+   * Since the processing happens async it'll be very hard to split further
    * if a span batch is too big. We are being conservative here and other
    * language agents transmit even smaller batches(100 per batch).
    */
@@ -64,15 +69,13 @@ class BatchSpanStreamer extends BaseSpanStreamer {
       return
     }
 
-    for (let i = 0; i < this.spans.length; i += this.batchSize) {
-      const spans = this.spans.slice(i, i + this.batchSize)
+    while (this.spans.length > 0 && this._writable) {
+      const spans = this.spans.splice(0, this.batchSize)
       logger.trace('Sending spans from queue: %s', spans.length)
-      this.send({ spans }, spans.length)
+      this.send({ spans })
     }
 
-    this.spans = []
-
-    logger.trace('Finished sending spans from queue.')
+    logger.trace('Finished sending spans from queue. Items left in queue: %s', this.spans.length)
   }
 }
 

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

@@ -54,7 +54,8 @@ function createStreamingAggregator(config, agent) {
       config.license_key,
       connection,
       metrics,
-      config.infinite_tracing.span_events.queue_size
+      config.infinite_tracing.span_events.queue_size,
+      config.infinite_tracing.span_events.batch_size
     )
     metrics.getOrCreateMetric(`${NAMES.BATCHING}/enabled`).incrementCallCount()
   } else {

package/lib/spans/span-streamer.js

@@ -44,7 +44,7 @@ class SpanStreamer extends BaseSpanStreamer {
 
     logger.trace('Sending spans from queue: %s.', this.spans.length)
 
-    // Continue sending the spans that were in the queue. _writable is checked
+    // Continue sending the spans that were in the queue. this._writable is checked
     // so that if a send fails while clearing the queue, this drain handler can
     // finish, and the drain handler setup on the failed send will then attempt
     // to clear the queue

package/lib/util/logger.js

@@ -10,6 +10,33 @@ const util = require('util')
 const Readable = require('readable-stream')
 const os = require('os')
 
+/**
+ * A logging utility with methods `info`, `warn`, `error`, `fatal`, `debug`,
+ * and `trace`. This logger is very similar to Pino.
+ *
+ * Each method supports the following invocation signatures:
+ *
+ * @example
+ * // Logs a single string.
+ * logger.info('hello world')
+ *
+ * @example
+ * // Logs an interpolated string.
+ * logger.info('hello %s', 'world')
+ *
+ * @example
+ * // Logs with data properties inlined:
+ * logger.info({a: 1, b: 2}, 'logged data')
+ * // e.g. `{ a: 1, b: 2, msg: 'logged data', level: 30 }`
+ *
+ * @example
+ * // Recommended for keeping data usable:
+ * logger.info({ data: { the: 'data', that: 'is important' }}, 'some message')
+ * // ^ only the `data` key will be inlined at the top level. The sub-properties
+ * // will still be nested under the data key.
+ *
+ * @type {Object}
+ */
 module.exports = Logger
 
 const LEVELS = {
@@ -294,12 +321,17 @@ function getPropertiesToLog(extra) {
   const obj = Object.assign(Object.create(null), extra)
   // Error properties (message, stack) are not enumerable, so getting them directly
   if (extra instanceof Error) {
-    const names = Object.getOwnPropertyNames(extra)
-    if (names) {
-      for (let i = 0; i < names.length; i++) {
-        obj[names[i]] = extra[names[i]]
-      }
-    }
+    decorateFromErrorInstance(obj, extra)
+  } else if (extra?.error != null) {
+    obj.error = {}
+    decorateFromErrorInstance(obj.error, extra.error)
   }
   return obj
 }
+
+function decorateFromErrorInstance(toDecorate, errorInstance) {
+  const names = Object.getOwnPropertyNames(errorInstance)
+  for (const name of names) {
+    toDecorate[name] = errorInstance[name]
+  }
+}

package/lib/utilization/aws-info.js

@@ -19,10 +19,12 @@ module.exports.clearCache = function clearAWSCache() {
 
 function fetchAWSInfo(agent, callback) {
   if (!agent.config.utilization || !agent.config.utilization.detect_aws) {
+    logger.trace({ utilization: 'aws' }, 'Skipping AWS due to being disabled via config.')
     return setImmediate(callback, null)
   }
 
   if (results) {
+    logger.trace({ utilization: 'aws' }, 'Returning previously found results.')
     return setImmediate(callback, null, results)
   }
 
@@ -35,7 +37,7 @@ function fetchAWSInfo(agent, callback) {
   }
   common.request(authTokenOpts, agent, function getAuthToken(err, authToken) {
     if (err) {
-      logger.debug('Failed to get AWS auth token.')
+      logger.debug({ utilization: 'aws' }, 'Failed to get AWS auth token.')
       return callback(err)
     }
 
@@ -49,19 +51,20 @@ function fetchAWSInfo(agent, callback) {
 
     common.request(metadataOpts, agent, function getMetadata(metaErr, data) {
       if (metaErr) {
+        logger.trace({ utilization: 'aws' }, 'Returning due to error from metadata service.')
         return callback(metaErr)
       }
 
       try {
         data = JSON.parse(data)
       } catch (e) {
-        logger.debug(e, 'Failed to parse AWS metadata.')
+        logger.debug({ utilization: 'aws', error: e }, 'Failed to parse AWS metadata.')
         data = null
       }
 
       results = common.getKeys(data, ['availabilityZone', 'instanceId', 'instanceType'])
       if (results == null) {
-        logger.debug('AWS metadata was invalid.')
+        logger.debug({ utilization: 'aws' }, 'AWS metadata was invalid.')
         agent.metrics.getOrCreateMetric(NAMES.UTILIZATION.AWS_ERROR).incrementCallCount()
       }
       callback(null, results)

package/lib/utilization/azure-info.js

@@ -17,10 +17,12 @@ module.exports.clearCache = function clearAzureCache() {
 
 function fetchAzureInfo(agent, callback) {
   if (!agent.config.utilization || !agent.config.utilization.detect_azure) {
+    logger.trace({ utilization: 'azure' }, 'Skipping Azure due to being disabled via config.')
     return setImmediate(callback, null, null)
   }
 
   if (results) {
+    logger.trace({ utilization: 'azure' }, 'Returning previously found results.')
     return setImmediate(callback, null, results)
   }
 
@@ -37,6 +39,7 @@ function fetchAzureInfo(agent, callback) {
     agent,
     function getMetadata(err, data) {
       if (err) {
+        logger.trace({ utilization: 'azure', error: err }, 'Failed to query metadata endpoint.')
         return callback(err)
       }
 
@@ -44,14 +47,14 @@ function fetchAzureInfo(agent, callback) {
       try {
         data = JSON.parse(data)
       } catch (e) {
-        logger.debug(e, 'Failed to parse Azure metadata.')
+        logger.debug({ utilization: 'azure', error: e }, 'Failed to parse Azure metadata.')
         data = null
       }
 
       // Get out just the keys we care about.
       results = common.getKeys(data, ['location', 'name', 'vmId', 'vmSize'])
       if (results == null) {
-        logger.debug('Azure metadata was invalid.')
+        logger.debug({ utilization: 'azure' }, 'Azure metadata was invalid.')
         agent.metrics.getOrCreateMetric(NAMES.UTILIZATION.AZURE_ERROR).incrementCallCount()
       }
 

package/lib/utilization/azurefunction-info.js

@@ -16,17 +16,19 @@ module.exports.clearCache = function clearAzureFunctionCache() {
 
 function fetchAzureFunctionInfo(agent, callback) {
   if (!agent.config.utilization || !agent.config.utilization.detect_azurefunction) {
+    logger.trace({ utilization: 'azurefunction' }, 'Skipping Azure function due to being disabled via config.')
     return setImmediate(callback, null, null)
   }
 
   if (results) {
+    logger.trace({ utilization: 'azurefunction' }, 'Returning previously found results.')
     return setImmediate(callback, null, results)
   }
 
   // Detect if Azure Function.
   const { REGION_NAME, WEBSITE_OWNER_NAME, WEBSITE_SITE_NAME, WEBSITE_RESOURCE_GROUP } = process.env
   if (!REGION_NAME || !WEBSITE_OWNER_NAME || !WEBSITE_SITE_NAME) {
-    logger.debug('Azure Function metadata was invalid.')
+    logger.debug({ utilization: 'azurefunction' }, 'Azure Function metadata was invalid.')
     agent.metrics.getOrCreateMetric(NAMES.UTILIZATION.AZURE_ERROR).incrementCallCount()
     return setImmediate(callback, null, null)
   }

package/lib/utilization/docker-info.js

@@ -28,7 +28,7 @@ function clearDockerVendorCache() {
 
 function getBootId(agent, callback, logger = log) {
   if (!/linux/i.test(os.platform())) {
-    logger.debug('Platform is not a flavor of linux, omitting boot info')
+    logger.debug({ utilization: 'docker' }, 'Platform is not a flavor of linux, omitting boot info')
     return setImmediate(callback, null, null)
   }
 
@@ -40,7 +40,7 @@ function getBootId(agent, callback, logger = log) {
       })
     }
 
-    logger.debug('Container boot id is not available in cgroups info')
+    logger.debug({ utilization: 'docker' }, 'Container boot id is not available in cgroups info')
     callback(null, null)
   })
 }
@@ -98,6 +98,7 @@ function readProcBootId({ data, agent, callback }) {
  */
 function fetchDockerVendorInfo(agent, callback, logger = log) {
   if (!agent.config.utilization || !agent.config.utilization.detect_docker) {
+    logger.trace({ utilization: 'docker' }, 'Skipping Docker due to being disabled via config.')
     return callback(null, null)
   }
 
@@ -106,7 +107,7 @@ function fetchDockerVendorInfo(agent, callback, logger = log) {
   }
 
   if (!os.platform().match(/linux/i)) {
-    logger.debug('Platform is not a flavor of linux, omitting docker info')
+    logger.debug({ utilization: 'docker' }, 'Platform is not a flavor of linux, omitting docker info')
     return callback(null, null)
   }
 
@@ -114,6 +115,7 @@ function fetchDockerVendorInfo(agent, callback, logger = log) {
   common.readProc(CGROUPS_V2_PATH, function getV2CGroup(_, data) {
     if (data === null) {
       logger.debug(
+        { utilization: 'docker' },
         `${CGROUPS_V2_PATH} not found, trying to parse container id from ${CGROUPS_V1_PATH}`
       )
       findCGroupsV1(callback, logger)
@@ -126,13 +128,14 @@ function fetchDockerVendorInfo(agent, callback, logger = log) {
         if (v2Data !== null) {
           // We found a valid Docker identifier in the v2 file, so we are going
           // to prioritize it.
+          logger.debug({ utilization: 'docker', v2Data }, 'Found identifier in cgroups v2 file.')
           return callback(null, v2Data)
         }
 
         // For some reason, we have a /proc/self/mountinfo but it does not have
         // any Docker information in it (that we have detected). So we will
         // fall back to trying the cgroups v1 file.
-        logger.debug('Attempting to fall back to cgroups v1 parsing.')
+        logger.debug({ utilization: 'docker' }, 'Attempting to fall back to cgroups v1 parsing.')
         findCGroupsV1(callback, logger)
       },
       logger
@@ -152,10 +155,10 @@ function parseCGroupsV2(data, callback, logger = log) {
   const containerLine = /\/docker\/containers\/([0-9a-f]{64})\//
   const line = containerLine.exec(data)
   if (line) {
-    logger.debug(`Found docker id from cgroups v2: ${line[1]}`)
+    logger.debug({ utilization: 'docker' }, `Found docker id from cgroups v2: ${line[1]}`)
     callback(null, { id: line[1] })
   } else {
-    logger.debug(`Found ${CGROUPS_V2_PATH} but failed to parse Docker container id.`)
+    logger.debug({ utilization: 'docker' }, `Found ${CGROUPS_V2_PATH} but failed to parse Docker container id.`)
     callback(null, null)
   }
 }
@@ -170,7 +173,7 @@ function parseCGroupsV2(data, callback, logger = log) {
 function findCGroupsV1(callback, logger = log) {
   common.readProc(CGROUPS_V1_PATH, function getCGroup(_, data) {
     if (!data) {
-      logger.debug(`${CGROUPS_V1_PATH} not found, exiting parsing containerId.`)
+      logger.debug({ utilization: 'docker' }, `${CGROUPS_V1_PATH} not found, exiting parsing containerId.`)
       return callback(null)
     }
 
@@ -187,10 +190,10 @@ function findCGroupsV1(callback, logger = log) {
 
     if (id) {
       vendorInfo = { id }
-      logger.debug(`Found docker id from cgroups v1: ${id}`)
+      logger.debug({ utilization: 'docker' }, `Found docker id from cgroups v1: ${id}`)
       callback(null, vendorInfo)
     } else {
-      logger.debug('No matching cpu group found.')
+      logger.debug({ utilization: 'docker' }, 'No matching cpu group found.')
       callback(null, null)
     }
   })

package/lib/utilization/ecs-info.js

@@ -21,11 +21,12 @@ module.exports = function fetchEcsInfo(
   // Per spec, we do not have a `detect_ecs` key. Since ECS is a service of AWS,
   // we rely on the `detect_aws` setting.
   if (!agent.config.utilization || !agent.config.utilization.detect_aws) {
+    logger.trace({ utilization: 'ecs' }, 'Skipping ECS due to being disabled via config.')
     return setImmediate(callback, null)
   }
 
   if (hasAwsContainerApi() === false) {
-    logger.debug('ECS API not available, omitting ECS container id info')
+    logger.debug({ utilization: 'ecs' }, 'ECS API not available, omitting ECS container id info')
     recordIdError(agent)
     return callback(null, null)
   }
@@ -70,13 +71,13 @@ function _getEcsContainerId({ agent, callback, logger, recordIdError }) {
         const json = body.toString('utf8')
         const data = JSON.parse(json)
         if (data.DockerId == null) {
-          logger.debug('Failed to find DockerId in response, omitting boot info')
+          logger.debug({ utilization: 'ecs' }, 'Failed to find DockerId in response, omitting boot info')
           recordIdError(agent)
           return callback(null, null)
         }
         callback(null, data.DockerId)
       } catch (error) {
-        logger.debug('Failed to process ECS API response, omitting boot info: ' + error.message)
+        logger.debug({ utilization: 'ecs' }, 'Failed to process ECS API response, omitting boot info: ' + error.message)
         recordIdError(agent)
         callback(null, null)
       }
@@ -84,7 +85,7 @@ function _getEcsContainerId({ agent, callback, logger, recordIdError }) {
   })
 
   req.on('error', () => {
-    logger.debug('Failed to query ECS endpoint, omitting boot info')
+    logger.debug({ utilization: 'ecs' }, 'Failed to query ECS endpoint, omitting boot info')
     recordIdError(agent)
     callback(null, null)
   })

package/lib/utilization/gcp-info.js

@@ -18,10 +18,12 @@ module.exports.clearCache = function clearGCPCache() {
 
 function fetchGCPInfo(agent, callback) {
   if (!agent.config.utilization || !agent.config.utilization.detect_gcp) {
+    logger.trace({ utilization: 'gcp' }, 'Skipping GCP due to being disabled via config.')
     return setImmediate(callback, null)
   }
 
   if (resultDict) {
+    logger.trace({ utilization: 'gcp' }, 'Returning previously found results.')
     return setImmediate(callback, null, resultDict)
   }
 
@@ -36,6 +38,7 @@ function fetchGCPInfo(agent, callback) {
     agent,
     function getMetadata(err, data) {
       if (err) {
+        logger.trace({ utilization: 'gcp', error: err }, 'Failed to communicate with metadata endpoint.')
         return callback(err)
       }
       try {
@@ -44,13 +47,13 @@ function fetchGCPInfo(agent, callback) {
           data.id = data.id.toString()
         }
       } catch (e) {
-        logger.debug(e, 'Failed to parse GCP metadata.')
+        logger.debug({ utilization: 'gcp', error: e }, 'Failed to parse GCP metadata.')
         data = null
       }
 
       const results = common.getKeys(data, ['id', 'machineType', 'name', 'zone'])
       if (results == null) {
-        logger.debug('GCP metadata was invalid.')
+        logger.debug({ utilization: 'gcp' }, 'GCP metadata was invalid.')
         agent.metrics.getOrCreateMetric(NAMES.UTILIZATION.GCP_ERROR).incrementCallCount()
       } else {
         // normalize

package/lib/utilization/index.js

@@ -24,8 +24,9 @@ function getVendors(agent, callback) {
   let done = 0
   let vendors = null
   VENDOR_NAMES.forEach(function getVendorInfo(vendor) {
+    logger.trace({ utilization: vendor }, 'Detecting utilization info for vendor %s', vendor)
     VENDOR_METHODS[vendor](agent, function getInfo(_, result) {
-      logger.trace('Vendor %s finished.', vendor)
+      logger.trace({ utilization: vendor, data: { result } }, 'Vendor %s finished.', vendor)
       if (result) {
         vendors = vendors || Object.create(null)
         vendors[vendor] = result

package/lib/utilization/kubernetes-info.js

@@ -9,21 +9,23 @@ const logger = require('../logger').child({ component: 'kubernetes-info' })
 let info = null
 
 module.exports = getKubernetesInfo
-module.exports.clearCache = function clearAWSCache() {
+module.exports.clearCache = function clearKubernetesCache() {
   info = null
 }
 
 function getKubernetesInfo(agent, callback) {
   if (!agent.config.utilization || !agent.config.utilization.detect_kubernetes) {
+    logger.trace({ utilization: 'kubernetes' }, 'Skipping Kubernetes due to being disabled via config.')
     return setImmediate(callback, null, null)
   }
 
   if (info) {
+    logger.trace({ utilization: 'kubernetes' }, 'Returning previously found results.')
     return setImmediate(callback, null, info)
   }
 
   if (!process.env.KUBERNETES_SERVICE_HOST) {
-    logger.debug('No Kubernetes service host found.')
+    logger.debug({ utilization: 'kubernetes' }, 'No Kubernetes service host found.')
     return setImmediate(callback, null, null)
   }
 

package/lib/utilization/pcf-info.js

@@ -13,6 +13,7 @@ module.exports = fetchPCFInfo
 
 function fetchPCFInfo(agent, callback) {
   if (!agent.config.utilization || !agent.config.utilization.detect_pcf) {
+    logger.trace({ utilization: 'pcf' }, 'Skipping PCF due to being disabled via config.')
     return setImmediate(callback, null, null)
   }
 
@@ -28,11 +29,11 @@ function fetchPCFInfo(agent, callback) {
     const key = keys[i]
     const value = process.env[key]
     if (value == null) {
-      logger.trace('Could not find environment value for %s', key)
+      logger.trace({ utilization: 'pcf' }, 'Could not find environment value for %s', key)
       return setImmediate(callback, null, null)
     }
     if (!common.checkValueString(value)) {
-      logger.trace('Invalid environment value for %s: %j', key, value)
+      logger.trace({ utilization: 'pcf' }, 'Invalid environment value for %s: %j', key, value)
       agent.metrics.getOrCreateMetric(NAMES.UTILIZATION.PCF_ERROR).incrementCallCount()
       return setImmediate(callback, null, null)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "12.17.0",
+  "version": "12.18.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -200,7 +200,7 @@
     "#test/assert": "./test/lib/custom-assertions/index.js"
   },
   "dependencies": {
-    "@grpc/grpc-js": "^1.12.2",
+    "@grpc/grpc-js": "^1.13.2",
     "@grpc/proto-loader": "^0.7.5",
     "@newrelic/security-agent": "^2.3.0",
     "@opentelemetry/api": "^1.9.0",