Merge pull request #9684 from getsentry/prepare-release/7.83.0

meta: Update Changelog for 7.83.0

Author: Lms24

CHANGELOG.md

@@ -4,6 +4,15 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+## 7.83.0
+
+- chore(astro): Allow Astro 4.0 in peer dependencies (#9683)
+- feat(astro): Add `assets` option to source maps upload options (#9668)
+- feat(react): Support `exactOptionalPropertyTypes` on `ErrorBoundary` (#9098)
+- fix: Don't depend on browser types in `types` (#9682)
+- fix(astro): Configure sourcemap assets directory for Vercel adapter (#9665)
+- fix(remix): Check the error data before spreading. (#9664)
+
 ## 7.82.0
 
 - feat(astro): Automatically add Sentry middleware in Astro integration (#9532)

CONTRIBUTING.md

@@ -69,7 +69,7 @@ Pro tip: If any of your breakpoints are in code run by multiple tests, and you r
 
 ## Debug Build Flags
 
-Throughout the codebase, you will find the `__DEBUG_BUILD__` flag guarding various code sections. This flag serves two purposes:
+Throughout the codebase, you will find a `__DEBUG_BUILD__` constant. This flag serves two purposes:
 
 1. It enables us to remove debug code from our minified CDN bundles during build, by replacing the flag with `false` before tree-shaking occurs.
 2. It enables users to remove Sentry debug code from their production bundles during their own build. When we build our npm packages, we replace the flag with `(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)`. If the user does nothing, this evaluates to `true` and logging is included. But if the user runs their own replacement during build (again replacing the flag with `false`), the build will tree-shake the logging away, just as our bundle builds do.

packages/astro/package.json

@@ -40,7 +40,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "astro": "3.x"
+    "astro": ">=3.x"
   },
   "dependencies": {
     "@sentry/browser": "7.82.0",

packages/astro/src/integration/index.ts

@@ -42,7 +42,7 @@ export const sentryAstro = (options: SentryOptions = {}): AstroIntegration => {
                   authToken: uploadOptions.authToken ?? env.SENTRY_AUTH_TOKEN,
                   telemetry: uploadOptions.telemetry ?? true,
                   sourcemaps: {
-                    assets: [getSourcemapsAssetsGlob(config)],
+                    assets: uploadOptions.assets ?? [getSourcemapsAssetsGlob(config)],
                   },
                   debug: options.debug ?? false,
                 }),
@@ -100,9 +100,19 @@ function findDefaultSdkInitFile(type: 'server' | 'client'): string | undefined {
 }
 
 function getSourcemapsAssetsGlob(config: AstroConfig): string {
+  // The vercel adapter puts the output into its .vercel directory
+  // However, the way this adapter is written, the config.outDir value is update too late for
+  // us to reliably detect it. Also, server files are first temporarily written to <root>/dist and then
+  // only copied over to <root>/.vercel. This seems to happen too late though.
+  // So we glob on both of these directories.
+  // Another case of "it ain't pretty but it works":(
+  if (config.adapter?.name?.startsWith('@astrojs/vercel')) {
+    return '{.vercel,dist}/**/*';
+  }
+
   // paths are stored as "file://" URLs
   const outDirPathname = config.outDir && path.resolve(config.outDir.pathname);
-  const rootDirName = path.resolve((config.root && config.root.pathname) || process.cwd());
+  const rootDirName = path.resolve(config.root?.pathname || process.cwd());
 
   if (outDirPathname) {
     const relativePath = path.relative(rootDirName, outDirPathname);

packages/astro/src/integration/types.ts

@@ -68,6 +68,18 @@ type SourceMapsOptions = {
      * @default true
      */
     telemetry?: boolean;
+
+    /**
+     * A glob or an array of globs that specify the build artifacts and source maps that will uploaded to Sentry.
+     *
+     * If this option is not specified, sensible defaults based on your `outDir`, `rootDir` and `adapter`
+     * config will be used. Use this option to override these defaults, for instance if you have a
+     * customized build setup that diverges from Astro's defaults.
+     *
+     * The globbing patterns must follow the implementation of the `glob` package.
+     * @see https://www.npmjs.com/package/glob#glob-primer
+     */
+    assets?: string | Array<string>;
   };
 };
 

packages/astro/test/integration/index.test.ts

@@ -83,6 +83,65 @@ describe('sentryAstro integration', () => {
     });
   });
 
+  it('sets the correct assets glob for vercel if the Vercel adapter is used', async () => {
+    const integration = sentryAstro({
+      sourceMapsUploadOptions: { enabled: true, org: 'my-org', project: 'my-project', telemetry: false },
+    });
+    // @ts-expect-error - the hook exists and we only need to pass what we actually use
+    await integration.hooks['astro:config:setup']({
+      updateConfig,
+      injectScript,
+      config: {
+        // @ts-expect-error - we only need to pass what we actually use
+        adapter: { name: '@astrojs/vercel/serverless' },
+      },
+    });
+
+    expect(sentryVitePluginSpy).toHaveBeenCalledTimes(1);
+    expect(sentryVitePluginSpy).toHaveBeenCalledWith({
+      authToken: 'my-token',
+      org: 'my-org',
+      project: 'my-project',
+      telemetry: false,
+      debug: false,
+      sourcemaps: {
+        assets: ['{.vercel,dist}/**/*'],
+      },
+    });
+  });
+
+  it('prefers user-specified assets-globs over the default values', async () => {
+    const integration = sentryAstro({
+      sourceMapsUploadOptions: {
+        enabled: true,
+        org: 'my-org',
+        project: 'my-project',
+        assets: ['dist/server/**/*, dist/client/**/*'],
+      },
+    });
+    // @ts-expect-error - the hook exists and we only need to pass what we actually use
+    await integration.hooks['astro:config:setup']({
+      updateConfig,
+      injectScript,
+      // @ts-expect-error - only passing in partial config
+      config: {
+        outDir: new URL('file://path/to/project/build'),
+      },
+    });
+
+    expect(sentryVitePluginSpy).toHaveBeenCalledTimes(1);
+    expect(sentryVitePluginSpy).toHaveBeenCalledWith({
+      authToken: 'my-token',
+      org: 'my-org',
+      project: 'my-project',
+      telemetry: true,
+      debug: false,
+      sourcemaps: {
+        assets: ['dist/server/**/*, dist/client/**/*'],
+      },
+    });
+  });
+
   it("doesn't enable source maps if `sourceMapsUploadOptions.enabled` is `false`", async () => {
     const integration = sentryAstro({
       sourceMapsUploadOptions: { enabled: false },

packages/browser/src/client.ts

@@ -13,6 +13,7 @@ import type {
 } from '@sentry/types';
 import { createClientReportEnvelope, dsnToString, getSDKSource, logger } from '@sentry/utils';
 
+import { DEBUG_BUILD } from './debug-build';
 import { eventFromException, eventFromMessage } from './eventbuilder';
 import { WINDOW } from './helpers';
 import type { BrowserTransportOptions } from './transports/types';
@@ -96,7 +97,7 @@ export class BrowserClient extends BaseClient<BrowserClientOptions> {
    */
   public captureUserFeedback(feedback: UserFeedback): void {
     if (!this._isEnabled()) {
-      __DEBUG_BUILD__ && logger.warn('SDK not enabled, will not capture user feedback.');
+      DEBUG_BUILD && logger.warn('SDK not enabled, will not capture user feedback.');
       return;
     }
 
@@ -123,17 +124,17 @@ export class BrowserClient extends BaseClient<BrowserClientOptions> {
     const outcomes = this._clearOutcomes();
 
     if (outcomes.length === 0) {
-      __DEBUG_BUILD__ && logger.log('No outcomes to send');
+      DEBUG_BUILD && logger.log('No outcomes to send');
       return;
     }
 
     // This is really the only place where we want to check for a DSN and only send outcomes then
     if (!this._dsn) {
-      __DEBUG_BUILD__ && logger.log('No dsn provided, will not send outcomes');
+      DEBUG_BUILD && logger.log('No dsn provided, will not send outcomes');
       return;
     }
 
-    __DEBUG_BUILD__ && logger.log('Sending outcomes:', outcomes);
+    DEBUG_BUILD && logger.log('Sending outcomes:', outcomes);
 
     const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));
     void this._sendEnvelope(envelope);

packages/browser/src/debug-build.ts

@@ -0,0 +1,8 @@
+declare const __DEBUG_BUILD__: boolean;
+
+/**
+ * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
+ *
+ * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
+ */
+export const DEBUG_BUILD = __DEBUG_BUILD__;

packages/browser/src/integrations/breadcrumbs.ts

@@ -30,6 +30,7 @@ import {
   severityLevelFromString,
 } from '@sentry/utils';
 
+import { DEBUG_BUILD } from '../debug-build';
 import { getClient } from '../exports';
 import { WINDOW } from '../helpers';
 
@@ -148,7 +149,7 @@ function _domBreadcrumb(dom: BreadcrumbsOptions['dom']): (handlerData: HandlerDa
     let maxStringLength =
       typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;
     if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {
-      __DEBUG_BUILD__ &&
+      DEBUG_BUILD &&
         logger.warn(
           `\`dom.maxStringLength\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`,
         );

packages/browser/src/integrations/dedupe.ts

@@ -1,6 +1,8 @@
 import type { Event, Exception, Integration, StackFrame } from '@sentry/types';
 import { logger } from '@sentry/utils';
 
+import { DEBUG_BUILD } from '../debug-build';
+
 /** Deduplication filter */
 export class Dedupe implements Integration {
   /**
@@ -40,7 +42,7 @@ export class Dedupe implements Integration {
     // Juuust in case something goes wrong
     try {
       if (_shouldDropEvent(currentEvent, this._previousEvent)) {
-        __DEBUG_BUILD__ && logger.warn('Event dropped due to being a duplicate of previously captured event.');
+        DEBUG_BUILD && logger.warn('Event dropped due to being a duplicate of previously captured event.');
         return null;
       }
     } catch (_oO) {} // eslint-disable-line no-empty