feat(core): Support OpenAI embeddings API

dev-packages/node-integration-tests/suites/tracing/openai/scenario-embeddings.mjs

@@ -0,0 +1,67 @@
+import { instrumentOpenAiClient } from '@sentry/core';
+import * as Sentry from '@sentry/node';
+
+class MockOpenAI {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+
+    this.embeddings = {
+      create: async params => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+
+        if (params.model === 'error-model') {
+          const error = new Error('Model not found');
+          error.status = 404;
+          error.headers = { 'x-request-id': 'mock-request-123' };
+          throw error;
+        }
+
+        return {
+          object: 'list',
+          data: [
+            {
+              object: 'embedding',
+              embedding: [0.1, 0.2, 0.3],
+              index: 0,
+            },
+          ],
+          model: params.model,
+          usage: {
+            prompt_tokens: 10,
+            total_tokens: 10,
+          },
+        };
+      },
+    };
+  }
+}
+
+async function run() {
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    const mockClient = new MockOpenAI({
+      apiKey: 'mock-api-key',
+    });
+
+    const client = instrumentOpenAiClient(mockClient);
+
+    // First test: embeddings API
+    await client.embeddings.create({
+      input: 'Embedding test!',
+      model: 'text-embedding-3-small',
+      dimensions: 1536,
+      encoding_format: 'float',
+    });
+
+    // Second test: embeddings API error model
+    try {
+      await client.embeddings.create({
+        input: 'Error embedding test!',
+        model: 'error-model',
+      });
+    } catch {
+      // Error is expected and handled
+    }
+  });
+}
+
+run();

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

@@ -6,7 +6,7 @@ describe('OpenAI integration', () => {
     cleanupChildProcesses();
   });
 
-  const EXPECTED_TRANSACTION_DEFAULT_PII_FALSE = {
+  const EXPECTED_TRANSACTION_DEFAULT_PII_FALSE_CHAT = {
     transaction: 'main',
     spans: expect.arrayContaining([
       // First span - basic chat completion without PII
@@ -147,7 +147,7 @@ describe('OpenAI integration', () => {
     ]),
   };
 
-  const EXPECTED_TRANSACTION_DEFAULT_PII_TRUE = {
+  const EXPECTED_TRANSACTION_DEFAULT_PII_TRUE_CHAT = {
     transaction: 'main',
     spans: expect.arrayContaining([
       // First span - basic chat completion with PII
@@ -321,27 +321,27 @@ describe('OpenAI integration', () => {
     ]),
   };
 
-  createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
+  createEsmAndCjsTests(__dirname, 'scenario-chat.mjs', 'instrument.mjs', (createRunner, test) => {
     test('creates openai related spans with sendDefaultPii: false', async () => {
       await createRunner()
         .ignore('event')
-        .expect({ transaction: EXPECTED_TRANSACTION_DEFAULT_PII_FALSE })
+        .expect({ transaction: EXPECTED_TRANSACTION_DEFAULT_PII_FALSE_CHAT })
         .start()
         .completed();
     });
   });
 
-  createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument-with-pii.mjs', (createRunner, test) => {
+  createEsmAndCjsTests(__dirname, 'scenario-chat.mjs', 'instrument-with-pii.mjs', (createRunner, test) => {
     test('creates openai related spans with sendDefaultPii: true', async () => {
       await createRunner()
         .ignore('event')
-        .expect({ transaction: EXPECTED_TRANSACTION_DEFAULT_PII_TRUE })
+        .expect({ transaction: EXPECTED_TRANSACTION_DEFAULT_PII_TRUE_CHAT })
         .start()
         .completed();
     });
   });
 
-  createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument-with-options.mjs', (createRunner, test) => {
+  createEsmAndCjsTests(__dirname, 'scenario-chat.mjs', 'instrument-with-options.mjs', (createRunner, test) => {
     test('creates openai related spans with custom options', async () => {
       await createRunner()
         .ignore('event')
@@ -351,6 +351,109 @@ describe('OpenAI integration', () => {
     });
   });
 
+  const EXPECTED_TRANSACTION_DEFAULT_PII_FALSE_EMBEDDINGS = {
+    transaction: 'main',
+    spans: expect.arrayContaining([
+      // First span - embeddings API
+      expect.objectContaining({
+        data: {
+          'gen_ai.operation.name': 'embeddings',
+          'sentry.op': 'gen_ai.embeddings',
+          'sentry.origin': 'auto.ai.openai',
+          'gen_ai.system': 'openai',
+          'gen_ai.request.model': 'text-embedding-3-small',
+          'gen_ai.request.encoding_format': 'float',
+          'gen_ai.request.dimensions': 1536,
+          'gen_ai.response.model': 'text-embedding-3-small',
+          'gen_ai.usage.input_tokens': 10,
+          'gen_ai.usage.total_tokens': 10,
+          'openai.response.model': 'text-embedding-3-small',
+          'openai.usage.prompt_tokens': 10,
+        },
+        description: 'embeddings text-embedding-3-small',
+        op: 'gen_ai.embeddings',
+        origin: 'auto.ai.openai',
+        status: 'ok',
+      }),
+      // Second span - embeddings API error model
+      expect.objectContaining({
+        data: {
+          'gen_ai.operation.name': 'embeddings',
+          'sentry.op': 'gen_ai.embeddings',
+          'sentry.origin': 'auto.ai.openai',
+          'gen_ai.system': 'openai',
+          'gen_ai.request.model': 'error-model',
+        },
+        description: 'embeddings error-model',
+        op: 'gen_ai.embeddings',
+        origin: 'auto.ai.openai',
+        status: 'internal_error',
+      }),
+    ]),
+  };
+
+  const EXPECTED_TRANSACTION_DEFAULT_PII_TRUE_EMBEDDINGS = {
+    transaction: 'main',
+    spans: expect.arrayContaining([
+      // First span - embeddings API with PII
+      expect.objectContaining({
+        data: {
+          'gen_ai.operation.name': 'embeddings',
+          'sentry.op': 'gen_ai.embeddings',
+          'sentry.origin': 'auto.ai.openai',
+          'gen_ai.system': 'openai',
+          'gen_ai.request.model': 'text-embedding-3-small',
+          'gen_ai.request.encoding_format': 'float',
+          'gen_ai.request.dimensions': 1536,
+          'gen_ai.request.messages': 'Embedding test!',
+          'gen_ai.response.model': 'text-embedding-3-small',
+          'gen_ai.usage.input_tokens': 10,
+          'gen_ai.usage.total_tokens': 10,
+          'openai.response.model': 'text-embedding-3-small',
+          'openai.usage.prompt_tokens': 10,
+        },
+        description: 'embeddings text-embedding-3-small',
+        op: 'gen_ai.embeddings',
+        origin: 'auto.ai.openai',
+        status: 'ok',
+      }),
+      // Second span - embeddings API error model with PII
+      expect.objectContaining({
+        data: {
+          'gen_ai.operation.name': 'embeddings',
+          'sentry.op': 'gen_ai.embeddings',
+          'sentry.origin': 'auto.ai.openai',
+          'gen_ai.system': 'openai',
+          'gen_ai.request.model': 'error-model',
+          'gen_ai.request.messages': 'Error embedding test!',
+        },
+        description: 'embeddings error-model',
+        op: 'gen_ai.embeddings',
+        origin: 'auto.ai.openai',
+        status: 'internal_error',
+      }),
+    ]),
+  };
+  createEsmAndCjsTests(__dirname, 'scenario-embeddings.mjs', 'instrument.mjs', (createRunner, test) => {
+    test('creates openai related spans with sendDefaultPii: false', async () => {
+      await createRunner()
+        .ignore('event')
+        .expect({ transaction: EXPECTED_TRANSACTION_DEFAULT_PII_FALSE_EMBEDDINGS })
+        .start()
+        .completed();
+    });
+  });
+
+  createEsmAndCjsTests(__dirname, 'scenario-embeddings.mjs', 'instrument-with-pii.mjs', (createRunner, test) => {
+    test('creates openai related spans with sendDefaultPii: true', async () => {
+      await createRunner()
+        .ignore('event')
+        .expect({ transaction: EXPECTED_TRANSACTION_DEFAULT_PII_TRUE_EMBEDDINGS })
+        .start()
+        .completed();
+    });
+  });
+
   createEsmAndCjsTests(__dirname, 'scenario-root-span.mjs', 'instrument.mjs', (createRunner, test) => {
     test('it works without a wrapping span', async () => {
       await createRunner()
@@ -400,7 +503,7 @@ describe('OpenAI integration', () => {
 
   createEsmAndCjsTests(
     __dirname,
-    'scenario-message-truncation-completions.mjs',
+    'truncation/scenario-message-truncation-completions.mjs',
     'instrument-with-pii.mjs',
     (createRunner, test) => {
       test('truncates messages when they exceed byte limit - keeps only last message and crops it', async () => {
@@ -436,7 +539,7 @@ describe('OpenAI integration', () => {
 
   createEsmAndCjsTests(
     __dirname,
-    'scenario-message-truncation-responses.mjs',
+    'truncation/scenario-message-truncation-responses.mjs',
     'instrument-with-pii.mjs',
     (createRunner, test) => {
       test('truncates string inputs when they exceed byte limit', async () => {
@@ -469,4 +572,30 @@ describe('OpenAI integration', () => {
       });
     },
   );
+
+  createEsmAndCjsTests(
+    __dirname,
+    'truncation/scenario-message-truncation-embeddings.mjs',
+    'instrument-with-pii.mjs',
+    (createRunner, test) => {
+      test('truncates messages when they exceed byte limit - keeps only last message and crops it', async () => {
+        await createRunner()
+          .ignore('event')
+          .expect({
+            transaction: {
+              transaction: 'main',
+              spans: expect.arrayContaining([
+                expect.objectContaining({
+                  data: expect.objectContaining({
+                    'gen_ai.operation.name': 'embeddings',
+                  }),
+                }),
+              ]),
+            },
+          })
+          .start()
+          .completed();
+      });
+    },
+  );
 });

dev-packages/node-integration-tests/suites/tracing/openai/truncation/scenario-message-truncation-embeddings.mjs

@@ -0,0 +1,66 @@
+import { instrumentOpenAiClient } from '@sentry/core';
+import * as Sentry from '@sentry/node';
+
+class MockOpenAI {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+
+    this.embeddings = {
+      create: async params => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+
+        return {
+          object: 'list',
+          data: [
+            {
+              object: 'embedding',
+              embedding: [0.1, 0.2, 0.3],
+              index: 0,
+            },
+          ],
+          model: params.model,
+          usage: {
+            prompt_tokens: 10,
+            total_tokens: 10,
+          },
+        };
+      },
+    };
+  }
+}
+
+async function run() {
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    const mockClient = new MockOpenAI({
+      apiKey: 'mock-api-key',
+    });
+
+    const client = instrumentOpenAiClient(mockClient);
+
+    // Create 1 large input that gets truncated to fit within the 20KB limit
+    const largeContent = 'A'.repeat(25000) + 'B'.repeat(25000); // ~50KB gets truncated to include only As
+
+    await client.embeddings.create({
+      input: largeContent,
+      model: 'text-embedding-3-small',
+      dimensions: 1536,
+      encoding_format: 'float',
+    });
+
+    // Create 3 large inputs where:
+    // - First 2 inputs are very large (will be dropped)
+    // - Last input is large but will be truncated to fit within the 20KB limit
+    const largeContent1 = 'A'.repeat(15000); // ~15KB
+    const largeContent2 = 'B'.repeat(15000); // ~15KB
+    const largeContent3 = 'C'.repeat(25000); // ~25KB (will be truncated)
+
+    await client.embeddings.create({
+      input: [largeContent1, largeContent2, largeContent3],
+      model: 'text-embedding-3-small',
+      dimensions: 1536,
+      encoding_format: 'float',
+    });
+  });
+}
+
+run();

packages/core/src/tracing/ai/gen-ai-attributes.ts

@@ -65,6 +65,16 @@ export const GEN_AI_REQUEST_TOP_K_ATTRIBUTE = 'gen_ai.request.top_k';
  */
 export const GEN_AI_REQUEST_STOP_SEQUENCES_ATTRIBUTE = 'gen_ai.request.stop_sequences';
 
+/**
+ * The encoding format for the model request
+ */
+export const GEN_AI_REQUEST_ENCODING_FORMAT_ATTRIBUTE = 'gen_ai.request.encoding_format';
+
+/**
+ * The dimensions for the model request
+ */
+export const GEN_AI_REQUEST_DIMENSIONS_ATTRIBUTE = 'gen_ai.request.dimensions';
+
 /**
  * Array of reasons why the model stopped generating tokens
  */
@@ -208,6 +218,7 @@ export const OPENAI_USAGE_PROMPT_TOKENS_ATTRIBUTE = 'openai.usage.prompt_tokens'
 export const OPENAI_OPERATIONS = {
   CHAT: 'chat',
   RESPONSES: 'responses',
+  EMBEDDINGS: 'embeddings',
 } as const;
 
 // =============================================================================

packages/core/src/tracing/openai/constants.ts

@@ -2,7 +2,7 @@ export const OPENAI_INTEGRATION_NAME = 'OpenAI';
 
 // https://platform.openai.com/docs/quickstart?api-mode=responses
 // https://platform.openai.com/docs/quickstart?api-mode=chat
-export const INSTRUMENTED_METHODS = ['responses.create', 'chat.completions.create'] as const;
+export const INSTRUMENTED_METHODS = ['responses.create', 'chat.completions.create', 'embeddings.create'] as const;
 export const RESPONSES_TOOL_CALL_EVENT_TYPES = [
   'response.output_item.added',
   'response.function_call_arguments.delta',