fix(dns): preserve shorthand rrtype with options (#9624)

* fix(dns): preserve shorthand rrtype with options

DNS shorthand calls with an options object were captured as [hostname, options, rrtype], so the plugin read the options object and fell back to A even when Node performed an AAAA query. Keep the synthetic record type in the plugin context slot while preserving the original options.

Fixes: #9621

* fix(dns): instrument CAA and TLSA resolve shorthands

## Summary

Node 18 exposes resolveCaa and newer releases expose resolveTlsa, but both were absent from the shorthand table and emitted no DNS spans.

## Why

In-place argument shifting measured 15.4 ns/context versus 32.2 ns/context for splice on Node 24.18.0 / V8 13.6 (two seven-trial runs, dropping the best and worst).

## Test plan

- packages/datadog-plugin-dns/test/index.spec.js

Refs: #9621

Author: BridgeAR

packages/datadog-instrumentations/src/dns.js

@@ -9,6 +9,7 @@ const rrtypes = {
   resolveAny: 'ANY',
   resolve4: 'A',
   resolve6: 'AAAA',
+  resolveCaa: 'CAA',
   resolveCname: 'CNAME',
   resolveMx: 'MX',
   resolveNs: 'NS',
@@ -17,6 +18,7 @@ const rrtypes = {
   resolvePtr: 'PTR',
   resolveNaptr: 'NAPTR',
   resolveSoa: 'SOA',
+  resolveTlsa: 'TLSA',
 }
 
 // `dns.promises` and `require('dns/promises')` resolve to the same exports object. Both
@@ -81,7 +83,7 @@ function buildCallbackArgsContext (rrtype) {
     const captured = [...args]
     captured.pop() // remove the callback
     if (rrtype) {
-      captured.push(rrtype)
+      insertRrtype(captured, rrtype)
     }
     return { args: captured }
   }
@@ -91,8 +93,25 @@ function buildPromiseArgsContext (rrtype) {
   return function (_, args) {
     const captured = [...args]
     if (rrtype) {
-      captured.push(rrtype)
+      insertRrtype(captured, rrtype)
     }
     return { args: captured }
   }
 }
+
+/**
+ * @param {unknown[]} captured
+ * @param {string} rrtype
+ */
+function insertRrtype (captured, rrtype) {
+  if (captured.length === 0) {
+    captured.push(rrtype)
+    return
+  }
+
+  captured.push(rrtype)
+  for (let index = captured.length - 1; index > 1; index--) {
+    captured[index] = captured[index - 1]
+  }
+  captured[1] = rrtype
+}

packages/datadog-plugin-dns/test/index.spec.js

@@ -163,6 +163,71 @@ describe('Plugin', () => {
         dns.resolveAny('localhost', err => err && done(err))
       })
 
+      it('should preserve the shorthand rrtype when callback options are passed', () => {
+        const tracePromise = agent.assertSomeTraces(traces => {
+          assertObjectContains(traces[0][0], {
+            name: 'dns.resolve',
+            service: 'test',
+            resource: 'AAAA fakedomain.faketld',
+          })
+          assertObjectContains(traces[0][0].meta, {
+            component: 'dns',
+            'span.kind': 'client',
+            'dns.hostname': 'fakedomain.faketld',
+            'dns.rrtype': 'AAAA',
+          })
+        })
+
+        return Promise.all([
+          tracePromise,
+          assert.rejects(promisify(dns.resolve6)('fakedomain.faketld', { ttl: true })),
+        ])
+      })
+
+      it('should instrument resolveCaa with options', () => {
+        const tracePromise = agent.assertSomeTraces(traces => {
+          assertObjectContains(traces[0][0], {
+            name: 'dns.resolve',
+            service: 'test',
+            resource: 'CAA fakedomain.faketld',
+          })
+          assertObjectContains(traces[0][0].meta, {
+            component: 'dns',
+            'span.kind': 'client',
+            'dns.hostname': 'fakedomain.faketld',
+            'dns.rrtype': 'CAA',
+          })
+        })
+
+        return Promise.all([
+          tracePromise,
+          assert.rejects(promisify(dns.resolveCaa)('fakedomain.faketld', { ttl: true })),
+        ])
+      })
+
+      it('should preserve the shorthand rrtype on callback Resolver instances when options are passed', () => {
+        const resolver = new dns.Resolver()
+
+        const tracePromise = agent.assertSomeTraces(traces => {
+          assertObjectContains(traces[0][0], {
+            name: 'dns.resolve',
+            service: 'test',
+            resource: 'AAAA fakedomain.faketld',
+          })
+          assertObjectContains(traces[0][0].meta, {
+            component: 'dns',
+            'span.kind': 'client',
+            'dns.hostname': 'fakedomain.faketld',
+            'dns.rrtype': 'AAAA',
+          })
+        })
+
+        return Promise.all([
+          tracePromise,
+          assert.rejects(promisify(resolver.resolve6).call(resolver, 'fakedomain.faketld', { ttl: true })),
+        ])
+      })
+
       it('should instrument reverse', done => {
         agent
           .assertSomeTraces(traces => {
@@ -377,6 +442,75 @@ describe('Plugin', () => {
           ])
         })
 
+        it('should preserve the shorthand rrtype when promise options are passed', () => {
+          const tracePromise = agent.assertSomeTraces(traces => {
+            assertObjectContains(traces[0][0], {
+              name: 'dns.resolve',
+              service: 'test',
+              resource: 'AAAA fakedomain.faketld',
+            })
+            assertObjectContains(traces[0][0].meta, {
+              component: 'dns',
+              'span.kind': 'client',
+              'dns.hostname': 'fakedomain.faketld',
+              'dns.rrtype': 'AAAA',
+            })
+          })
+
+          return Promise.all([
+            tracePromise,
+            assert.rejects(dns.promises.resolve6('fakedomain.faketld', { ttl: true })),
+          ])
+        })
+
+        it('should instrument resolveTlsa with options when supported', function () {
+          if (typeof dns.promises.resolveTlsa !== 'function') {
+            this.skip()
+          }
+
+          const tracePromise = agent.assertSomeTraces(traces => {
+            assertObjectContains(traces[0][0], {
+              name: 'dns.resolve',
+              service: 'test',
+              resource: 'TLSA fakedomain.faketld',
+            })
+            assertObjectContains(traces[0][0].meta, {
+              component: 'dns',
+              'span.kind': 'client',
+              'dns.hostname': 'fakedomain.faketld',
+              'dns.rrtype': 'TLSA',
+            })
+          })
+
+          return Promise.all([
+            tracePromise,
+            assert.rejects(dns.promises.resolveTlsa('fakedomain.faketld', { ttl: true })),
+          ])
+        })
+
+        it('should preserve the shorthand rrtype on promise Resolver instances when options are passed', () => {
+          const resolver = new dns.promises.Resolver()
+
+          const tracePromise = agent.assertSomeTraces(traces => {
+            assertObjectContains(traces[0][0], {
+              name: 'dns.resolve',
+              service: 'test',
+              resource: 'AAAA fakedomain.faketld',
+            })
+            assertObjectContains(traces[0][0].meta, {
+              component: 'dns',
+              'span.kind': 'client',
+              'dns.hostname': 'fakedomain.faketld',
+              'dns.rrtype': 'AAAA',
+            })
+          })
+
+          return Promise.all([
+            tracePromise,
+            assert.rejects(resolver.resolve6('fakedomain.faketld', { ttl: true })),
+          ])
+        })
+
         it('should instrument reverse', () => {
           const tracePromise = agent.assertSomeTraces(traces => {
             assertObjectContains(traces[0][0], {
@@ -407,9 +541,8 @@ describe('Plugin', () => {
         })
 
         it('should rethrow synchronous errors from the underlying call', () => {
-          // dns.promises.lookup validates `hostname` synchronously and throws ERR_INVALID_ARG_TYPE
-          // rather than returning a rejected promise; the wrapper must propagate that.
           assert.throws(() => dns.promises.lookup({}), { code: 'ERR_INVALID_ARG_TYPE' })
+          assert.throws(() => dns.promises.resolve6(), { code: 'ERR_INVALID_ARG_TYPE' })
         })
 
         it('should instrument Resolver instances', () => {