test(node): Port Tedious integration tests to span streaming

dev-packages/node-integration-tests/suites/tracing/tedious/instrument.mjs

@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,

dev-packages/node-integration-tests/suites/tracing/tedious/test.ts

@@ -1,3 +1,15 @@
+import {
+  DB_NAMESPACE,
+  DB_QUERY_SUMMARY,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  DB_USER,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
 import { afterAll, expect } from 'vitest';
 import { conditionalTest } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
@@ -9,36 +21,36 @@ describeWithDockerCompose('tedious auto instrumentation', { workingDirectory: [_
     cleanupChildProcesses();
   });
 
-  const dbSpan = (overrides: Record<string, unknown>) =>
+  const dbSpan = (text: string, status = 'ok') =>
     expect.objectContaining({
-      op: 'db',
-      origin: ORIGIN,
-      data: expect.objectContaining({
-        'sentry.origin': ORIGIN,
-        'sentry.op': 'db',
-        'db.system.name': 'mssql',
-        'db.namespace': 'master',
-        'db.user': 'sa',
-        'server.address': '127.0.0.1',
-        'server.port': 1433,
+      status,
+      attributes: expect.objectContaining({
+        [DB_QUERY_TEXT]: { type: 'string', value: text },
+        [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+        [SENTRY_OP]: { type: 'string', value: DB },
+        [DB_SYSTEM_NAME]: { type: 'string', value: 'mssql' },
+        [DB_NAMESPACE]: { type: 'string', value: 'master' },
+        [DB_USER]: { type: 'string', value: 'sa' },
+        [SERVER_ADDRESS]: { type: 'string', value: '127.0.0.1' },
+        [SERVER_PORT]: { type: 'integer', value: 1433 },
       }),
-      ...overrides,
     });
 
-  const EXPECTED_TRANSACTION = {
-    transaction: 'Test Transaction',
-    spans: expect.arrayContaining([
-      dbSpan({ description: 'SELECT ? + ? AS solution', status: 'ok' }),
-      dbSpan({ description: 'SELECT ?; SELECT ?', status: 'ok' }),
-      dbSpan({ description: 'select !', status: 'internal_error' }),
-      dbSpan({ description: '[dbo].[test_proced]', status: 'ok' }),
-      dbSpan({ description: 'INSERT INTO [dbo].[test_prepared] VALUES (@val1, @val2)', status: 'ok' }),
+  const EXPECTED_SPANS = {
+    items: expect.arrayContaining([
+      dbSpan('SELECT ? + ? AS solution'),
+      dbSpan('SELECT ?; SELECT ?'),
+      dbSpan('select !', 'error'),
+      dbSpan('[dbo].[test_proced]'),
+      dbSpan('INSERT INTO [dbo].[test_prepared] VALUES (@val1, @val2)'),
       expect.objectContaining({
-        description: 'execBulkLoad test_bulk master',
-        op: 'db',
-        origin: ORIGIN,
+        name: 'execBulkLoad test_bulk',
         status: 'ok',
-        data: expect.objectContaining({ 'db.sql.table': 'test_bulk' }),
+        attributes: expect.objectContaining({
+          'db.sql.table': { type: 'string', value: 'test_bulk' },
+          [SENTRY_OP]: { type: 'string', value: DB },
+          [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+        }),
       }),
     ]),
   };
@@ -47,9 +59,9 @@ describeWithDockerCompose('tedious auto instrumentation', { workingDirectory: [_
     test('should auto-instrument `tedious` package', async () => {
       await createTestRunner()
         .expect({
-          transaction: transaction => {
-            expect(transaction.transaction).toBe(EXPECTED_TRANSACTION.transaction);
-            expect(transaction.spans).toEqual(EXPECTED_TRANSACTION.spans);
+          span: container => {
+            expect(container.items.find(span => span.is_segment)?.name).toBe('Test Transaction');
+            expect(container.items).toEqual(EXPECTED_SPANS.items);
 
             const CREATE_PROCEDURE =
               'CREATE OR ALTER PROCEDURE [dbo].[test_proced] @inputVal varchar(?), @outputCount int OUTPUT AS set @outputCount = LEN(@inputVal)';
@@ -65,26 +77,43 @@ describeWithDockerCompose('tedious auto instrumentation', { workingDirectory: [_
             const SELECT_STRING_LITERAL = 'SELECT c1, c2 FROM [dbo].[test_bulk] WHERE c2 = ?';
 
             expect(
-              (transaction.spans ?? [])
-                .filter(span => span.origin === ORIGIN)
-                .map(span => ({ name: span.description, text: span.data?.['db.query.text'] })),
+              container.items
+                .filter(span => span.attributes[SENTRY_ORIGIN]?.value === ORIGIN)
+                .map(span => ({
+                  name: span.name,
+                  summary: span.attributes[DB_QUERY_SUMMARY]?.value,
+                  text: span.attributes[DB_QUERY_TEXT]?.value,
+                })),
             ).toEqual([
-              { name: 'SELECT ? + ? AS solution', text: 'SELECT ? + ? AS solution' },
-              { name: 'SELECT ?; SELECT ?', text: 'SELECT ?; SELECT ?' },
-              { name: 'select !', text: 'select !' },
-              { name: CREATE_PROCEDURE, text: CREATE_PROCEDURE },
-              { name: '[dbo].[test_proced]', text: '[dbo].[test_proced]' },
-              { name: CREATE_PREPARED_TABLE, text: CREATE_PREPARED_TABLE },
-              { name: INSERT_PREPARED, text: INSERT_PREPARED },
-              { name: INSERT_PREPARED, text: INSERT_PREPARED },
-              { name: CREATE_BULK_TABLE, text: CREATE_BULK_TABLE },
-              { name: 'execBulkLoad test_bulk master', text: undefined },
-              { name: INSERT_BULK, text: INSERT_BULK },
-              { name: SELECT_PREPARED, text: SELECT_PREPARED },
-              { name: SELECT_JOIN, text: SELECT_JOIN },
-              { name: SELECT_INLINE_LITERAL, text: SELECT_INLINE_LITERAL },
-              { name: SELECT_PARAMETERIZED, text: SELECT_PARAMETERIZED },
-              { name: SELECT_STRING_LITERAL, text: SELECT_STRING_LITERAL },
+              { name: 'SELECT', summary: 'SELECT', text: 'SELECT ? + ? AS solution' },
+              { name: 'SELECT', summary: 'SELECT', text: 'SELECT ?; SELECT ?' },
+              { name: 'select', summary: 'select', text: 'select !' },
+              { name: 'CREATE', summary: 'CREATE', text: CREATE_PROCEDURE },
+              { name: 'callProcedure [dbo].[test_proced]', summary: undefined, text: '[dbo].[test_proced]' },
+              { name: 'if', summary: 'if', text: CREATE_PREPARED_TABLE },
+              { name: 'INSERT [dbo].[test_prepared]', summary: 'INSERT [dbo].[test_prepared]', text: INSERT_PREPARED },
+              { name: 'INSERT [dbo].[test_prepared]', summary: 'INSERT [dbo].[test_prepared]', text: INSERT_PREPARED },
+              { name: 'if', summary: 'if', text: CREATE_BULK_TABLE },
+              { name: 'insert', summary: 'insert', text: INSERT_BULK },
+              { name: 'execBulkLoad test_bulk', summary: undefined, text: undefined },
+              { name: 'SELECT [dbo].[test_prepared]', summary: 'SELECT [dbo].[test_prepared]', text: SELECT_PREPARED },
+              {
+                // TODO: (check if correct) Both sides of the join survive into the summary.
+                name: 'SELECT [dbo].[test_prepared] [dbo].[test_bulk]',
+                summary: 'SELECT [dbo].[test_prepared] [dbo].[test_bulk]',
+                text: SELECT_JOIN,
+              },
+              {
+                name: 'SELECT [dbo].[test_prepared]',
+                summary: 'SELECT [dbo].[test_prepared]',
+                text: SELECT_INLINE_LITERAL,
+              },
+              {
+                name: 'SELECT [dbo].[test_prepared]',
+                summary: 'SELECT [dbo].[test_prepared]',
+                text: SELECT_PARAMETERIZED,
+              },
+              { name: 'SELECT [dbo].[test_bulk]', summary: 'SELECT [dbo].[test_bulk]', text: SELECT_STRING_LITERAL },
             ]);
           },
         })
@@ -98,13 +127,13 @@ describeWithDockerCompose('tedious auto instrumentation', { workingDirectory: [_
     createEsmAndCjsTests(
       __dirname,
       'scenario.mjs',
-      'instrument-span-streaming.mjs',
+      'instrument.mjs',
       (createTestRunner, test) => {
         test('should auto-instrument `tedious` package', async () => {
           await createTestRunner()
             .expect({
               span: container => {
-                const dbSpans = container.items.filter(item => item.attributes['sentry.origin']?.value === ORIGIN);
+                const dbSpans = container.items.filter(item => item.attributes[SENTRY_ORIGIN]?.value === ORIGIN);
 
                 expect(dbSpans.map(span => span.name)).toEqual(
                   expect.arrayContaining([
@@ -116,13 +145,12 @@ describeWithDockerCompose('tedious auto instrumentation', { workingDirectory: [_
                   ]),
                 );
                 expect(dbSpans.find(span => span.name === 'select')?.status).toBe('error');
-                expect(dbSpans[0]?.attributes).toMatchObject({
-                  'db.system.name': { value: 'mssql' },
-                  'db.namespace': { value: 'master' },
-                  'db.user': { value: 'sa' },
-                  'server.address': { value: '127.0.0.1' },
-                  'server.port': { value: 1433 },
-                });
+                const attributes = dbSpans[0]?.attributes;
+                expect(attributes?.[DB_SYSTEM_NAME]).toEqual({ type: 'string', value: 'mssql' });
+                expect(attributes?.[DB_NAMESPACE]).toEqual({ type: 'string', value: 'master' });
+                expect(attributes?.[DB_USER]).toEqual({ type: 'string', value: 'sa' });
+                expect(attributes?.[SERVER_ADDRESS]).toEqual({ type: 'string', value: '127.0.0.1' });
+                expect(attributes?.[SERVER_PORT]).toEqual({ type: 'integer', value: 1433 });
               },
             })
             .start()
@@ -132,87 +160,4 @@ describeWithDockerCompose('tedious auto instrumentation', { workingDirectory: [_
       { additionalDependencies: { tedious: '^20' } },
     );
   });
-
-  createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument-span-streaming.mjs', (createTestRunner, test) => {
-    test('should name spans after the query summary with span streaming', async () => {
-      await createTestRunner()
-        .expect({
-          span: container => {
-            const dbSpans = container.items.filter(item => item.attributes['sentry.origin']?.value === ORIGIN);
-
-            expect(
-              dbSpans.map(span => ({
-                name: span.name,
-                summary: span.attributes['db.query.summary']?.value,
-                text: span.attributes['db.query.text']?.value,
-              })),
-            ).toEqual([
-              { name: 'SELECT', summary: 'SELECT', text: 'SELECT ? + ? AS solution' },
-              { name: 'SELECT', summary: 'SELECT', text: 'SELECT ?; SELECT ?' },
-              { name: 'select', summary: 'select', text: 'select !' },
-              {
-                name: 'CREATE',
-                summary: 'CREATE',
-                text: 'CREATE OR ALTER PROCEDURE [dbo].[test_proced] @inputVal varchar(?), @outputCount int OUTPUT AS set @outputCount = LEN(@inputVal)',
-              },
-              { name: 'callProcedure [dbo].[test_proced]', summary: undefined, text: '[dbo].[test_proced]' },
-              {
-                name: 'if',
-                summary: 'if',
-                text: 'if object_id(?) is null CREATE TABLE [dbo].[test_prepared] (c1 int, c2 int)',
-              },
-              {
-                name: 'INSERT [dbo].[test_prepared]',
-                summary: 'INSERT [dbo].[test_prepared]',
-                text: 'INSERT INTO [dbo].[test_prepared] VALUES (@val1, @val2)',
-              },
-              {
-                name: 'INSERT [dbo].[test_prepared]',
-                summary: 'INSERT [dbo].[test_prepared]',
-                text: 'INSERT INTO [dbo].[test_prepared] VALUES (@val1, @val2)',
-              },
-              {
-                name: 'if',
-                summary: 'if',
-                text: 'if object_id(?) is null CREATE TABLE [dbo].[test_bulk] (c1 int, c2 varchar(?))',
-              },
-              {
-                name: 'insert',
-                summary: 'insert',
-                text: 'insert bulk test_bulk([c1] int, [c2] nvarchar(?)) WITH (KEEP_NULLS)',
-              },
-              { name: 'execBulkLoad test_bulk', summary: undefined, text: undefined },
-              {
-                name: 'SELECT [dbo].[test_prepared]',
-                summary: 'SELECT [dbo].[test_prepared]',
-                text: 'SELECT c1, c2 FROM [dbo].[test_prepared]',
-              },
-              {
-                // TODO: (check if correct) Both sides of the join survive into the summary.
-                name: 'SELECT [dbo].[test_prepared] [dbo].[test_bulk]',
-                summary: 'SELECT [dbo].[test_prepared] [dbo].[test_bulk]',
-                text: 'SELECT p.c1 FROM [dbo].[test_prepared] p INNER JOIN [dbo].[test_bulk] b ON p.c1 = b.c1',
-              },
-              {
-                name: 'SELECT [dbo].[test_prepared]',
-                summary: 'SELECT [dbo].[test_prepared]',
-                text: 'SELECT c1, c2 FROM [dbo].[test_prepared] WHERE c1 = ?',
-              },
-              {
-                name: 'SELECT [dbo].[test_prepared]',
-                summary: 'SELECT [dbo].[test_prepared]',
-                text: 'SELECT c1, c2 FROM [dbo].[test_prepared] WHERE c1 = @c1',
-              },
-              {
-                name: 'SELECT [dbo].[test_bulk]',
-                summary: 'SELECT [dbo].[test_bulk]',
-                text: 'SELECT c1, c2 FROM [dbo].[test_bulk] WHERE c2 = ?',
-              },
-            ]);
-          },
-        })
-        .start()
-        .completed();
-    });
-  });
 });