test: add a few database tests to cover recent reports better

BridgeAR · BridgeAR · commit 6f8dd96cb341 · 2026-02-16T15:00:12.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -32,6 +32,7 @@ Temporary Items
 # Logs
 logs
 *.log
+node-*-junit.xml
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
diff --git a/packages/datadog-plugin-mongodb-core/test/core.spec.js b/packages/datadog-plugin-mongodb-core/test/core.spec.js
@@ -524,6 +524,58 @@ describe('Plugin', () => {
         })
       })
 
+      describe('with dbmPropagationMode full from tracer configuration', () => {
+        before(() => {
+          return agent.load('mongodb-core', {
+            dbmPropagationMode: 'full',
+          }, {
+            sampler: { sampleRate: 1 },
+          })
+        })
+
+        after(() => {
+          return agent.close({ ritmReset: false })
+        })
+
+        beforeEach(done => {
+          const Server = getServer()
+
+          server = new Server({
+            host: '127.0.0.1',
+            port: 27017,
+            reconnect: false,
+          })
+
+          server.on('connect', () => done())
+          server.on('error', done)
+
+          server.connect()
+
+          startSpy = sinon.spy(MongodbCorePlugin.prototype, 'start')
+        })
+
+        afterEach(() => {
+          startSpy?.restore()
+        })
+
+        it('DBM propagation should inject full mode comment with traceparent', done => {
+          agent
+            .assertFirstTraceSpan(span => {
+              const traceId = span.meta['_dd.p.tid'] + span.trace_id.toString(16).padStart(16, '0')
+              const spanId = span.span_id.toString(16).padStart(16, '0')
+
+              assert.strictEqual(startSpy.called, true)
+              const { comment } = startSpy.getCall(0).args[0].ops
+              assert.ok(comment.includes(`traceparent='00-${traceId}-${spanId}-01'`))
+              assert.strictEqual(span.meta['_dd.dbm_trace_injected'], 'true')
+            })
+            .then(done)
+            .catch(done)
+
+          server.insert(`test.${collection}`, [{ a: 1 }], () => {})
+        })
+      })
+
       describe('with dbmPropagationMode service', () => {
         before(() => {
           return agent.load('mongodb-core', { dbmPropagationMode: 'service' })
diff --git a/packages/datadog-plugin-mysql/test/index.spec.js b/packages/datadog-plugin-mysql/test/index.spec.js
@@ -427,6 +427,42 @@ describe('Plugin', () => {
           })
         })
       })
+
+      describe('with DBM propagation enabled with service using tracer configurations', () => {
+        let connection
+
+        before(async () => {
+          await agent.load('mysql', { service: 'serviced', dbmPropagationMode: 'service' })
+          mysql = proxyquire(`../../../versions/mysql@${version}`, {}).get()
+
+          connection = mysql.createConnection({
+            host: '127.0.0.1',
+            user: 'root',
+            database: 'db',
+          })
+          connection.connect()
+        })
+
+        after((done) => {
+          connection.end(() => {
+            agent.close({ ritmReset: false }).then(done)
+          })
+        })
+
+        it('should contain service mode comment in query text', done => {
+          connection.query('SELECT 1 + 1 AS solution', () => {
+            try {
+              assert.strictEqual(connection._protocol._queue[0].sql,
+                '/*dddb=\'db\',dddbs=\'serviced\',dde=\'tester\',ddh=\'127.0.0.1\',ddps=\'test\',' +
+                `ddpv='${ddpv}'*/ SELECT 1 + 1 AS solution`)
+            } catch (e) {
+              done(e)
+            }
+            done()
+          })
+        })
+      })
+
       describe('DBM propagation should handle special characters', () => {
         let connection
 
diff --git a/packages/datadog-plugin-pg/test/index.spec.js b/packages/datadog-plugin-pg/test/index.spec.js
@@ -864,6 +864,48 @@ describe('Plugin', () => {
           await queryPromise
         })
       })
+
+      describe('with DBM propagation enabled with append comment using tracer configuration', () => {
+        before(async () => {
+          await agent.load('pg', {
+            appendComment: true,
+            service: () => 'serviced',
+            dbmPropagationMode: 'service',
+          })
+          pg = require(`../../../versions/pg@${version}`).get()
+        })
+
+        after(() => {
+          return agent.close({ ritmReset: false })
+        })
+
+        beforeEach((done) => {
+          client = new pg.Client({
+            host: '127.0.0.1',
+            user: 'postgres',
+            password: 'postgres',
+            database: 'postgres',
+          })
+          client.connect(err => done(err))
+        })
+
+        afterEach((done) => {
+          client.end(done)
+        })
+
+        it('should append service mode comment in query text', async () => {
+          const queryQueueName = Object.hasOwn(client, '_queryQueue') ? '_queryQueue' : 'queryQueue'
+
+          const queryPromise = client.query('SELECT $1::text as message', ['Hello world!'])
+
+          assert.strictEqual(client[queryQueueName][0].text,
+            'SELECT $1::text as message /*dddb=\'postgres\',dddbs=\'serviced\',dde=\'tester\',' +
+              `ddh='127.0.0.1',ddps='test',ddpv='${ddpv}'*/`
+          )
+
+          await queryPromise
+        })
+      })
     })
   })
 })
diff --git a/packages/datadog-plugin-prisma/test/index.spec.js b/packages/datadog-plugin-prisma/test/index.spec.js
@@ -1,12 +1,14 @@
 'use strict'
 
 const assert = require('node:assert/strict')
-const { execSync } = require('node:child_process')
+const { execFileSync, execSync } = require('node:child_process')
 const fs = require('node:fs/promises')
 const path = require('node:path')
+
 const { after, before, beforeEach, describe, it } = require('mocha')
 const proxyquire = require('proxyquire')
 const semifies = require('semifies')
+
 const { assertObjectContains } = require('../../../integration-tests/helpers')
 const { storage } = require('../../datadog-core')
 const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../dd-trace/src/constants')
@@ -82,7 +84,7 @@ async function copySchemaToVersionDir (schemaPath, range) {
 }
 
 function createPrismaClient (prisma, config) {
-  // With the introduction of v7 prisma now enforces the use of adpaters
+  // With the introduction of v7 prisma now enforces the use of adapters
   if (config.v7) {
     const { PrismaPg } = require('@prisma/adapter-pg')
     const adapter = new PrismaPg({ connectionString: process.env[TEST_DATABASE_ENV_NAME] })
@@ -94,6 +96,21 @@ function createPrismaClient (prisma, config) {
   return new prisma.PrismaClient()
 }
 
+function createEngineDbQuerySpan (queryText) {
+  return [{
+    id: '1',
+    parentId: null,
+    name: 'prisma:engine:db_query',
+    startTime: [1745340876, 436861000],
+    endTime: [1745340876, 438601541],
+    kind: 'client',
+    attributes: {
+      'db.system': 'postgresql',
+      'db.query.text': queryText,
+    },
+  }]
+}
+
 describe('Plugin', () => {
   let prisma
   let prismaClient
@@ -488,24 +505,63 @@ describe('Plugin', () => {
             })
 
             const engineSpans = [
-              {
-                id: '1',
-                parentId: null,
-                name: 'prisma:engine:db_query',
-                startTime: [1745340876, 436861000],
-                endTime: [1745340876, 438601541],
-                kind: 'client',
-                attributes: {
-                  'db.system': 'postgresql',
-                  'db.query.text': 'SELECT 1',
-                },
-              },
+              ...createEngineDbQuerySpan('SELECT 1'),
             ]
             tracingHelper.dispatchEngineSpans(engineSpans)
             await Promise.all([
               tracingPromise,
             ])
           })
+
+          if (config.v7) {
+            it('should tag db_query spans with the active client adapter metadata in read-replica setups', async () => {
+              const initialDbUrl = process.env[TEST_DATABASE_ENV_NAME]
+              process.env[TEST_DATABASE_ENV_NAME] =
+                'postgres://postgres:postgres@primary.db.internal:5432/postgres'
+              const primaryClient = createPrismaClient(prisma, config)
+
+              process.env[TEST_DATABASE_ENV_NAME] =
+                'postgres://postgres:postgres@replica.db.internal:5433/postgres'
+              const replicaClient = createPrismaClient(prisma, config)
+
+              if (initialDbUrl === undefined) {
+                delete process.env[TEST_DATABASE_ENV_NAME]
+              } else {
+                process.env[TEST_DATABASE_ENV_NAME] = initialDbUrl
+              }
+
+              assert.ok(primaryClient._tracingHelper)
+              assert.ok(replicaClient._tracingHelper)
+
+              const replicaReadTrace = agent.assertSomeTraces(traces => {
+                const dbQuerySpan = traces[0].find(span => span.meta['prisma.name'] === 'db_query')
+                assertObjectContains(dbQuerySpan, {
+                  resource: 'SELECT 1',
+                  meta: {
+                    'out.host': 'replica.db.internal',
+                    'network.destination.port': '5433',
+                  },
+                })
+              })
+              replicaClient._tracingHelper.dispatchEngineSpans(createEngineDbQuerySpan('SELECT 1'))
+              await replicaReadTrace
+
+              const primaryWriteTrace = agent.assertSomeTraces(traces => {
+                const dbQuerySpan = traces[0].find(span => span.meta['prisma.name'] === 'db_query')
+                assertObjectContains(dbQuerySpan, {
+                  resource: 'INSERT INTO "User" ("name") VALUES ($1)',
+                  meta: {
+                    'out.host': 'primary.db.internal',
+                    'network.destination.port': '5432',
+                  },
+                })
+              })
+              primaryClient._tracingHelper.dispatchEngineSpans(createEngineDbQuerySpan(
+                'INSERT INTO "User" ("name") VALUES ($1)'
+              ))
+              await primaryWriteTrace
+            })
+          }
         })
 
         describe('with configuration', () => {
diff --git a/packages/datadog-plugin-prisma/test/integration-test/client.spec.js b/packages/datadog-plugin-prisma/test/integration-test/client.spec.js
@@ -341,4 +341,90 @@ describe('esm', () => {
       })
     })
   })
+
+  describe('prisma-generator v7 pg adapter with OTel TracerProvider registration', () => {
+    const isNodeSupported = semifies(semver.clean(process.version), '>=20.19.0')
+    if (!isNodeSupported) {
+      return
+    }
+
+    withVersions('prisma', '@prisma/client', '7.0.0', version => {
+      const config = {
+        serverFile: 'server-ts-v7-otel.mjs',
+        schema: `./packages/datadog-plugin-prisma/test/${SCHEMA_FIXTURES.tsEsmV7}`,
+        configFile: `./packages/datadog-plugin-prisma/test/${SCHEMA_FIXTURES.tsEsmV7Config}`,
+        env: {
+          PRISMA_CLIENT_OUTPUT: './generated/prisma',
+          DATABASE_URL: TEST_DATABASE_URL,
+        },
+      }
+      const paths = [
+        './packages/datadog-plugin-prisma/test/integration-test/*',
+        config.schema,
+        config.configFile,
+      ]
+      const deps = [`@prisma/client@${version}`]
+      for (const ext of externals['@prisma/client']) {
+        if (ext.node && !semifies(semver.clean(process.version), ext.node)) continue
+        if (ext.dep === '@prisma/client') {
+          deps.push(`${ext.name}@${version}`)
+        } else if (ext.dep || ext.node) {
+          deps.push(ext.name)
+        }
+      }
+
+      useSandbox(deps, false, paths)
+
+      beforeEach(async function () {
+        this.timeout(60000)
+        agent = await new FakeAgent().start()
+        const cwd = sandboxCwd()
+        const commands = [
+          './node_modules/.bin/prisma db push --accept-data-loss',
+          './node_modules/.bin/prisma generate',
+          './node_modules/.bin/tsc ./generated/**/*.ts' +
+            ' --outDir ./dist' +
+            ' --target ES2023' +
+            ' --module ESNext' +
+            ' --strict true' +
+            ' --moduleResolution node' +
+            ' --esModuleInterop true',
+        ]
+
+        execSync(commands.join(' && '), {
+          cwd,
+          stdio: 'inherit',
+          env: {
+            ...process.env,
+            ...config.env,
+          },
+        })
+      })
+
+      afterEach(async () => {
+        proc?.kill()
+        await agent?.stop()
+      })
+
+      it('uses active OTel span IDs in Prisma DBM traceparent comments', async function () {
+        this.timeout(60000)
+        let stdout = ''
+        await spawnPluginIntegrationTestProcAndExpectExit(
+          sandboxCwd(),
+          config.serverFile,
+          agent.port,
+          { DD_TRACE_FLUSH_INTERVAL: '2000', ...config.env },
+          undefined,
+          data => {
+            stdout += data.toString()
+          }
+        )
+
+        const marker = stdout.match(/TRACEPARENT_OK:(00-[a-f0-9]{32}-[a-f0-9]{16}-01)/)
+        assert.ok(marker, `Expected TRACEPARENT_OK output marker, got: ${stdout}`)
+        assert.notStrictEqual(marker[1], '00-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-bbbbbbbbbbbbbbbb-01')
+        assert.notStrictEqual(marker[1], '00-00000000000000000000000000000000-0000000000000000-01')
+      })
+    })
+  })
 })
diff --git a/packages/datadog-plugin-prisma/test/integration-test/server-ts-v7-otel.mjs b/packages/datadog-plugin-prisma/test/integration-test/server-ts-v7-otel.mjs
