feat(server-utils): Port Bedrock aws-sdk extension and add integration tests

dev-packages/node-integration-tests/suites/aws-serverless/bedrock/instrument.mjs

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/aws-serverless';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});

dev-packages/node-integration-tests/suites/aws-serverless/bedrock/scenario.mjs

@@ -0,0 +1,84 @@
+import * as Sentry from '@sentry/aws-serverless';
+import { BedrockRuntimeClient, ConverseCommand, InvokeModelCommand } from '@aws-sdk/client-bedrock-runtime';
+// Force the HTTP/1 handler so `nock` can intercept the request instead of hitting real AWS.
+import { NodeHttpHandler } from '@smithy/node-http-handler';
+import nock from 'nock';
+
+nock.disableNetConnect();
+
+const region = 'us-east-1';
+const credentials = { accessKeyId: 'aws-test-key', secretAccessKey: 'aws-test-secret' };
+const host = `https://bedrock-runtime.${region}.amazonaws.com`;
+
+async function converse() {
+  const client = new BedrockRuntimeClient({
+    region,
+    credentials,
+    maxAttempts: 1,
+    requestHandler: new NodeHttpHandler(),
+  });
+
+  nock(host)
+    .post(/\/model\/.*\/converse$/)
+    .reply(
+      200,
+      JSON.stringify({
+        output: { message: { role: 'assistant', content: [{ text: 'Hello from Bedrock' }] } },
+        stopReason: 'end_turn',
+        usage: { inputTokens: 12, outputTokens: 8, totalTokens: 20 },
+      }),
+      { 'content-type': 'application/json' },
+    );
+
+  await client.send(
+    new ConverseCommand({
+      modelId: 'anthropic.claude-3-5-sonnet-20240620-v1:0',
+      messages: [{ role: 'user', content: [{ text: 'Hello' }] }],
+      inferenceConfig: { maxTokens: 100, temperature: 0.5, topP: 0.9 },
+    }),
+  );
+}
+
+async function invokeModel() {
+  const client = new BedrockRuntimeClient({
+    region,
+    credentials,
+    maxAttempts: 1,
+    requestHandler: new NodeHttpHandler(),
+  });
+
+  nock(host)
+    .post(/\/model\/.*\/invoke$/)
+    .reply(
+      200,
+      JSON.stringify({
+        content: [{ type: 'text', text: 'Hello from Bedrock' }],
+        stop_reason: 'end_turn',
+        usage: { input_tokens: 15, output_tokens: 9 },
+      }),
+      { 'content-type': 'application/json' },
+    );
+
+  await client.send(
+    new InvokeModelCommand({
+      modelId: 'anthropic.claude-3-5-sonnet-20240620-v1:0',
+      contentType: 'application/json',
+      body: JSON.stringify({
+        anthropic_version: 'bedrock-2023-05-31',
+        max_tokens: 100,
+        temperature: 0.5,
+        top_p: 0.9,
+        messages: [{ role: 'user', content: 'Hello' }],
+      }),
+    }),
+  );
+}
+
+async function run() {
+  await Sentry.startSpan({ name: 'Test Transaction' }, async () => {
+    await converse();
+    await invokeModel();
+  });
+}
+
+run();

dev-packages/node-integration-tests/suites/aws-serverless/bedrock/test.ts

@@ -0,0 +1,75 @@
+import type { TransactionEvent } from '@sentry/core';
+import { afterAll, describe, expect } from 'vitest';
+import { isOrchestrionEnabled } from '../../../utils';
+import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
+
+// The suite runs twice on CI: once with the OTel `Aws` integration (default) and once with the
+// orchestrion diagnostics-channel integration auto-injected (`INJECT_ORCHESTRION`). Both emit the
+// same gen_ai spans; only the origin differs.
+const ORIGIN = isOrchestrionEnabled() ? 'auto.aws.orchestrion.aws_sdk' : 'auto.otel.aws';
+
+const MODEL_ID = 'anthropic.claude-3-5-sonnet-20240620-v1:0';
+
+function assertBedrockSpans(transaction: TransactionEvent): void {
+  const spans = transaction.spans ?? [];
+
+  expect(transaction.transaction).toBe('Test Transaction');
+
+  // Converse (non-streaming)
+  expect(spans, 'expected a Bedrock Converse span').toContainEqual(
+    expect.objectContaining({
+      description: `chat ${MODEL_ID}`,
+      origin: ORIGIN,
+      status: 'ok',
+      data: expect.objectContaining({
+        'sentry.origin': ORIGIN,
+        'gen_ai.system': 'aws.bedrock',
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.request.model': MODEL_ID,
+        'gen_ai.request.max_tokens': 100,
+        'gen_ai.request.temperature': 0.5,
+        'gen_ai.request.top_p': 0.9,
+        'gen_ai.usage.input_tokens': 12,
+        'gen_ai.usage.output_tokens': 8,
+        'gen_ai.response.finish_reasons': ['end_turn'],
+      }),
+    }),
+  );
+
+  // InvokeModel (non-streaming, anthropic.claude request/response body)
+  expect(spans, 'expected a Bedrock InvokeModel span').toContainEqual(
+    expect.objectContaining({
+      origin: ORIGIN,
+      status: 'ok',
+      data: expect.objectContaining({
+        'sentry.origin': ORIGIN,
+        'gen_ai.system': 'aws.bedrock',
+        'gen_ai.request.model': MODEL_ID,
+        'gen_ai.request.max_tokens': 100,
+        'gen_ai.request.temperature': 0.5,
+        'gen_ai.request.top_p': 0.9,
+        'gen_ai.usage.input_tokens': 15,
+        'gen_ai.usage.output_tokens': 9,
+        'gen_ai.response.finish_reasons': ['end_turn'],
+      }),
+    }),
+  );
+}
+
+describe('awsIntegration - Bedrock', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  createEsmAndCjsTests(
+    __dirname,
+    'scenario.mjs',
+    'instrument.mjs',
+    (createTestRunner, test) => {
+      test('auto-instruments Bedrock Converse and InvokeModel', { timeout: 90_000 }, async () => {
+        await createTestRunner().ignore('event').expect({ transaction: assertBedrockSpans }).start().completed();
+      });
+    },
+    { additionalDependencies: { '@aws-sdk/client-bedrock-runtime': '^3.1046.0' } },
+  );
+});

packages/server-utils/src/integrations/tracing-channel/aws-sdk/constants.ts

@@ -60,3 +60,8 @@ export const ATTR_FAAS_EXECUTION = 'faas.execution';
 export const ATTR_MESSAGING_DESTINATION = 'messaging.destination';
 export const ATTR_MESSAGING_DESTINATION_KIND = 'messaging.destination_kind';
 export const MESSAGING_DESTINATION_KIND_VALUE_TOPIC = 'topic';
+
+// Bedrock (gen_ai)
+export const ATTR_GEN_AI_REQUEST_STOP_SEQUENCES = 'gen_ai.request.stop_sequences';
+export const GEN_AI_OPERATION_NAME_VALUE_CHAT = 'chat';
+export const GEN_AI_SYSTEM_VALUE_AWS_BEDROCK = 'aws.bedrock';

packages/server-utils/src/integrations/tracing-channel/aws-sdk/services/ServicesExtensions.ts

@@ -1,5 +1,6 @@
 import type { Span } from '@sentry/core';
 import type { NormalizedRequest, NormalizedResponse, RequestMetadata } from '../types';
+import { BedrockRuntimeServiceExtension } from './bedrock-runtime';
 import { DynamodbServiceExtension } from './dynamodb';
 import { KinesisServiceExtension } from './kinesis';
 import { LambdaServiceExtension } from './lambda';
@@ -25,6 +26,7 @@ export class ServicesExtensions implements ServiceExtension {
     this._services.set('Lambda', new LambdaServiceExtension());
     this._services.set('S3', new S3ServiceExtension());
     this._services.set('Kinesis', new KinesisServiceExtension());
+    this._services.set('BedrockRuntime', new BedrockRuntimeServiceExtension());
   }
 
   public requestPreSpanHook(request: NormalizedRequest): RequestMetadata {