chore: Refactored zlib instrumentation to be subscriber based

lib/context-manager/async-local-context-manager.js

@@ -24,6 +24,16 @@ class AsyncLocalContextManager {
     this._asyncLocalStorage = new AsyncLocalStorage()
   }
 
+  /**
+   * The underlying local storage object.
+   *
+   * @see https://nodejs.org/api/async_context.html#class-asynclocalstorage
+   * @returns {AsyncLocalStorage}
+   */
+  get store() {
+    return this._asyncLocalStorage
+  }
+
   /**
    * Get the currently active context.
    *

lib/core-instrumentation.js

@@ -47,9 +47,5 @@ module.exports = {
   timers: {
     type: InstrumentationDescriptor.TYPE_GENERIC,
     file: 'timers.js'
-  },
-  zlib: {
-    type: InstrumentationDescriptor.TYPE_GENERIC,
-    file: 'zlib.js'
   }
 }

lib/subscriber-configs.js

@@ -45,7 +45,10 @@ const subscribers = {
   ...require('./subscribers/redis-client/config'),
   ...require('./subscribers/undici/config'),
   ...require('./subscribers/when/config'),
-  ...require('./subscribers/winston/config')
+  ...require('./subscribers/winston/config'),
+
+  // Node.js Core modules:
+  ...require('./subscribers/core/zlib/config')
 }
 
 module.exports = subscribers

lib/subscribers/core/zlib/config.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+module.exports = {
+  zlib: [
+    {
+      path: './core/zlib/tc.js',
+      instrumentations: []
+    }
+  ]
+}

lib/subscribers/core/zlib/tc.js

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const zlib = require('node:zlib')
+// eslint-disable-next-line n/no-unsupported-features/node-builtins
+const { tracingChannel } = require('node:diagnostics_channel')
+
+const {
+  TracingChannelSubscription,
+  TracingChannelSubscriber
+} = require('#agentlib/subscribers/tracing-channel-subscriber.js')
+const { wrapMethod } = require('#agentlib/subscribers/wrap-method.js')
+
+const methods = [
+  'deflate',
+  'deflateRaw',
+  'gzip',
+  'gunzip',
+  'inflate',
+  'inflateRaw',
+  'unzip'
+]
+const subscriptions = []
+for (const method of methods) {
+  // First we need to monkey-patch the module methods to generating
+  // tracing channel events.
+  const chanName = `nr_core:zlib:${method}`
+  wrapMethod({
+    module: zlib,
+    methodName: method,
+    wrapper(originalMethod, methodName) {
+      const chan = tracingChannel(chanName)
+      const data = { segmentName: `zlib.${methodName}` }
+      return function wrappedMethod(...args) {
+        chan.traceCallback(originalMethod, -1, data, this, ...args)
+      }
+    }
+  })
+
+  // Now we can create a subscription for the channel we created.
+  const sub = new TracingChannelSubscription({ channel: chanName })
+  subscriptions.push(sub)
+}
+
+class ZlibSubscriber extends TracingChannelSubscriber {
+  constructor({ agent, logger }) {
+    super({ agent, logger, packageName: 'zlib', subs: subscriptions })
+  }
+}
+
+module.exports = ZlibSubscriber

lib/subscribers/subscriber.js

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+/**
+ * This is an interface class. It defines the methods each subclass _must_
+ * implement and override in order for the diagnostics channel or tracing
+ * channel subscriptions to work.
+ *
+ * @property {object} agent A New Relic Node.js agent instance.
+ * @property {object} logger An agent logger instance.
+ * @property {object} config The agent configuration object.
+ * @property {string} packageName The name of the module being instrumented.
+ * This is the same string one would pass to the `require` function.
+ * @property {string} id An alias for `packageName`.
+ *
+ * @private
+ * @interface
+ */
+class Subscriber {
+  #agent
+  #config
+  #logger
+  #packageName
+
+  constructor({ agent, logger, packageName }) {
+    this.#agent = agent
+    this.#config = agent.config
+    this.#logger = logger.child({ component: `${packageName}-subscriber` })
+    this.#packageName = packageName
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'Subscriber'
+  }
+
+  get agent() {
+    return this.#agent
+  }
+
+  get config() {
+    return this.#config
+  }
+
+  get id() {
+    return this.#packageName
+  }
+
+  get logger() {
+    return this.#logger
+  }
+
+  get packageName() {
+    return this.#packageName
+  }
+
+  /**
+   * Indicates if the subscription should be enabled or not. The most likely
+   * scenario is that an implementation will consult the agent configuration
+   * to determine the result.
+   *
+   * @returns {boolean} Subscriber is enabled or not.
+   */
+  get enabled() {
+    throw Error('enabled is not implemented on class: ' + this.constructor.name)
+  }
+
+  /**
+   * Implementations should utilize subclass specific configuration or logic
+   * to enable the subscriber. This is basically a start-up lifecycle hook
+   * that the implementation can use to perform necessary actions, e.g.
+   * creating an asynchronous context and binding it to an appropriate channel.
+   *
+   * @returns {void | Function | boolean} Result of the enablement. Not likely
+   * to be used.
+   */
+  enable() {
+    throw Error('enable is not implemented on class: ' + this.constructor.name)
+  }
+
+  /**
+   * The inverse of the `enable` method. It's basically an agent shutdown
+   * lifecycle hook. Any clean up logic required as a result of the work
+   * performed in the `enable` method should be hosted here.
+   *
+   * @returns {void | boolean} Result of the disablement. Not likely to be
+   * used.
+   */
+  disable() {
+    throw Error('disable is not implemented on class: ' + this.constructor.name)
+  }
+
+  /**
+   * Classes must implement this method. It is expected to read some
+   * configuration data, specific to the subclass, and utilize it to
+   * perform the channel subscriptions.
+   *
+   * @returns {void}
+   *
+   * @example A basic "Diagnostics Channel" based method.
+   * const dc = require('node:diagnostics_channel')
+   * for (const sub of this.#subscriptions) {
+   *   dc.subscribe(sub.channelName, sub.hook.bind(this))
+   * }
+   */
+  subscribe() {
+    throw Error('subscribe is not implemented on class: ' + this.constructor.name)
+  }
+
+  /**
+   * The inverse of the `subscribe` method. This should iterate through the
+   * subscribed channels and issue any unsubscribe and clean-up logic for them.
+   *
+   * @returns {void}
+   */
+  unsubscribe() {
+    throw Error('unsubscribe is not implemented on class: ' + this.constructor.name)
+  }
+}
+
+module.exports = Subscriber