feat(sveltekit): Enable hidden source maps or keep settings

Author: s1gr1d

packages/sveltekit/src/vite/sourceMaps.ts

@@ -1,11 +1,11 @@
 import * as child_process from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
-import { escapeStringForRegex, uuid4 } from '@sentry/core';
+import { consoleSandbox, escapeStringForRegex, uuid4 } from '@sentry/core';
 import { getSentryRelease } from '@sentry/node';
 import type { SentryVitePluginOptions } from '@sentry/vite-plugin';
 import { sentryVitePlugin } from '@sentry/vite-plugin';
-import type { Plugin } from 'vite';
+import type { Plugin, UserConfig } from 'vite';
 
 import MagicString from 'magic-string';
 import { WRAPPED_MODULE_SUFFIX } from './autoInstrument';
@@ -101,26 +101,18 @@ export async function makeCustomSentryVitePlugins(options?: CustomSentryVitePlug
     enforce: 'post', // this needs to be set to post, otherwise we don't pick up the output from the SvelteKit adapter
 
     // Modify the config to generate source maps
-    config: config => {
-      const sourceMapsPreviouslyNotEnabled = !config.build?.sourcemap;
-      if (debug && sourceMapsPreviouslyNotEnabled) {
-        // eslint-disable-next-line no-console
-        console.log('[Source Maps Plugin] Enabling source map generation');
-        if (!mergedOptions.sourcemaps?.filesToDeleteAfterUpload) {
+    config: (config: UserConfig) => {
+      changeViteSourceMapSettings(config, options);
+
+      if (debug && !mergedOptions.sourcemaps?.filesToDeleteAfterUpload) {
+        consoleSandbox(() => {
           // eslint-disable-next-line no-console
           console.warn(
-            `[Source Maps Plugin] We recommend setting the \`sourceMapsUploadOptions.sourcemaps.filesToDeleteAfterUpload\` option to clean up source maps after uploading.
-[Source Maps Plugin] Otherwise, source maps might be deployed to production, depending on your configuration`,
+            '[Source Maps Plugin] We recommend setting the `sourceMapsUploadOptions.sourcemaps.filesToDeleteAfterUpload` option to clean up source maps after uploading. Otherwise, source maps might be deployed to production, depending on your configuration',
           );
-        }
+        });
       }
-      return {
-        ...config,
-        build: {
-          ...config.build,
-          sourcemap: true,
-        },
-      };
+      return config;
     },
 
     resolveId: (id, _importer, _ref) => {
@@ -251,6 +243,86 @@ export async function makeCustomSentryVitePlugins(options?: CustomSentryVitePlug
   return [...restOfSentryVitePlugins, customPlugin];
 }
 
+/**
+ * Whether the user enabled (true, 'hidden', 'inline') or disabled (false) source maps
+ */
+export type UserSourceMapSetting = 'enabled' | 'disabled' | 'unset' | undefined;
+
+/** There are 3 ways to set up source maps (https://github.com/getsentry/sentry-javascript/issues/13993)
+ *
+ *     1. User explicitly disabled source maps
+ *       - keep this setting (emit a warning that errors won't be unminified in Sentry)
+ *       - We won't upload anything
+ *
+ *     2. Users enabled source map generation (true, 'hidden', 'inline').
+ *       - keep this setting (don't do anything - like deletion - besides uploading)
+ *
+ *     3. Users didn't set source maps generation
+ *       - we enable 'hidden' source maps generation
+ *       - configure `filesToDeleteAfterUpload` to delete all .map files (we emit a log about this)
+ *
+ * --> only exported for testing
+ */
+export function changeViteSourceMapSettings(
+  viteConfig: {
+    build?: {
+      sourcemap?: boolean | 'inline' | 'hidden';
+    };
+  },
+  sentryPluginOptions?: CustomSentryVitePluginOptions,
+): UserSourceMapSetting {
+  let previousUserSourceMapSetting: UserSourceMapSetting = undefined;
+
+  viteConfig.build = viteConfig.build || {};
+
+  const viteSourceMap = viteConfig.build.sourcemap;
+
+  if (viteSourceMap === false) {
+    warnExplicitlyDisabledSourceMap('vite.build.sourcemap');
+    previousUserSourceMapSetting = 'disabled';
+  } else if (viteSourceMap && ['hidden', 'inline', true].includes(viteSourceMap)) {
+    logKeepSourceMapSetting('vite.build.sourcemap', viteSourceMap.toString(), sentryPluginOptions);
+    previousUserSourceMapSetting = 'enabled';
+  } else {
+    viteConfig.build.sourcemap = 'hidden';
+    logSentryEnablesSourceMap('vite.build.sourcemap', 'hidden');
+    previousUserSourceMapSetting = 'unset';
+  }
+
+  return previousUserSourceMapSetting;
+}
+
+function logKeepSourceMapSetting(
+  settingKey: string,
+  settingValue: string,
+  sentryPluginOptions?: CustomSentryVitePluginOptions,
+): void {
+  if (sentryPluginOptions?.debug) {
+    consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.log(
+        `[Sentry] We discovered \`${settingKey}\` is set to \`${settingValue}\`. Sentry will keep this source map setting. This will un-minify the code snippet on the Sentry Issue page.`,
+      );
+    });
+  }
+}
+
+function warnExplicitlyDisabledSourceMap(settingKey: string): void {
+  consoleSandbox(() => {
+    //  eslint-disable-next-line no-console
+    console.warn(
+      `[Sentry] Parts of source map generation are currently disabled in your Nuxt configuration (\`${settingKey}: false\`). This setting is either a default setting or was explicitly set in your configuration. Sentry won't override this setting. Without source maps, code snippets on the Sentry Issues page will remain minified. To show unminified code, enable source maps in \`${settingKey}\` (e.g. by setting them to \`hidden\`).`,
+    );
+  });
+}
+
+function logSentryEnablesSourceMap(settingKey: string, settingValue: string): void {
+  consoleSandbox(() => {
+    //  eslint-disable-next-line no-console
+    console.log(`[Sentry] Enabled source map generation in the build options with \`${settingKey}: ${settingValue}\`.`);
+  });
+}
+
 function getFiles(dir: string): string[] {
   if (!fs.existsSync(dir)) {
     return [];

packages/sveltekit/test/vite/sourceMaps.test.ts

@@ -1,4 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { changeViteSourceMapSettings } from '../../src/vite/sourceMaps';
+import type { CustomSentryVitePluginOptions } from '../../src/vite/types';
 
 import type { Plugin } from 'vite';
 import { makeCustomSentryVitePlugins } from '../../src/vite/sourceMaps';
@@ -59,10 +61,26 @@ describe('makeCustomSentryVitePlugin()', () => {
   });
 
   describe('Custom sentry vite plugin', () => {
-    it('enables source map generation', async () => {
+    it('enables source map generation when unset', async () => {
       const plugin = await getCustomSentryViteUploadSourcemapsPlugin();
       // @ts-expect-error this function exists!
       const sentrifiedConfig = plugin.config({ build: { foo: {} }, test: {} });
+      expect(sentrifiedConfig).toEqual({
+        build: {
+          foo: {},
+          sourcemap: 'hidden',
+        },
+        test: {},
+      });
+    });
+
+    it('keeps source map generation settings', async () => {
+      const plugin = await getCustomSentryViteUploadSourcemapsPlugin();
+      // @ts-expect-error this function exists!
+      const sentrifiedConfig = plugin.config({
+        build: { sourcemap: true, foo: {} },
+        test: {},
+      });
       expect(sentrifiedConfig).toEqual({
         build: {
           foo: {},
@@ -125,3 +143,50 @@ describe('makeCustomSentryVitePlugin()', () => {
     expect(consoleLogSpy).toHaveBeenCalled();
   });
 });
+
+describe('changeViteSourceMapSettings()', () => {
+  let viteConfig: { build?: { sourcemap?: boolean | 'inline' | 'hidden' } };
+  let sentryModuleOptions: CustomSentryVitePluginOptions;
+
+  beforeEach(() => {
+    viteConfig = {};
+    sentryModuleOptions = {};
+  });
+
+  it('handles vite source map settings', () => {
+    const cases = [
+      { sourcemap: false, expectedSourcemap: false, expectedReturn: 'disabled' },
+      { sourcemap: 'hidden', expectedSourcemap: 'hidden', expectedReturn: 'enabled' },
+      { sourcemap: 'inline', expectedSourcemap: 'inline', expectedReturn: 'enabled' },
+      { sourcemap: true, expectedSourcemap: true, expectedReturn: 'enabled' },
+      { sourcemap: undefined, expectedSourcemap: 'hidden', expectedReturn: 'unset' },
+    ];
+
+    cases.forEach(({ sourcemap, expectedSourcemap, expectedReturn }) => {
+      viteConfig.build = { sourcemap };
+      const previousUserSourceMapSetting = changeViteSourceMapSettings(viteConfig, sentryModuleOptions);
+      expect(viteConfig.build.sourcemap).toBe(expectedSourcemap);
+      expect(previousUserSourceMapSetting).toBe(expectedReturn);
+    });
+  });
+
+  it('logs warnings and messages when debug is enabled', () => {
+    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    sentryModuleOptions = { debug: true };
+
+    viteConfig.build = { sourcemap: false };
+    changeViteSourceMapSettings(viteConfig, sentryModuleOptions);
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Parts of source map generation are currently disabled'),
+    );
+
+    viteConfig.build = { sourcemap: 'hidden' };
+    changeViteSourceMapSettings(viteConfig, sentryModuleOptions);
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Sentry will keep this source map setting'));
+
+    consoleWarnSpy.mockRestore();
+    consoleLogSpy.mockRestore();
+  });
+});