fix(nextjs): Apply environment from options if set

packages/nextjs/src/client/index.ts

@@ -65,7 +65,7 @@ export function init(options: BrowserOptions): Client | undefined {
  }
 
  const opts = {
- environment: getVercelEnv(true) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(true) || process.env.NODE_ENV,
  defaultIntegrations: getDefaultIntegrations(options),
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,

packages/nextjs/src/edge/index.ts

@@ -78,6 +78,7 @@ export function init(options: VercelEdgeOptions = {}): void {
 
  const opts: VercelEdgeOptions = {
  defaultIntegrations: customDefaultIntegrations,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,
  // Override runtime to 'cloudflare' when running on OpenNext/Cloudflare

packages/nextjs/src/server/index.ts

@@ -106,6 +106,7 @@ function getCloudflareRuntimeConfig(): { runtime: { name: string } } | undefined
 }
 
 /** Inits the Sentry NextJS SDK on node. */
+// eslint-disable-next-line complexity
 export function init(options: NodeOptions): NodeClient | undefined {
  prepareSafeIdGeneratorContext();
  if (isBuild()) {
@@ -146,7 +147,7 @@ export function init(options: NodeOptions): NodeClient | undefined {
  const cloudflareConfig = getCloudflareRuntimeConfig();
 
  const opts: NodeOptions = {
- environment: process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  defaultIntegrations: customDefaultIntegrations,
  ...options,

packages/nextjs/test/clientSdk.test.ts

@@ -166,4 +166,89 @@ describe('Client init()', () => {
  it('returns client from init', () => {
  expect(init({})).not.toBeUndefined();
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'custom-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'options-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/test/edgeSdk.test.ts

@@ -0,0 +1,140 @@
+import type { Integration } from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/core';
+import * as SentryVercelEdge from '@sentry/vercel-edge';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init } from '../src/edge';
+
+// normally this is set as part of the build process, so mock it here
+(GLOBAL_OBJ as typeof GLOBAL_OBJ & { _sentryRewriteFramesDistDir: string })._sentryRewriteFramesDistDir = '.next';
+
+const vercelEdgeInit = vi.spyOn(SentryVercelEdge, 'init');
+
+function findIntegrationByName(integrations: Integration[] = [], name: string): Integration | undefined {
+ return integrations.find(integration => integration.name === name);
+}
+
+describe('Edge init()', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('inits the Vercel Edge SDK', () => {
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(0);
+ init({});
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ expect(vercelEdgeInit).toHaveBeenLastCalledWith(
+ expect.objectContaining({
+ _metadata: {
+ sdk: {
+ name: 'sentry.javascript.nextjs',
+ version: expect.any(String),
+ packages: [
+ {
+ name: 'npm:@sentry/nextjs',
+ version: expect.any(String),
+ },
+ {
+ name: 'npm:@sentry/vercel-edge',
+ version: expect.any(String),
+ },
+ ],
+ },
+ },
+ // Integrations are tested separately, and we can't be more specific here without depending on the order in
+ // which integrations appear in the array, which we can't guarantee.
+ defaultIntegrations: expect.any(Array),
+ }),
+ );
+ });
+
+ describe('integrations', () => {
+ // Options passed by `@sentry/nextjs`'s `init` to `@sentry/vercel-edge`'s `init` after modifying them
+ type ModifiedInitOptions = { integrations?: Integration[]; defaultIntegrations: Integration[] };
+
+ it('adds default integrations', () => {
+ init({});
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const integrationNames = vercelEdgeInitOptions.defaultIntegrations.map(integration => integration.name);
+
+ expect(integrationNames).toContain('DistDirRewriteFrames');
+ });
+
+ it('supports passing unrelated integrations through options', () => {
+ init({ integrations: [SentryVercelEdge.dedupeIntegration()] });
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const dedupeIntegration = findIntegrationByName(vercelEdgeInitOptions.integrations, 'Dedupe');
+
+ expect(dedupeIntegration).toBeDefined();
+ });
+ });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses fallback environment when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ // In test environment, it should be undefined since we only set it explicitly when SENTRY_ENVIRONMENT is present
+ // Note: The underlying vercel-edge SDK may set its own default
+ expect(callArgs?.environment).toBeDefined();
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+ });
+});

packages/nextjs/test/serverSdk.test.ts

@@ -189,4 +189,97 @@ describe('Server init()', () => {
  );
  });
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ beforeEach(() => {
+ // Reset the global scope to allow re-initialization
+ SentryNode.getGlobalScope().clear();
+ SentryNode.getIsolationScope().clear();
+ SentryNode.getCurrentScope().clear();
+ SentryNode.getCurrentScope().setClient(undefined);
+ });
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/src/client/index.ts

@@ -65,7 +65,7 @@ export function init(options: BrowserOptions): Client | undefined {
  }
 
  const opts = {
- environment: getVercelEnv(true) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(true) || process.env.NODE_ENV,
  defaultIntegrations: getDefaultIntegrations(options),
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,

packages/nextjs/src/edge/index.ts

@@ -78,6 +78,7 @@ export function init(options: VercelEdgeOptions = {}): void {
 
  const opts: VercelEdgeOptions = {
  defaultIntegrations: customDefaultIntegrations,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,
  // Override runtime to 'cloudflare' when running on OpenNext/Cloudflare

packages/nextjs/src/server/index.ts

@@ -106,6 +106,7 @@ function getCloudflareRuntimeConfig(): { runtime: { name: string } } | undefined
 }
 
 /** Inits the Sentry NextJS SDK on node. */
+// eslint-disable-next-line complexity
 export function init(options: NodeOptions): NodeClient | undefined {
  prepareSafeIdGeneratorContext();
  if (isBuild()) {
@@ -146,7 +147,7 @@ export function init(options: NodeOptions): NodeClient | undefined {
  const cloudflareConfig = getCloudflareRuntimeConfig();
 
  const opts: NodeOptions = {
- environment: process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  defaultIntegrations: customDefaultIntegrations,
  ...options,

packages/nextjs/test/clientSdk.test.ts

@@ -166,4 +166,89 @@ describe('Client init()', () => {
  it('returns client from init', () => {
  expect(init({})).not.toBeUndefined();
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'custom-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'options-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/test/edgeSdk.test.ts

@@ -0,0 +1,140 @@
+import type { Integration } from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/core';
+import * as SentryVercelEdge from '@sentry/vercel-edge';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init } from '../src/edge';
+
+// normally this is set as part of the build process, so mock it here
+(GLOBAL_OBJ as typeof GLOBAL_OBJ & { _sentryRewriteFramesDistDir: string })._sentryRewriteFramesDistDir = '.next';
+
+const vercelEdgeInit = vi.spyOn(SentryVercelEdge, 'init');
+
+function findIntegrationByName(integrations: Integration[] = [], name: string): Integration | undefined {
+ return integrations.find(integration => integration.name === name);
+}
+
+describe('Edge init()', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('inits the Vercel Edge SDK', () => {
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(0);
+ init({});
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ expect(vercelEdgeInit).toHaveBeenLastCalledWith(
+ expect.objectContaining({
+ _metadata: {
+ sdk: {
+ name: 'sentry.javascript.nextjs',
+ version: expect.any(String),
+ packages: [
+ {
+ name: 'npm:@sentry/nextjs',
+ version: expect.any(String),
+ },
+ {
+ name: 'npm:@sentry/vercel-edge',
+ version: expect.any(String),
+ },
+ ],
+ },
+ },
+ // Integrations are tested separately, and we can't be more specific here without depending on the order in
+ // which integrations appear in the array, which we can't guarantee.
+ defaultIntegrations: expect.any(Array),
+ }),
+ );
+ });
+
+ describe('integrations', () => {
+ // Options passed by `@sentry/nextjs`'s `init` to `@sentry/vercel-edge`'s `init` after modifying them
+ type ModifiedInitOptions = { integrations?: Integration[]; defaultIntegrations: Integration[] };
+
+ it('adds default integrations', () => {
+ init({});
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const integrationNames = vercelEdgeInitOptions.defaultIntegrations.map(integration => integration.name);
+
+ expect(integrationNames).toContain('DistDirRewriteFrames');
+ });
+
+ it('supports passing unrelated integrations through options', () => {
+ init({ integrations: [SentryVercelEdge.dedupeIntegration()] });
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const dedupeIntegration = findIntegrationByName(vercelEdgeInitOptions.integrations, 'Dedupe');
+
+ expect(dedupeIntegration).toBeDefined();
+ });
+ });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses fallback environment when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ // In test environment, it should be undefined since we only set it explicitly when SENTRY_ENVIRONMENT is present
+ // Note: The underlying vercel-edge SDK may set its own default
+ expect(callArgs?.environment).toBeDefined();
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+ });
+});

packages/nextjs/test/serverSdk.test.ts

@@ -189,4 +189,97 @@ describe('Server init()', () => {
  );
  });
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ beforeEach(() => {
+ // Reset the global scope to allow re-initialization
+ SentryNode.getGlobalScope().clear();
+ SentryNode.getIsolationScope().clear();
+ SentryNode.getCurrentScope().clear();
+ SentryNode.getCurrentScope().setClient(undefined);
+ });
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/src/client/index.ts

@@ -65,7 +65,7 @@ export function init(options: BrowserOptions): Client | undefined {
  }
 
  const opts = {
- environment: getVercelEnv(true) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(true) || process.env.NODE_ENV,
  defaultIntegrations: getDefaultIntegrations(options),
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,

packages/nextjs/src/edge/index.ts

@@ -78,6 +78,7 @@ export function init(options: VercelEdgeOptions = {}): void {
 
  const opts: VercelEdgeOptions = {
  defaultIntegrations: customDefaultIntegrations,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,
  // Override runtime to 'cloudflare' when running on OpenNext/Cloudflare

packages/nextjs/src/server/index.ts

@@ -106,6 +106,7 @@ function getCloudflareRuntimeConfig(): { runtime: { name: string } } | undefined
 }
 
 /** Inits the Sentry NextJS SDK on node. */
+// eslint-disable-next-line complexity
 export function init(options: NodeOptions): NodeClient | undefined {
  prepareSafeIdGeneratorContext();
  if (isBuild()) {
@@ -146,7 +147,7 @@ export function init(options: NodeOptions): NodeClient | undefined {
  const cloudflareConfig = getCloudflareRuntimeConfig();
 
  const opts: NodeOptions = {
- environment: process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  defaultIntegrations: customDefaultIntegrations,
  ...options,

packages/nextjs/test/clientSdk.test.ts

@@ -166,4 +166,89 @@ describe('Client init()', () => {
  it('returns client from init', () => {
  expect(init({})).not.toBeUndefined();
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'custom-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'options-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/test/edgeSdk.test.ts

@@ -0,0 +1,140 @@
+import type { Integration } from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/core';
+import * as SentryVercelEdge from '@sentry/vercel-edge';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init } from '../src/edge';
+
+// normally this is set as part of the build process, so mock it here
+(GLOBAL_OBJ as typeof GLOBAL_OBJ & { _sentryRewriteFramesDistDir: string })._sentryRewriteFramesDistDir = '.next';
+
+const vercelEdgeInit = vi.spyOn(SentryVercelEdge, 'init');
+
+function findIntegrationByName(integrations: Integration[] = [], name: string): Integration | undefined {
+ return integrations.find(integration => integration.name === name);
+}
+
+describe('Edge init()', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('inits the Vercel Edge SDK', () => {
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(0);
+ init({});
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ expect(vercelEdgeInit).toHaveBeenLastCalledWith(
+ expect.objectContaining({
+ _metadata: {
+ sdk: {
+ name: 'sentry.javascript.nextjs',
+ version: expect.any(String),
+ packages: [
+ {
+ name: 'npm:@sentry/nextjs',
+ version: expect.any(String),
+ },
+ {
+ name: 'npm:@sentry/vercel-edge',
+ version: expect.any(String),
+ },
+ ],
+ },
+ },
+ // Integrations are tested separately, and we can't be more specific here without depending on the order in
+ // which integrations appear in the array, which we can't guarantee.
+ defaultIntegrations: expect.any(Array),
+ }),
+ );
+ });
+
+ describe('integrations', () => {
+ // Options passed by `@sentry/nextjs`'s `init` to `@sentry/vercel-edge`'s `init` after modifying them
+ type ModifiedInitOptions = { integrations?: Integration[]; defaultIntegrations: Integration[] };
+
+ it('adds default integrations', () => {
+ init({});
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const integrationNames = vercelEdgeInitOptions.defaultIntegrations.map(integration => integration.name);
+
+ expect(integrationNames).toContain('DistDirRewriteFrames');
+ });
+
+ it('supports passing unrelated integrations through options', () => {
+ init({ integrations: [SentryVercelEdge.dedupeIntegration()] });
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const dedupeIntegration = findIntegrationByName(vercelEdgeInitOptions.integrations, 'Dedupe');
+
+ expect(dedupeIntegration).toBeDefined();
+ });
+ });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses fallback environment when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ // In test environment, it should be undefined since we only set it explicitly when SENTRY_ENVIRONMENT is present
+ // Note: The underlying vercel-edge SDK may set its own default
+ expect(callArgs?.environment).toBeDefined();
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+ });
+});

packages/nextjs/test/serverSdk.test.ts

@@ -189,4 +189,97 @@ describe('Server init()', () => {
  );
  });
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ beforeEach(() => {
+ // Reset the global scope to allow re-initialization
+ SentryNode.getGlobalScope().clear();
+ SentryNode.getIsolationScope().clear();
+ SentryNode.getCurrentScope().clear();
+ SentryNode.getCurrentScope().setClient(undefined);
+ });
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/src/client/index.ts

@@ -65,7 +65,7 @@ export function init(options: BrowserOptions): Client | undefined {
  }
 
  const opts = {
- environment: getVercelEnv(true) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(true) || process.env.NODE_ENV,
  defaultIntegrations: getDefaultIntegrations(options),
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,

packages/nextjs/src/edge/index.ts

@@ -78,6 +78,7 @@ export function init(options: VercelEdgeOptions = {}): void {
 
  const opts: VercelEdgeOptions = {
  defaultIntegrations: customDefaultIntegrations,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,
  // Override runtime to 'cloudflare' when running on OpenNext/Cloudflare

packages/nextjs/src/server/index.ts

@@ -106,6 +106,7 @@ function getCloudflareRuntimeConfig(): { runtime: { name: string } } | undefined
 }
 
 /** Inits the Sentry NextJS SDK on node. */
+// eslint-disable-next-line complexity
 export function init(options: NodeOptions): NodeClient | undefined {
  prepareSafeIdGeneratorContext();
  if (isBuild()) {
@@ -146,7 +147,7 @@ export function init(options: NodeOptions): NodeClient | undefined {
  const cloudflareConfig = getCloudflareRuntimeConfig();
 
  const opts: NodeOptions = {
- environment: process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  defaultIntegrations: customDefaultIntegrations,
  ...options,

packages/nextjs/test/clientSdk.test.ts

@@ -166,4 +166,89 @@ describe('Client init()', () => {
  it('returns client from init', () => {
  expect(init({})).not.toBeUndefined();
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'custom-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'options-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/test/edgeSdk.test.ts

@@ -0,0 +1,140 @@
+import type { Integration } from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/core';
+import * as SentryVercelEdge from '@sentry/vercel-edge';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init } from '../src/edge';
+
+// normally this is set as part of the build process, so mock it here
+(GLOBAL_OBJ as typeof GLOBAL_OBJ & { _sentryRewriteFramesDistDir: string })._sentryRewriteFramesDistDir = '.next';
+
+const vercelEdgeInit = vi.spyOn(SentryVercelEdge, 'init');
+
+function findIntegrationByName(integrations: Integration[] = [], name: string): Integration | undefined {
+ return integrations.find(integration => integration.name === name);
+}
+
+describe('Edge init()', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('inits the Vercel Edge SDK', () => {
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(0);
+ init({});
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ expect(vercelEdgeInit).toHaveBeenLastCalledWith(
+ expect.objectContaining({
+ _metadata: {
+ sdk: {
+ name: 'sentry.javascript.nextjs',
+ version: expect.any(String),
+ packages: [
+ {
+ name: 'npm:@sentry/nextjs',
+ version: expect.any(String),
+ },
+ {
+ name: 'npm:@sentry/vercel-edge',
+ version: expect.any(String),
+ },
+ ],
+ },
+ },
+ // Integrations are tested separately, and we can't be more specific here without depending on the order in
+ // which integrations appear in the array, which we can't guarantee.
+ defaultIntegrations: expect.any(Array),
+ }),
+ );
+ });
+
+ describe('integrations', () => {
+ // Options passed by `@sentry/nextjs`'s `init` to `@sentry/vercel-edge`'s `init` after modifying them
+ type ModifiedInitOptions = { integrations?: Integration[]; defaultIntegrations: Integration[] };
+
+ it('adds default integrations', () => {
+ init({});
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const integrationNames = vercelEdgeInitOptions.defaultIntegrations.map(integration => integration.name);
+
+ expect(integrationNames).toContain('DistDirRewriteFrames');
+ });
+
+ it('supports passing unrelated integrations through options', () => {
+ init({ integrations: [SentryVercelEdge.dedupeIntegration()] });
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const dedupeIntegration = findIntegrationByName(vercelEdgeInitOptions.integrations, 'Dedupe');
+
+ expect(dedupeIntegration).toBeDefined();
+ });
+ });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses fallback environment when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ // In test environment, it should be undefined since we only set it explicitly when SENTRY_ENVIRONMENT is present
+ // Note: The underlying vercel-edge SDK may set its own default
+ expect(callArgs?.environment).toBeDefined();
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+ });
+});

packages/nextjs/test/serverSdk.test.ts

@@ -189,4 +189,97 @@ describe('Server init()', () => {
  );
  });
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ beforeEach(() => {
+ // Reset the global scope to allow re-initialization
+ SentryNode.getGlobalScope().clear();
+ SentryNode.getIsolationScope().clear();
+ SentryNode.getCurrentScope().clear();
+ SentryNode.getCurrentScope().setClient(undefined);
+ });
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/src/client/index.ts

@@ -65,7 +65,7 @@ export function init(options: BrowserOptions): Client | undefined {
  }
 
  const opts = {
- environment: getVercelEnv(true) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(true) || process.env.NODE_ENV,
  defaultIntegrations: getDefaultIntegrations(options),
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,

packages/nextjs/src/edge/index.ts

@@ -78,6 +78,7 @@ export function init(options: VercelEdgeOptions = {}): void {
 
  const opts: VercelEdgeOptions = {
  defaultIntegrations: customDefaultIntegrations,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,
  // Override runtime to 'cloudflare' when running on OpenNext/Cloudflare

packages/nextjs/src/server/index.ts

@@ -106,6 +106,7 @@ function getCloudflareRuntimeConfig(): { runtime: { name: string } } | undefined
 }
 
 /** Inits the Sentry NextJS SDK on node. */
+// eslint-disable-next-line complexity
 export function init(options: NodeOptions): NodeClient | undefined {
  prepareSafeIdGeneratorContext();
  if (isBuild()) {
@@ -146,7 +147,7 @@ export function init(options: NodeOptions): NodeClient | undefined {
  const cloudflareConfig = getCloudflareRuntimeConfig();
 
  const opts: NodeOptions = {
- environment: process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  defaultIntegrations: customDefaultIntegrations,
  ...options,

packages/nextjs/test/clientSdk.test.ts

@@ -166,4 +166,89 @@ describe('Client init()', () => {
  it('returns client from init', () => {
  expect(init({})).not.toBeUndefined();
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'custom-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'options-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/test/edgeSdk.test.ts

@@ -0,0 +1,140 @@
+import type { Integration } from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/core';
+import * as SentryVercelEdge from '@sentry/vercel-edge';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init } from '../src/edge';
+
+// normally this is set as part of the build process, so mock it here
+(GLOBAL_OBJ as typeof GLOBAL_OBJ & { _sentryRewriteFramesDistDir: string })._sentryRewriteFramesDistDir = '.next';
+
+const vercelEdgeInit = vi.spyOn(SentryVercelEdge, 'init');
+
+function findIntegrationByName(integrations: Integration[] = [], name: string): Integration | undefined {
+ return integrations.find(integration => integration.name === name);
+}
+
+describe('Edge init()', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('inits the Vercel Edge SDK', () => {
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(0);
+ init({});
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ expect(vercelEdgeInit).toHaveBeenLastCalledWith(
+ expect.objectContaining({
+ _metadata: {
+ sdk: {
+ name: 'sentry.javascript.nextjs',
+ version: expect.any(String),
+ packages: [
+ {
+ name: 'npm:@sentry/nextjs',
+ version: expect.any(String),
+ },
+ {
+ name: 'npm:@sentry/vercel-edge',
+ version: expect.any(String),
+ },
+ ],
+ },
+ },
+ // Integrations are tested separately, and we can't be more specific here without depending on the order in
+ // which integrations appear in the array, which we can't guarantee.
+ defaultIntegrations: expect.any(Array),
+ }),
+ );
+ });
+
+ describe('integrations', () => {
+ // Options passed by `@sentry/nextjs`'s `init` to `@sentry/vercel-edge`'s `init` after modifying them
+ type ModifiedInitOptions = { integrations?: Integration[]; defaultIntegrations: Integration[] };
+
+ it('adds default integrations', () => {
+ init({});
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const integrationNames = vercelEdgeInitOptions.defaultIntegrations.map(integration => integration.name);
+
+ expect(integrationNames).toContain('DistDirRewriteFrames');
+ });
+
+ it('supports passing unrelated integrations through options', () => {
+ init({ integrations: [SentryVercelEdge.dedupeIntegration()] });
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const dedupeIntegration = findIntegrationByName(vercelEdgeInitOptions.integrations, 'Dedupe');
+
+ expect(dedupeIntegration).toBeDefined();
+ });
+ });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses fallback environment when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ // In test environment, it should be undefined since we only set it explicitly when SENTRY_ENVIRONMENT is present
+ // Note: The underlying vercel-edge SDK may set its own default
+ expect(callArgs?.environment).toBeDefined();
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+ });
+});

packages/nextjs/test/serverSdk.test.ts

@@ -189,4 +189,97 @@ describe('Server init()', () => {
  );
  });
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ beforeEach(() => {
+ // Reset the global scope to allow re-initialization
+ SentryNode.getGlobalScope().clear();
+ SentryNode.getIsolationScope().clear();
+ SentryNode.getCurrentScope().clear();
+ SentryNode.getCurrentScope().setClient(undefined);
+ });
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/src/client/index.ts

@@ -65,7 +65,7 @@ export function init(options: BrowserOptions): Client | undefined {
  }
 
  const opts = {
- environment: getVercelEnv(true) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(true) || process.env.NODE_ENV,
  defaultIntegrations: getDefaultIntegrations(options),
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,

packages/nextjs/src/edge/index.ts

@@ -78,6 +78,7 @@ export function init(options: VercelEdgeOptions = {}): void {
 
  const opts: VercelEdgeOptions = {
  defaultIntegrations: customDefaultIntegrations,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,
  // Override runtime to 'cloudflare' when running on OpenNext/Cloudflare

packages/nextjs/src/server/index.ts

@@ -106,6 +106,7 @@ function getCloudflareRuntimeConfig(): { runtime: { name: string } } | undefined
 }
 
 /** Inits the Sentry NextJS SDK on node. */
+// eslint-disable-next-line complexity
 export function init(options: NodeOptions): NodeClient | undefined {
  prepareSafeIdGeneratorContext();
  if (isBuild()) {
@@ -146,7 +147,7 @@ export function init(options: NodeOptions): NodeClient | undefined {
  const cloudflareConfig = getCloudflareRuntimeConfig();
 
  const opts: NodeOptions = {
- environment: process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  defaultIntegrations: customDefaultIntegrations,
  ...options,

packages/nextjs/test/clientSdk.test.ts

@@ -166,4 +166,89 @@ describe('Client init()', () => {
  it('returns client from init', () => {
  expect(init({})).not.toBeUndefined();
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'custom-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'options-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/test/edgeSdk.test.ts

@@ -0,0 +1,140 @@
+import type { Integration } from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/core';
+import * as SentryVercelEdge from '@sentry/vercel-edge';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init } from '../src/edge';
+
+// normally this is set as part of the build process, so mock it here
+(GLOBAL_OBJ as typeof GLOBAL_OBJ & { _sentryRewriteFramesDistDir: string })._sentryRewriteFramesDistDir = '.next';
+
+const vercelEdgeInit = vi.spyOn(SentryVercelEdge, 'init');
+
+function findIntegrationByName(integrations: Integration[] = [], name: string): Integration | undefined {
+ return integrations.find(integration => integration.name === name);
+}
+
+describe('Edge init()', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('inits the Vercel Edge SDK', () => {
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(0);
+ init({});
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ expect(vercelEdgeInit).toHaveBeenLastCalledWith(
+ expect.objectContaining({
+ _metadata: {
+ sdk: {
+ name: 'sentry.javascript.nextjs',
+ version: expect.any(String),
+ packages: [
+ {
+ name: 'npm:@sentry/nextjs',
+ version: expect.any(String),
+ },
+ {
+ name: 'npm:@sentry/vercel-edge',
+ version: expect.any(String),
+ },
+ ],
+ },
+ },
+ // Integrations are tested separately, and we can't be more specific here without depending on the order in
+ // which integrations appear in the array, which we can't guarantee.
+ defaultIntegrations: expect.any(Array),
+ }),
+ );
+ });
+
+ describe('integrations', () => {
+ // Options passed by `@sentry/nextjs`'s `init` to `@sentry/vercel-edge`'s `init` after modifying them
+ type ModifiedInitOptions = { integrations?: Integration[]; defaultIntegrations: Integration[] };
+
+ it('adds default integrations', () => {
+ init({});
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const integrationNames = vercelEdgeInitOptions.defaultIntegrations.map(integration => integration.name);
+
+ expect(integrationNames).toContain('DistDirRewriteFrames');
+ });
+
+ it('supports passing unrelated integrations through options', () => {
+ init({ integrations: [SentryVercelEdge.dedupeIntegration()] });
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const dedupeIntegration = findIntegrationByName(vercelEdgeInitOptions.integrations, 'Dedupe');
+
+ expect(dedupeIntegration).toBeDefined();
+ });
+ });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses fallback environment when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ // In test environment, it should be undefined since we only set it explicitly when SENTRY_ENVIRONMENT is present
+ // Note: The underlying vercel-edge SDK may set its own default
+ expect(callArgs?.environment).toBeDefined();
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+ });
+});

packages/nextjs/test/serverSdk.test.ts

@@ -189,4 +189,97 @@ describe('Server init()', () => {
  );
  });
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ beforeEach(() => {
+ // Reset the global scope to allow re-initialization
+ SentryNode.getGlobalScope().clear();
+ SentryNode.getIsolationScope().clear();
+ SentryNode.getCurrentScope().clear();
+ SentryNode.getCurrentScope().setClient(undefined);
+ });
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/src/client/index.ts

@@ -65,7 +65,7 @@ export function init(options: BrowserOptions): Client | undefined {
  }
 
  const opts = {
- environment: getVercelEnv(true) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(true) || process.env.NODE_ENV,
  defaultIntegrations: getDefaultIntegrations(options),
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,

packages/nextjs/src/edge/index.ts

@@ -78,6 +78,7 @@ export function init(options: VercelEdgeOptions = {}): void {
 
  const opts: VercelEdgeOptions = {
  defaultIntegrations: customDefaultIntegrations,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,
  // Override runtime to 'cloudflare' when running on OpenNext/Cloudflare

packages/nextjs/src/server/index.ts

@@ -106,6 +106,7 @@ function getCloudflareRuntimeConfig(): { runtime: { name: string } } | undefined
 }
 
 /** Inits the Sentry NextJS SDK on node. */
+// eslint-disable-next-line complexity
 export function init(options: NodeOptions): NodeClient | undefined {
  prepareSafeIdGeneratorContext();
  if (isBuild()) {
@@ -146,7 +147,7 @@ export function init(options: NodeOptions): NodeClient | undefined {
  const cloudflareConfig = getCloudflareRuntimeConfig();
 
  const opts: NodeOptions = {
- environment: process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  defaultIntegrations: customDefaultIntegrations,
  ...options,

packages/nextjs/test/clientSdk.test.ts

@@ -166,4 +166,89 @@ describe('Client init()', () => {
  it('returns client from init', () => {
  expect(init({})).not.toBeUndefined();
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'custom-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'options-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/test/edgeSdk.test.ts

@@ -0,0 +1,140 @@
+import type { Integration } from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/core';
+import * as SentryVercelEdge from '@sentry/vercel-edge';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init } from '../src/edge';
+
+// normally this is set as part of the build process, so mock it here
+(GLOBAL_OBJ as typeof GLOBAL_OBJ & { _sentryRewriteFramesDistDir: string })._sentryRewriteFramesDistDir = '.next';
+
+const vercelEdgeInit = vi.spyOn(SentryVercelEdge, 'init');
+
+function findIntegrationByName(integrations: Integration[] = [], name: string): Integration | undefined {
+ return integrations.find(integration => integration.name === name);
+}
+
+describe('Edge init()', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('inits the Vercel Edge SDK', () => {
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(0);
+ init({});
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ expect(vercelEdgeInit).toHaveBeenLastCalledWith(
+ expect.objectContaining({
+ _metadata: {
+ sdk: {
+ name: 'sentry.javascript.nextjs',
+ version: expect.any(String),
+ packages: [
+ {
+ name: 'npm:@sentry/nextjs',
+ version: expect.any(String),
+ },
+ {
+ name: 'npm:@sentry/vercel-edge',
+ version: expect.any(String),
+ },
+ ],
+ },
+ },
+ // Integrations are tested separately, and we can't be more specific here without depending on the order in
+ // which integrations appear in the array, which we can't guarantee.
+ defaultIntegrations: expect.any(Array),
+ }),
+ );
+ });
+
+ describe('integrations', () => {
+ // Options passed by `@sentry/nextjs`'s `init` to `@sentry/vercel-edge`'s `init` after modifying them
+ type ModifiedInitOptions = { integrations?: Integration[]; defaultIntegrations: Integration[] };
+
+ it('adds default integrations', () => {
+ init({});
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const integrationNames = vercelEdgeInitOptions.defaultIntegrations.map(integration => integration.name);
+
+ expect(integrationNames).toContain('DistDirRewriteFrames');
+ });
+
+ it('supports passing unrelated integrations through options', () => {
+ init({ integrations: [SentryVercelEdge.dedupeIntegration()] });
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const dedupeIntegration = findIntegrationByName(vercelEdgeInitOptions.integrations, 'Dedupe');
+
+ expect(dedupeIntegration).toBeDefined();
+ });
+ });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses fallback environment when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ // In test environment, it should be undefined since we only set it explicitly when SENTRY_ENVIRONMENT is present
+ // Note: The underlying vercel-edge SDK may set its own default
+ expect(callArgs?.environment).toBeDefined();
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+ });
+});

packages/nextjs/test/serverSdk.test.ts

@@ -189,4 +189,97 @@ describe('Server init()', () => {
  );
  });
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ beforeEach(() => {
+ // Reset the global scope to allow re-initialization
+ SentryNode.getGlobalScope().clear();
+ SentryNode.getIsolationScope().clear();
+ SentryNode.getCurrentScope().clear();
+ SentryNode.getCurrentScope().setClient(undefined);
+ });
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/src/client/index.ts

@@ -65,7 +65,7 @@ export function init(options: BrowserOptions): Client | undefined {
  }
 
  const opts = {
- environment: getVercelEnv(true) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(true) || process.env.NODE_ENV,
  defaultIntegrations: getDefaultIntegrations(options),
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,

packages/nextjs/src/edge/index.ts

@@ -78,6 +78,7 @@ export function init(options: VercelEdgeOptions = {}): void {
 
  const opts: VercelEdgeOptions = {
  defaultIntegrations: customDefaultIntegrations,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  ...options,
  // Override runtime to 'cloudflare' when running on OpenNext/Cloudflare

packages/nextjs/src/server/index.ts

@@ -106,6 +106,7 @@ function getCloudflareRuntimeConfig(): { runtime: { name: string } } | undefined
 }
 
 /** Inits the Sentry NextJS SDK on node. */
+// eslint-disable-next-line complexity
 export function init(options: NodeOptions): NodeClient | undefined {
  prepareSafeIdGeneratorContext();
  if (isBuild()) {
@@ -146,7 +147,7 @@ export function init(options: NodeOptions): NodeClient | undefined {
  const cloudflareConfig = getCloudflareRuntimeConfig();
 
  const opts: NodeOptions = {
- environment: process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
+ environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
  release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
  defaultIntegrations: customDefaultIntegrations,
  ...options,

packages/nextjs/test/clientSdk.test.ts

@@ -166,4 +166,89 @@ describe('Client init()', () => {
  it('returns client from init', () => {
  expect(init({})).not.toBeUndefined();
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'custom-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ environment: 'options-env',
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: TEST_DSN,
+ });
+
+ expect(reactInit).toHaveBeenCalledTimes(1);
+ const callArgs = reactInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });

packages/nextjs/test/edgeSdk.test.ts

@@ -0,0 +1,140 @@
+import type { Integration } from '@sentry/core';
+import { GLOBAL_OBJ } from '@sentry/core';
+import * as SentryVercelEdge from '@sentry/vercel-edge';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init } from '../src/edge';
+
+// normally this is set as part of the build process, so mock it here
+(GLOBAL_OBJ as typeof GLOBAL_OBJ & { _sentryRewriteFramesDistDir: string })._sentryRewriteFramesDistDir = '.next';
+
+const vercelEdgeInit = vi.spyOn(SentryVercelEdge, 'init');
+
+function findIntegrationByName(integrations: Integration[] = [], name: string): Integration | undefined {
+ return integrations.find(integration => integration.name === name);
+}
+
+describe('Edge init()', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('inits the Vercel Edge SDK', () => {
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(0);
+ init({});
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ expect(vercelEdgeInit).toHaveBeenLastCalledWith(
+ expect.objectContaining({
+ _metadata: {
+ sdk: {
+ name: 'sentry.javascript.nextjs',
+ version: expect.any(String),
+ packages: [
+ {
+ name: 'npm:@sentry/nextjs',
+ version: expect.any(String),
+ },
+ {
+ name: 'npm:@sentry/vercel-edge',
+ version: expect.any(String),
+ },
+ ],
+ },
+ },
+ // Integrations are tested separately, and we can't be more specific here without depending on the order in
+ // which integrations appear in the array, which we can't guarantee.
+ defaultIntegrations: expect.any(Array),
+ }),
+ );
+ });
+
+ describe('integrations', () => {
+ // Options passed by `@sentry/nextjs`'s `init` to `@sentry/vercel-edge`'s `init` after modifying them
+ type ModifiedInitOptions = { integrations?: Integration[]; defaultIntegrations: Integration[] };
+
+ it('adds default integrations', () => {
+ init({});
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const integrationNames = vercelEdgeInitOptions.defaultIntegrations.map(integration => integration.name);
+
+ expect(integrationNames).toContain('DistDirRewriteFrames');
+ });
+
+ it('supports passing unrelated integrations through options', () => {
+ init({ integrations: [SentryVercelEdge.dedupeIntegration()] });
+
+ const vercelEdgeInitOptions = vercelEdgeInit.mock.calls[0]?.[0] as ModifiedInitOptions;
+ const dedupeIntegration = findIntegrationByName(vercelEdgeInitOptions.integrations, 'Dedupe');
+
+ expect(dedupeIntegration).toBeDefined();
+ });
+ });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses fallback environment when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ // In test environment, it should be undefined since we only set it explicitly when SENTRY_ENVIRONMENT is present
+ // Note: The underlying vercel-edge SDK may set its own default
+ expect(callArgs?.environment).toBeDefined();
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(vercelEdgeInit).toHaveBeenCalledTimes(1);
+ const callArgs = vercelEdgeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+ });
+});

packages/nextjs/test/serverSdk.test.ts

@@ -189,4 +189,97 @@ describe('Server init()', () => {
  );
  });
  });
+
+ describe('environment option', () => {
+ const originalEnv = process.env.SENTRY_ENVIRONMENT;
+ const originalNodeEnv = process.env.NODE_ENV;
+
+ beforeEach(() => {
+ // Reset the global scope to allow re-initialization
+ SentryNode.getGlobalScope().clear();
+ SentryNode.getIsolationScope().clear();
+ SentryNode.getCurrentScope().clear();
+ SentryNode.getCurrentScope().setClient(undefined);
+ });
+
+ afterEach(() => {
+ if (originalEnv !== undefined) {
+ process.env.SENTRY_ENVIRONMENT = originalEnv;
+ } else {
+ delete process.env.SENTRY_ENVIRONMENT;
+ }
+ if (originalNodeEnv !== undefined) {
+ process.env.NODE_ENV = originalNodeEnv;
+ } else {
+ delete process.env.NODE_ENV;
+ }
+ });
+
+ it('uses environment from options when provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'custom-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('custom-env');
+ });
+
+ it('uses SENTRY_ENVIRONMENT env var when options.environment is not provided', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('env-from-variable');
+ });
+
+ it('uses NODE_ENV as fallback when neither options.environment nor SENTRY_ENVIRONMENT is provided', () => {
+ delete process.env.SENTRY_ENVIRONMENT;
+ process.env.NODE_ENV = 'production';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('production');
+ });
+
+ it('prioritizes options.environment over SENTRY_ENVIRONMENT env var', () => {
+ process.env.SENTRY_ENVIRONMENT = 'env-from-variable';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ environment: 'options-env',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('options-env');
+ });
+
+ it('prioritizes SENTRY_ENVIRONMENT over NODE_ENV', () => {
+ process.env.SENTRY_ENVIRONMENT = 'sentry-env';
+ process.env.NODE_ENV = 'development';
+
+ init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ });
+
+ expect(nodeInit).toHaveBeenCalledTimes(1);
+ const callArgs = nodeInit.mock.calls[0]?.[0];
+ expect(callArgs?.environment).toBe('sentry-env');
+ });
+ });
 });