Skip to content

Commit 502e317

Browse files
JonasBaJonasBa
authored
Merge branch 'master' into jb/bundle/drop-severity
2 parents 16714f9 + edf1be9 commit 502e317

File tree

20 files changed

+319
-296
lines changed

20 files changed

+319
-296
lines changed

‎packages/browser/src/integrations/dedupe.ts‎

Lines changed: 117 additions & 117 deletions
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,7 @@ export class Dedupe implements Integration {
2727
if (self) {
2828
// Juuust in case something goes wrong
2929
try {
30-
if (self._shouldDropEvent(currentEvent, self._previousEvent)) {
30+
if (_shouldDropEvent(currentEvent, self._previousEvent)) {
3131
logger.warn(`Event dropped due to being a duplicate of previously captured event.`);
3232
return null;
3333
}
@@ -40,164 +40,164 @@ export class Dedupe implements Integration {
4040
return currentEvent;
4141
});
4242
}
43+
}
4344

44-
/** JSDoc */
45-
private _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
46-
if (!previousEvent) {
47-
return false;
48-
}
49-
50-
if (this._isSameMessageEvent(currentEvent, previousEvent)) {
51-
return true;
52-
}
53-
54-
if (this._isSameExceptionEvent(currentEvent, previousEvent)) {
55-
return true;
56-
}
57-
45+
/** JSDoc */
46+
function _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
47+
if (!previousEvent) {
5848
return false;
5949
}
6050

61-
/** JSDoc */
62-
private _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {
63-
const currentMessage = currentEvent.message;
64-
const previousMessage = previousEvent.message;
51+
if (_isSameMessageEvent(currentEvent, previousEvent)) {
52+
return true;
53+
}
6554

66-
// If neither event has a message property, they were both exceptions, so bail out
67-
if (!currentMessage && !previousMessage) {
68-
return false;
69-
}
55+
if (_isSameExceptionEvent(currentEvent, previousEvent)) {
56+
return true;
57+
}
7058

71-
// If only one event has a stacktrace, but not the other one, they are not the same
72-
if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
73-
return false;
74-
}
59+
return false;
60+
}
7561

76-
if (currentMessage !== previousMessage) {
77-
return false;
78-
}
62+
/** JSDoc */
63+
function _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {
64+
const currentMessage = currentEvent.message;
65+
const previousMessage = previousEvent.message;
7966

80-
if (!this._isSameFingerprint(currentEvent, previousEvent)) {
81-
return false;
82-
}
67+
// If neither event has a message property, they were both exceptions, so bail out
68+
if (!currentMessage && !previousMessage) {
69+
return false;
70+
}
8371

84-
if (!this._isSameStacktrace(currentEvent, previousEvent)) {
85-
return false;
86-
}
72+
// If only one event has a stacktrace, but not the other one, they are not the same
73+
if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
74+
return false;
75+
}
8776

88-
return true;
77+
if (currentMessage !== previousMessage) {
78+
return false;
8979
}
9080

91-
/** JSDoc */
92-
private _getFramesFromEvent(event: Event): StackFrame[] | undefined {
93-
const exception = event.exception;
81+
if (!_isSameFingerprint(currentEvent, previousEvent)) {
82+
return false;
83+
}
9484

95-
if (exception) {
96-
try {
97-
// @ts-ignore Object could be undefined
98-
return exception.values[0].stacktrace.frames;
99-
} catch (_oO) {
100-
return undefined;
101-
}
102-
} else if (event.stacktrace) {
103-
return event.stacktrace.frames;
104-
}
105-
return undefined;
85+
if (!_isSameStacktrace(currentEvent, previousEvent)) {
86+
return false;
10687
}
10788

108-
/** JSDoc */
109-
private _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
110-
let currentFrames = this._getFramesFromEvent(currentEvent);
111-
let previousFrames = this._getFramesFromEvent(previousEvent);
89+
return true;
90+
}
11291

113-
// If neither event has a stacktrace, they are assumed to be the same
114-
if (!currentFrames && !previousFrames) {
115-
return true;
116-
}
92+
/** JSDoc */
93+
function _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
94+
const previousException = _getExceptionFromEvent(previousEvent);
95+
const currentException = _getExceptionFromEvent(currentEvent);
11796

118-
// If only one event has a stacktrace, but not the other one, they are not the same
119-
if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
120-
return false;
121-
}
97+
if (!previousException || !currentException) {
98+
return false;
99+
}
122100

123-
currentFrames = currentFrames as StackFrame[];
124-
previousFrames = previousFrames as StackFrame[];
101+
if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
102+
return false;
103+
}
125104

126-
// If number of frames differ, they are not the same
127-
if (previousFrames.length !== currentFrames.length) {
128-
return false;
129-
}
105+
if (!_isSameFingerprint(currentEvent, previousEvent)) {
106+
return false;
107+
}
130108

131-
// Otherwise, compare the two
132-
for (let i = 0; i < previousFrames.length; i++) {
133-
const frameA = previousFrames[i];
134-
const frameB = currentFrames[i];
135-
136-
if (
137-
frameA.filename !== frameB.filename ||
138-
frameA.lineno !== frameB.lineno ||
139-
frameA.colno !== frameB.colno ||
140-
frameA.function !== frameB.function
141-
) {
142-
return false;
143-
}
144-
}
109+
if (!_isSameStacktrace(currentEvent, previousEvent)) {
110+
return false;
111+
}
112+
113+
return true;
114+
}
115+
116+
/** JSDoc */
117+
function _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
118+
let currentFrames = _getFramesFromEvent(currentEvent);
119+
let previousFrames = _getFramesFromEvent(previousEvent);
145120

121+
// If neither event has a stacktrace, they are assumed to be the same
122+
if (!currentFrames && !previousFrames) {
146123
return true;
147124
}
148125

149-
/** JSDoc */
150-
private _getExceptionFromEvent(event: Event): Exception | undefined {
151-
return event.exception && event.exception.values && event.exception.values[0];
126+
// If only one event has a stacktrace, but not the other one, they are not the same
127+
if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
128+
return false;
152129
}
153130

154-
/** JSDoc */
155-
private _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
156-
const previousException = this._getExceptionFromEvent(previousEvent);
157-
const currentException = this._getExceptionFromEvent(currentEvent);
131+
currentFrames = currentFrames as StackFrame[];
132+
previousFrames = previousFrames as StackFrame[];
158133

159-
if (!previousException || !currentException) {
160-
return false;
161-
}
134+
// If number of frames differ, they are not the same
135+
if (previousFrames.length !== currentFrames.length) {
136+
return false;
137+
}
162138

163-
if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
139+
// Otherwise, compare the two
140+
for (let i = 0; i < previousFrames.length; i++) {
141+
const frameA = previousFrames[i];
142+
const frameB = currentFrames[i];
143+
144+
if (
145+
frameA.filename !== frameB.filename ||
146+
frameA.lineno !== frameB.lineno ||
147+
frameA.colno !== frameB.colno ||
148+
frameA.function !== frameB.function
149+
) {
164150
return false;
165151
}
152+
}
166153

167-
if (!this._isSameFingerprint(currentEvent, previousEvent)) {
168-
return false;
169-
}
154+
return true;
155+
}
170156

171-
if (!this._isSameStacktrace(currentEvent, previousEvent)) {
172-
return false;
173-
}
157+
/** JSDoc */
158+
function _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
159+
let currentFingerprint = currentEvent.fingerprint;
160+
let previousFingerprint = previousEvent.fingerprint;
174161

162+
// If neither event has a fingerprint, they are assumed to be the same
163+
if (!currentFingerprint && !previousFingerprint) {
175164
return true;
176165
}
177166

178-
/** JSDoc */
179-
private _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
180-
let currentFingerprint = currentEvent.fingerprint;
181-
let previousFingerprint = previousEvent.fingerprint;
167+
// If only one event has a fingerprint, but not the other one, they are not the same
168+
if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
169+
return false;
170+
}
171+
172+
currentFingerprint = currentFingerprint as string[];
173+
previousFingerprint = previousFingerprint as string[];
182174

183-
// If neither event has a fingerprint, they are assumed to be the same
184-
if (!currentFingerprint && !previousFingerprint) {
185-
return true;
186-
}
175+
// Otherwise, compare the two
176+
try {
177+
return !!(currentFingerprint.join('') === previousFingerprint.join(''));
178+
} catch (_oO) {
179+
return false;
180+
}
181+
}
187182

188-
// If only one event has a fingerprint, but not the other one, they are not the same
189-
if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
190-
return false;
191-
}
183+
/** JSDoc */
184+
function _getExceptionFromEvent(event: Event): Exception | undefined {
185+
return event.exception && event.exception.values && event.exception.values[0];
186+
}
192187

193-
currentFingerprint = currentFingerprint as string[];
194-
previousFingerprint = previousFingerprint as string[];
188+
/** JSDoc */
189+
function _getFramesFromEvent(event: Event): StackFrame[] | undefined {
190+
const exception = event.exception;
195191

196-
// Otherwise, compare the two
192+
if (exception) {
197193
try {
198-
return !!(currentFingerprint.join('') === previousFingerprint.join(''));
194+
// @ts-ignore Object could be undefined
195+
return exception.values[0].stacktrace.frames;
199196
} catch (_oO) {
200-
return false;
197+
return undefined;
201198
}
199+
} else if (event.stacktrace) {
200+
return event.stacktrace.frames;
202201
}
202+
return undefined;
203203
}

‎packages/browser/src/integrations/trycatch.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -232,7 +232,7 @@ export class TryCatch implements Integration {
232232
*/
233233
const wrappedEventHandler = (fn as unknown) as WrappedFunction;
234234
try {
235-
const originalEventHandler = wrappedEventHandler?.__sentry_wrapped__;
235+
const originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;
236236
if (originalEventHandler) {
237237
originalRemoveEventListener.call(this, eventName, originalEventHandler, options);
238238
}

‎packages/browser/src/integrations/useragent.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -28,12 +28,12 @@ export class UserAgent implements Integration {
2828
}
2929

3030
// grab as much info as exists and add it to the event
31-
const url = event.request?.url || global.location?.href;
31+
const url = (event.request && event.request.url) || (global.location && global.location.href);
3232
const { referrer } = global.document || {};
3333
const { userAgent } = global.navigator || {};
3434

3535
const headers = {
36-
...event.request?.headers,
36+
...(event.request && event.request.headers),
3737
...(referrer && { Referer: referrer }),
3838
...(userAgent && { 'User-Agent': userAgent }),
3939
};

‎packages/browser/src/transports/utils.ts‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -58,13 +58,14 @@ export function getNativeFetchImplementation(): FetchImpl {
5858
const document = global.document;
5959
let fetchImpl = global.fetch;
6060
// eslint-disable-next-line deprecation/deprecation
61-
if (typeof document?.createElement === `function`) {
61+
if (document && typeof document.createElement === `function`) {
6262
try {
6363
const sandbox = document.createElement('iframe');
6464
sandbox.hidden = true;
6565
document.head.appendChild(sandbox);
66-
if (sandbox.contentWindow?.fetch) {
67-
fetchImpl = sandbox.contentWindow.fetch;
66+
const contentWindow = sandbox.contentWindow;
67+
if (contentWindow && contentWindow.fetch) {
68+
fetchImpl = contentWindow.fetch;
6869
}
6970
document.head.removeChild(sandbox);
7071
} catch (e) {

‎packages/core/src/baseclient.ts‎

Lines changed: 13 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -150,7 +150,7 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
150150
*/
151151
public captureEvent(event: Event, hint?: EventHint, scope?: Scope): string | undefined {
152152
// ensure we haven't captured this very object before
153-
if (hint?.originalException && checkOrSetAlreadyCaught(hint.originalException)) {
153+
if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {
154154
logger.log(ALREADY_SEEN_ERROR);
155155
return;
156156
}
@@ -523,6 +523,15 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
523523
const { beforeSend, sampleRate } = this.getOptions();
524524
const transport = this.getTransport();
525525

526+
type RecordLostEvent = NonNullable<Transport['recordLostEvent']>;
527+
type RecordLostEventParams = Parameters<RecordLostEvent>;
528+
529+
function recordLostEvent(outcome: RecordLostEventParams[0], category: RecordLostEventParams[1]): void {
530+
if (transport.recordLostEvent) {
531+
transport.recordLostEvent(outcome, category);
532+
}
533+
}
534+
526535
if (!this._isEnabled()) {
527536
return SyncPromise.reject(new SentryError('SDK not enabled, will not capture event.'));
528537
}
@@ -532,7 +541,7 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
532541
// 0.0 === 0% events are sent
533542
// Sampling for transaction happens somewhere else
534543
if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {
535-
transport.recordLostEvent?.(Outcome.SampleRate, 'event');
544+
recordLostEvent(Outcome.SampleRate, 'event');
536545
return SyncPromise.reject(
537546
new SentryError(
538547
`Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,
@@ -543,7 +552,7 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
543552
return this._prepareEvent(event, scope, hint)
544553
.then(prepared => {
545554
if (prepared === null) {
546-
transport.recordLostEvent?.(Outcome.EventProcessor, event.type || 'event');
555+
recordLostEvent(Outcome.EventProcessor, event.type || 'event');
547556
throw new SentryError('An event processor returned null, will not send event.');
548557
}
549558

@@ -557,7 +566,7 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
557566
})
558567
.then(processedEvent => {
559568
if (processedEvent === null) {
560-
transport.recordLostEvent?.(Outcome.BeforeSend, event.type || 'event');
569+
recordLostEvent(Outcome.BeforeSend, event.type || 'event');
561570
throw new SentryError('`beforeSend` returned `null`, will not send event.');
562571
}
563572

‎packages/core/src/integrations/inboundfilters.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -194,7 +194,7 @@ export class InboundFilters implements Integration {
194194
for (let i = frames.length - 1; i >= 0; i--) {
195195
const frame = frames[i];
196196

197-
if (frame?.filename !== '<anonymous>' && frame?.filename !== '[native code]') {
197+
if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {
198198
return frame.filename || null;
199199
}
200200
}

0 commit comments

Comments
 (0)