fix: Resolve merge conflicts with develop

- Keep both Spotlight proxy functions and new waitForMetric function
- Export all functions from index.ts

Author: BYK

CHANGELOG.md

@@ -4,7 +4,7 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
-Work in this release was contributed by @xgedev, @Mohataseem89 and @sebws. Thank you for your contributions!
+Work in this release was contributed by @xgedev, @Mohataseem89, @sebws, and @G-Rath. Thank you for your contributions!
 
 - ref(nextjs): Drop `resolve` dependency from the Next.js SDK ([#18618](https://github.com/getsentry/sentry-javascript/pull/18618))
 

dev-packages/e2e-tests/test-applications/nextjs-16/app/metrics/page.tsx

@@ -0,0 +1,34 @@
+'use client';
+
+import * as Sentry from '@sentry/nextjs';
+
+export default function Page() {
+  const handleClick = async () => {
+    Sentry.metrics.count('test.page.count', 1, {
+      attributes: {
+        page: '/metrics',
+        'random.attribute': 'Apples',
+      },
+    });
+    Sentry.metrics.distribution('test.page.distribution', 100, {
+      attributes: {
+        page: '/metrics',
+        'random.attribute': 'Manzanas',
+      },
+    });
+    Sentry.metrics.gauge('test.page.gauge', 200, {
+      attributes: {
+        page: '/metrics',
+        'random.attribute': 'Mele',
+      },
+    });
+    await fetch('/metrics/route-handler');
+  };
+
+  return (
+    <div>
+      <h1>Metrics page</h1>
+      <button onClick={handleClick}>Emit</button>
+    </div>
+  );
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/metrics/route-handler/route.ts

@@ -0,0 +1,23 @@
+import * as Sentry from '@sentry/nextjs';
+
+export const GET = async () => {
+  Sentry.metrics.count('test.route.handler.count', 1, {
+    attributes: {
+      endpoint: '/metrics/route-handler',
+      'random.attribute': 'Potatoes',
+    },
+  });
+  Sentry.metrics.distribution('test.route.handler.distribution', 100, {
+    attributes: {
+      endpoint: '/metrics/route-handler',
+      'random.attribute': 'Patatas',
+    },
+  });
+  Sentry.metrics.gauge('test.route.handler.gauge', 200, {
+    attributes: {
+      endpoint: '/metrics/route-handler',
+      'random.attribute': 'Patate',
+    },
+  });
+  return Response.json({ message: 'Bueno' });
+};

dev-packages/e2e-tests/test-applications/nextjs-16/tests/metrics.test.ts

@@ -0,0 +1,133 @@
+import { expect, test } from '@playwright/test';
+import { waitForMetric } from '@sentry-internal/test-utils';
+
+test('Should emit metrics from server and client', async ({ request, page }) => {
+  const clientCountPromise = waitForMetric('nextjs-16', async metric => {
+    return metric.name === 'test.page.count';
+  });
+
+  const clientDistributionPromise = waitForMetric('nextjs-16', async metric => {
+    return metric.name === 'test.page.distribution';
+  });
+
+  const clientGaugePromise = waitForMetric('nextjs-16', async metric => {
+    return metric.name === 'test.page.gauge';
+  });
+
+  const serverCountPromise = waitForMetric('nextjs-16', async metric => {
+    return metric.name === 'test.route.handler.count';
+  });
+
+  const serverDistributionPromise = waitForMetric('nextjs-16', async metric => {
+    return metric.name === 'test.route.handler.distribution';
+  });
+
+  const serverGaugePromise = waitForMetric('nextjs-16', async metric => {
+    return metric.name === 'test.route.handler.gauge';
+  });
+
+  await page.goto('/metrics');
+  await page.getByText('Emit').click();
+  const clientCount = await clientCountPromise;
+  const clientDistribution = await clientDistributionPromise;
+  const clientGauge = await clientGaugePromise;
+  const serverCount = await serverCountPromise;
+  const serverDistribution = await serverDistributionPromise;
+  const serverGauge = await serverGaugePromise;
+
+  expect(clientCount).toMatchObject({
+    timestamp: expect.any(Number),
+    trace_id: expect.any(String),
+    span_id: expect.any(String),
+    name: 'test.page.count',
+    type: 'counter',
+    value: 1,
+    attributes: {
+      page: { value: '/metrics', type: 'string' },
+      'random.attribute': { value: 'Apples', type: 'string' },
+      'sentry.environment': { value: 'qa', type: 'string' },
+      'sentry.sdk.name': { value: 'sentry.javascript.nextjs', type: 'string' },
+      'sentry.sdk.version': { value: expect.any(String), type: 'string' },
+    },
+  });
+
+  expect(clientDistribution).toMatchObject({
+    timestamp: expect.any(Number),
+    trace_id: expect.any(String),
+    span_id: expect.any(String),
+    name: 'test.page.distribution',
+    type: 'distribution',
+    value: 100,
+    attributes: {
+      page: { value: '/metrics', type: 'string' },
+      'random.attribute': { value: 'Manzanas', type: 'string' },
+      'sentry.environment': { value: 'qa', type: 'string' },
+      'sentry.sdk.name': { value: 'sentry.javascript.nextjs', type: 'string' },
+      'sentry.sdk.version': { value: expect.any(String), type: 'string' },
+    },
+  });
+
+  expect(clientGauge).toMatchObject({
+    timestamp: expect.any(Number),
+    trace_id: expect.any(String),
+    span_id: expect.any(String),
+    name: 'test.page.gauge',
+    type: 'gauge',
+    value: 200,
+    attributes: {
+      page: { value: '/metrics', type: 'string' },
+      'random.attribute': { value: 'Mele', type: 'string' },
+      'sentry.environment': { value: 'qa', type: 'string' },
+      'sentry.sdk.name': { value: 'sentry.javascript.nextjs', type: 'string' },
+      'sentry.sdk.version': { value: expect.any(String), type: 'string' },
+    },
+  });
+
+  expect(serverCount).toMatchObject({
+    timestamp: expect.any(Number),
+    trace_id: expect.any(String),
+    name: 'test.route.handler.count',
+    type: 'counter',
+    value: 1,
+    attributes: {
+      'server.address': { value: expect.any(String), type: 'string' },
+      'random.attribute': { value: 'Potatoes', type: 'string' },
+      endpoint: { value: '/metrics/route-handler', type: 'string' },
+      'sentry.environment': { value: 'qa', type: 'string' },
+      'sentry.sdk.name': { value: 'sentry.javascript.nextjs', type: 'string' },
+      'sentry.sdk.version': { value: expect.any(String), type: 'string' },
+    },
+  });
+
+  expect(serverDistribution).toMatchObject({
+    timestamp: expect.any(Number),
+    trace_id: expect.any(String),
+    name: 'test.route.handler.distribution',
+    type: 'distribution',
+    value: 100,
+    attributes: {
+      'server.address': { value: expect.any(String), type: 'string' },
+      'random.attribute': { value: 'Patatas', type: 'string' },
+      endpoint: { value: '/metrics/route-handler', type: 'string' },
+      'sentry.environment': { value: 'qa', type: 'string' },
+      'sentry.sdk.name': { value: 'sentry.javascript.nextjs', type: 'string' },
+      'sentry.sdk.version': { value: expect.any(String), type: 'string' },
+    },
+  });
+
+  expect(serverGauge).toMatchObject({
+    timestamp: expect.any(Number),
+    trace_id: expect.any(String),
+    name: 'test.route.handler.gauge',
+    type: 'gauge',
+    value: 200,
+    attributes: {
+      'server.address': { value: expect.any(String), type: 'string' },
+      'random.attribute': { value: 'Patate', type: 'string' },
+      endpoint: { value: '/metrics/route-handler', type: 'string' },
+      'sentry.environment': { value: 'qa', type: 'string' },
+      'sentry.sdk.name': { value: 'sentry.javascript.nextjs', type: 'string' },
+      'sentry.sdk.version': { value: expect.any(String), type: 'string' },
+    },
+  });
+});

dev-packages/node-integration-tests/suites/tracing/vercelai/scenario-late-model-id.mjs

@@ -0,0 +1,36 @@
+import * as Sentry from '@sentry/node';
+import { generateText } from 'ai';
+
+// Custom mock model that doesn't set modelId initially (simulates late model ID setting)
+// This tests that the op is correctly set even when model ID is not available at span start.
+// The span name update (e.g., 'generate_text gpt-4') is skipped when model ID is missing.t
+class LateModelIdMock {
+  specificationVersion = 'v1';
+  provider = 'late-model-provider';
+  // modelId is intentionally undefined initially to simulate late setting
+  modelId = undefined;
+  defaultObjectGenerationMode = 'json';
+
+  async doGenerate() {
+    // Model ID is only "available" during generation, not at span start
+    this.modelId = 'late-mock-model-id';
+
+    return {
+      rawCall: { rawPrompt: null, rawSettings: {} },
+      finishReason: 'stop',
+      usage: { promptTokens: 5, completionTokens: 10 },
+      text: 'Response from late model!',
+    };
+  }
+}
+
+async function run() {
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    await generateText({
+      model: new LateModelIdMock(),
+      prompt: 'Test prompt for late model ID',
+    });
+  });
+}
+
+run();

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

@@ -699,4 +699,40 @@ describe('Vercel AI integration', () => {
       expect(errorEvent!.contexts!.trace!.span_id).toBe(transactionEvent!.contexts!.trace!.span_id);
     });
   });
+
+  createEsmAndCjsTests(__dirname, 'scenario-late-model-id.mjs', 'instrument.mjs', (createRunner, test) => {
+    test('sets op correctly even when model ID is not available at span start', async () => {
+      const expectedTransaction = {
+        transaction: 'main',
+        spans: expect.arrayContaining([
+          // The generateText span should have the correct op even though model ID was not available at span start
+          expect.objectContaining({
+            description: 'generateText',
+            op: 'gen_ai.invoke_agent',
+            origin: 'auto.vercelai.otel',
+            status: 'ok',
+            data: expect.objectContaining({
+              'sentry.op': 'gen_ai.invoke_agent',
+              'sentry.origin': 'auto.vercelai.otel',
+              'gen_ai.operation.name': 'ai.generateText',
+            }),
+          }),
+          // The doGenerate span - name stays as 'generateText.doGenerate' since model ID is missing
+          expect.objectContaining({
+            description: 'generateText.doGenerate',
+            op: 'gen_ai.generate_text',
+            origin: 'auto.vercelai.otel',
+            status: 'ok',
+            data: expect.objectContaining({
+              'sentry.op': 'gen_ai.generate_text',
+              'sentry.origin': 'auto.vercelai.otel',
+              'gen_ai.operation.name': 'ai.generateText.doGenerate',
+            }),
+          }),
+        ]),
+      };
+
+      await createRunner().expect({ transaction: expectedTransaction }).start().completed();
+    });
+  });
 });

dev-packages/node-integration-tests/suites/vercel/sigterm-flush/scenario.ts

@@ -0,0 +1,36 @@
+import type { BaseTransportOptions, Envelope, Transport, TransportMakeRequestResponse } from '@sentry/core';
+import * as Sentry from '@sentry/node';
+
+function bufferedLoggingTransport(_options: BaseTransportOptions): Transport {
+  const bufferedEnvelopes: Envelope[] = [];
+
+  return {
+    send(envelope: Envelope): Promise<TransportMakeRequestResponse> {
+      bufferedEnvelopes.push(envelope);
+      return Promise.resolve({ statusCode: 200 });
+    },
+    flush(_timeout?: number): PromiseLike<boolean> {
+      // Print envelopes once flushed to verify they were sent.
+      for (const envelope of bufferedEnvelopes.splice(0, bufferedEnvelopes.length)) {
+        // eslint-disable-next-line no-console
+        console.log(JSON.stringify(envelope));
+      }
+
+      return Promise.resolve(true);
+    },
+  };
+}
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  transport: bufferedLoggingTransport,
+});
+
+Sentry.captureMessage('SIGTERM flush message');
+
+// Signal that we're ready to receive SIGTERM.
+// eslint-disable-next-line no-console
+console.log('READY');
+
+// Keep the process alive so the integration test can send SIGTERM.
+setInterval(() => undefined, 1_000);

dev-packages/node-integration-tests/suites/vercel/sigterm-flush/test.ts

@@ -0,0 +1,39 @@
+import { afterAll, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('flushes buffered events when SIGTERM is received on Vercel', async () => {
+  const runner = createRunner(__dirname, 'scenario.ts')
+    .withEnv({ VERCEL: '1' })
+    .expect({
+      event: {
+        message: 'SIGTERM flush message',
+      },
+    })
+    .start();
+
+  // Wait for the scenario to signal it's ready (SIGTERM handler is registered).
+  const waitForReady = async (): Promise<void> => {
+    const maxWait = 10_000;
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+      if (runner.getLogs().some(line => line.includes('READY'))) {
+        return;
+      }
+      await new Promise<void>(resolve => setTimeout(resolve, 50));
+    }
+    throw new Error('Timed out waiting for scenario to be ready');
+  };
+
+  await waitForReady();
+
+  runner.sendSignal('SIGTERM');
+
+  await runner.completed();
+
+  // Check that the child didn't crash (it may be killed by the runner after completion).
+  expect(runner.getLogs().join('\n')).not.toMatch(/Error starting child process/i);
+});

dev-packages/node-integration-tests/utils/runner.ts

@@ -172,6 +172,7 @@ type StartResult = {
   childHasExited(): boolean;
   getLogs(): string[];
   getPort(): number | undefined;
+  sendSignal(signal: NodeJS.Signals): void;
   makeRequest<T>(
     method: 'get' | 'post' | 'put' | 'delete' | 'patch',
     path: string,
@@ -668,6 +669,9 @@ export function createRunner(...paths: string[]) {
         getPort(): number | undefined {
           return scenarioServerPort;
         },
+        sendSignal(signal: NodeJS.Signals): void {
+          child?.kill(signal);
+        },
         makeRequest: async function <T>(
           method: 'get' | 'post' | 'put' | 'delete' | 'patch',
           path: string,