Merge remote-tracking branch 'upstream/master' into dsorin/forge-add-transport

* upstream/master: (29 commits)
  ref: Always use lowercase files (getsentry#3742)
  feat: Make dedupe integration default for browser (getsentry#3730)
  ref(ember): Allow initing Ember without config entry (getsentry#3745)
  fix(serverless): wrapEventFunction does not await for async code (getsentry#3740)
  Metrics: Tag CLS elements (getsentry#3734)
  feat: Add Next.js 11 to supported peer dependencies list (getsentry#3711)
  test: Run integration tests for Next 10/11 and Webpack 4/5 matrix (getsentry#3741)
  fix: Correctly limit Buffer requests (getsentry#3736)
  Whoops. Remove pinned node version from package.json
  ref: Introduce test runner for node session health tests (getsentry#3728)
  fix: Prevent circular structure serialization in events (getsentry#3727)
  ref(node): Update Node manual tests and test for sessionCount (getsentry#3726)
  ref(ember): Update scenarios and remove a few to speed up tests (getsentry#3720)
  docs: Fix typos (getsentry#3716)
  fix(ember): Fix ember test flake (getsentry#3719)
  release: 6.7.2
  ci: fix ember flaky test (getsentry#3718)
  misc: changelog for release 6.7.2 (getsentry#3717)
  fix(release-health): Prevent sending terminal status session updates (getsentry#3701)
  ref: Make beforeSend more strict (getsentry#3713)
  ...

Author: 1999

CHANGELOG.md

@@ -4,6 +4,18 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+## 6.7.2
+
+- [core] fix: Do not track sessions if not enabled (#3686)
+- [core] fix: Prevent sending terminal status session updates (#3701)  
+- [core] ref: Make `beforeSend` more strict (#3713)
+- [browser] ref: Log which request type has been limited (#3687)
+- [nextjs] feat: Auto enable node http integration on server (#3675)
+- [nextjs] fix: Correctly handle functional next config in `withSentryConfig` (#3698)
+- [nextjs] fix: Fix conflict with other libraries modifying webpack `entry` property (#3703)
+- [nextjs] fix: Update @sentry/webpack-plugin to 1.15.1 in @sentry/nextjs to resolve build timeouts issue (#3708) 
+- [nextjs] ref: Split up config code and add tests (#3693)
+
 ## 6.7.1
 
 - [core] fix: Add event type to item header when envelopes are forced (#3676)
@@ -59,7 +71,7 @@
 
 ## 6.4.0
 
-- [core] feat: initalScope in SDK Options (#3544)
+- [core] feat: initialScope in SDK Options (#3544)
 - [node] feat: Release Health for Node (Session Aggregates) (#3319)
 - [node] feat: Autoload Database Integrations in Node environment (#3483)
 - [react] feat: Add support for React 17 Error Boundaries (#3532)

lerna.json

@@ -1,6 +1,6 @@
 {
   "lerna": "3.4.0",
-  "version": "6.7.1",
+  "version": "6.7.2",
   "packages": "packages/*",
   "npmClient": "yarn",
   "useWorkspaces": true

packages/angular/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/angular",
-  "version": "6.7.1",
+  "version": "6.7.2",
   "description": "Official Sentry SDK for Angular",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/angular",
@@ -21,17 +21,17 @@
     "@angular/router": "10.x || 11.x || 12.x"
   },
   "dependencies": {
-    "@sentry/browser": "6.7.1",
-    "@sentry/types": "6.7.1",
-    "@sentry/utils": "6.7.1",
+    "@sentry/browser": "6.7.2",
+    "@sentry/types": "6.7.2",
+    "@sentry/utils": "6.7.2",
     "rxjs": "^6.6.0",
     "tslib": "^1.9.3"
   },
   "devDependencies": {
     "@angular/common": "^10.0.3",
     "@angular/core": "^10.0.3",
     "@angular/router": "^10.0.3",
-    "@sentry-internal/eslint-config-sdk": "6.7.1",
+    "@sentry-internal/eslint-config-sdk": "6.7.2",
     "npm-run-all": "^4.1.2",
     "prettier": "1.19.0",
     "rimraf": "^2.6.3",

packages/browser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/browser",
-  "version": "6.7.1",
+  "version": "6.7.2",
   "description": "Official Sentry SDK for browsers",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/browser",
@@ -16,13 +16,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/core": "6.7.1",
-    "@sentry/types": "6.7.1",
-    "@sentry/utils": "6.7.1",
+    "@sentry/core": "6.7.2",
+    "@sentry/types": "6.7.2",
+    "@sentry/utils": "6.7.2",
     "tslib": "^1.9.3"
   },
   "devDependencies": {
-    "@sentry-internal/eslint-config-sdk": "6.7.1",
+    "@sentry-internal/eslint-config-sdk": "6.7.2",
     "@types/eslint": "^7.2.0",
     "@types/md5": "2.1.33",
     "btoa": "^1.2.1",

packages/browser/src/integrations/dedupe.ts

@@ -0,0 +1,201 @@
+import { Event, EventProcessor, Exception, Hub, Integration, StackFrame } from '@sentry/types';
+
+/** Deduplication filter */
+export class Dedupe implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'Dedupe';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = Dedupe.id;
+
+  /**
+   * @inheritDoc
+   */
+  private _previousEvent?: Event;
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {
+    addGlobalEventProcessor((currentEvent: Event) => {
+      const self = getCurrentHub().getIntegration(Dedupe);
+      if (self) {
+        // Juuust in case something goes wrong
+        try {
+          if (self._shouldDropEvent(currentEvent, self._previousEvent)) {
+            return null;
+          }
+        } catch (_oO) {
+          return (self._previousEvent = currentEvent);
+        }
+
+        return (self._previousEvent = currentEvent);
+      }
+      return currentEvent;
+    });
+  }
+
+  /** JSDoc */
+  private _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
+    if (!previousEvent) {
+      return false;
+    }
+
+    if (this._isSameMessageEvent(currentEvent, previousEvent)) {
+      return true;
+    }
+
+    if (this._isSameExceptionEvent(currentEvent, previousEvent)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /** JSDoc */
+  private _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {
+    const currentMessage = currentEvent.message;
+    const previousMessage = previousEvent.message;
+
+    // If neither event has a message property, they were both exceptions, so bail out
+    if (!currentMessage && !previousMessage) {
+      return false;
+    }
+
+    // If only one event has a stacktrace, but not the other one, they are not the same
+    if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
+      return false;
+    }
+
+    if (currentMessage !== previousMessage) {
+      return false;
+    }
+
+    if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /** JSDoc */
+  private _getFramesFromEvent(event: Event): StackFrame[] | undefined {
+    const exception = event.exception;
+
+    if (exception) {
+      try {
+        // @ts-ignore Object could be undefined
+        return exception.values[0].stacktrace.frames;
+      } catch (_oO) {
+        return undefined;
+      }
+    } else if (event.stacktrace) {
+      return event.stacktrace.frames;
+    }
+    return undefined;
+  }
+
+  /** JSDoc */
+  private _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
+    let currentFrames = this._getFramesFromEvent(currentEvent);
+    let previousFrames = this._getFramesFromEvent(previousEvent);
+
+    // If neither event has a stacktrace, they are assumed to be the same
+    if (!currentFrames && !previousFrames) {
+      return true;
+    }
+
+    // If only one event has a stacktrace, but not the other one, they are not the same
+    if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
+      return false;
+    }
+
+    currentFrames = currentFrames as StackFrame[];
+    previousFrames = previousFrames as StackFrame[];
+
+    // If number of frames differ, they are not the same
+    if (previousFrames.length !== currentFrames.length) {
+      return false;
+    }
+
+    // Otherwise, compare the two
+    for (let i = 0; i < previousFrames.length; i++) {
+      const frameA = previousFrames[i];
+      const frameB = currentFrames[i];
+
+      if (
+        frameA.filename !== frameB.filename ||
+        frameA.lineno !== frameB.lineno ||
+        frameA.colno !== frameB.colno ||
+        frameA.function !== frameB.function
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /** JSDoc */
+  private _getExceptionFromEvent(event: Event): Exception | undefined {
+    return event.exception && event.exception.values && event.exception.values[0];
+  }
+
+  /** JSDoc */
+  private _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
+    const previousException = this._getExceptionFromEvent(previousEvent);
+    const currentException = this._getExceptionFromEvent(currentEvent);
+
+    if (!previousException || !currentException) {
+      return false;
+    }
+
+    if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
+      return false;
+    }
+
+    if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /** JSDoc */
+  private _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
+    let currentFingerprint = currentEvent.fingerprint;
+    let previousFingerprint = previousEvent.fingerprint;
+
+    // If neither event has a fingerprint, they are assumed to be the same
+    if (!currentFingerprint && !previousFingerprint) {
+      return true;
+    }
+
+    // If only one event has a fingerprint, but not the other one, they are not the same
+    if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
+      return false;
+    }
+
+    currentFingerprint = currentFingerprint as string[];
+    previousFingerprint = previousFingerprint as string[];
+
+    // Otherwise, compare the two
+    try {
+      return !!(currentFingerprint.join('') === previousFingerprint.join(''));
+    } catch (_oO) {
+      return false;
+    }
+  }
+}

packages/browser/src/integrations/globalhandlers.ts

@@ -85,17 +85,18 @@ export class GlobalHandlers implements Integration {
         }
 
         const client = currentHub.getClient();
-        const event = isPrimitive(error)
-          ? this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)
-          : this._enhanceEventWithInitialFrame(
-              eventFromUnknownInput(error, undefined, {
-                attachStacktrace: client && client.getOptions().attachStacktrace,
-                rejection: false,
-              }),
-              data.url,
-              data.line,
-              data.column,
-            );
+        const event =
+          error === undefined && isString(data.msg)
+            ? this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)
+            : this._enhanceEventWithInitialFrame(
+                eventFromUnknownInput(error || data.msg, undefined, {
+                  attachStacktrace: client && client.getOptions().attachStacktrace,
+                  rejection: false,
+                }),
+                data.url,
+                data.line,
+                data.column,
+              );
 
         addExceptionMechanism(event, {
           handled: false,
@@ -188,12 +189,10 @@ export class GlobalHandlers implements Integration {
     let message = isErrorEvent(msg) ? msg.message : msg;
     let name;
 
-    if (isString(message)) {
-      const groups = message.match(ERROR_TYPES_RE);
-      if (groups) {
-        name = groups[1];
-        message = groups[2];
-      }
+    const groups = message.match(ERROR_TYPES_RE);
+    if (groups) {
+      name = groups[1];
+      message = groups[2];
     }
 
     const event = {

packages/browser/src/integrations/index.ts

@@ -3,3 +3,4 @@ export { TryCatch } from './trycatch';
 export { Breadcrumbs } from './breadcrumbs';
 export { LinkedErrors } from './linkederrors';
 export { UserAgent } from './useragent';
+export { Dedupe } from './dedupe';

packages/browser/src/sdk.ts

@@ -4,7 +4,7 @@ import { addInstrumentationHandler, getGlobalObject, logger, SyncPromise } from
 import { BrowserOptions } from './backend';
 import { BrowserClient } from './client';
 import { ReportDialogOptions, wrap as internalWrap } from './helpers';
-import { Breadcrumbs, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';
+import { Breadcrumbs, Dedupe, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';
 
 export const defaultIntegrations = [
   new CoreIntegrations.InboundFilters(),
@@ -13,6 +13,7 @@ export const defaultIntegrations = [
   new Breadcrumbs(),
   new GlobalHandlers(),
   new LinkedErrors(),
+  new Dedupe(),
   new UserAgent(),
 ];
 

packages/browser/src/transports/base.ts

@@ -76,7 +76,8 @@ export abstract class BaseTransport implements Transport {
      * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get
      */
     const limited = this._handleRateLimit(headers);
-    if (limited) logger.warn(`Too many requests, backing off until: ${this._disabledUntil(requestType)}`);
+    if (limited)
+      logger.warn(`Too many ${requestType} requests, backing off until: ${this._disabledUntil(requestType)}`);
 
     if (status === Status.Success) {
       resolve({ status });