ref: Create safe isInstanceOf util (#2331)

* ref: Create safe isInstanceOf util

* test: Add isInstanceOf tests

* misc: Changelog

Author: kamilogorek

CHANGELOG.md

@@ -7,6 +7,7 @@
 - [browser] feat: Refactor breadcrumbs integration to allow for custom handlers
 - [utils] feat: Move insturment to utils
 - [apm] feat: Add `@sentry/apm` package
+- [utils] feat: Add `isInstanceOf` util for safety reasons
 
 ## 5.9.1
 

packages/apm/src/hubextensions.ts

@@ -1,5 +1,6 @@
 import { getMainCarrier, Hub } from '@sentry/hub';
 import { SpanContext } from '@sentry/types';
+import { isInstanceOf } from '@sentry/utils';
 
 import { Span } from './span';
 
@@ -8,7 +9,7 @@ import { Span } from './span';
  * @param span value to check
  */
 function isSpanInstance(span: unknown): span is Span {
-  return span instanceof Span;
+  return isInstanceOf(span, Span);
 }
 
 /** Returns all trace headers that are currently on the top scope. */

packages/apm/src/span.ts

@@ -2,7 +2,7 @@
 
 import { getCurrentHub, Hub } from '@sentry/hub';
 import { Span as SpanInterface, SpanContext, SpanStatus } from '@sentry/types';
-import { logger, timestampWithMs, uuid4 } from '@sentry/utils';
+import { isInstanceOf, logger, timestampWithMs, uuid4 } from '@sentry/utils';
 
 // TODO: Should this be exported?
 export const TRACEPARENT_REGEXP = new RegExp(
@@ -117,8 +117,8 @@ export class Span implements SpanInterface, SpanContext {
   public spanRecorder?: SpanRecorder;
 
   public constructor(spanContext?: SpanContext, hub?: Hub) {
-    if (hub instanceof Hub) {
-      this._hub = hub;
+    if (isInstanceOf(hub, Hub)) {
+      this._hub = hub as Hub;
     }
 
     if (!spanContext) {

packages/browser/src/integrations/linkederrors.ts

@@ -1,5 +1,6 @@
 import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';
 import { Event, EventHint, Exception, ExtendedError, Integration } from '@sentry/types';
+import { isInstanceOf } from '@sentry/utils';
 
 import { exceptionFromStacktrace } from '../parsers';
 import { computeStackTrace } from '../tracekit';
@@ -54,10 +55,10 @@ export class LinkedErrors implements Integration {
    * @inheritDoc
    */
   private _handler(event: Event, hint?: EventHint): Event | null {
-    if (!event.exception || !event.exception.values || !hint || !(hint.originalException instanceof Error)) {
+    if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
       return event;
     }
-    const linkedErrors = this._walkErrorTree(hint.originalException, this._key);
+    const linkedErrors = this._walkErrorTree(hint.originalException as ExtendedError, this._key);
     event.exception.values = [...linkedErrors, ...event.exception.values];
     return event;
   }
@@ -66,7 +67,7 @@ export class LinkedErrors implements Integration {
    * @inheritDoc
    */
   private _walkErrorTree(error: ExtendedError, key: string, stack: Exception[] = []): Exception[] {
-    if (!(error[key] instanceof Error) || stack.length + 1 >= this._limit) {
+    if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {
       return stack;
     }
     const stacktrace = computeStackTrace(error[key]);

packages/integrations/src/ember.ts

@@ -1,5 +1,5 @@
 import { EventProcessor, Hub, Integration } from '@sentry/types';
-import { getGlobalObject, logger } from '@sentry/utils';
+import { getGlobalObject, isInstanceOf, logger } from '@sentry/utils';
 
 /** JSDoc */
 export class Ember implements Integration {
@@ -55,7 +55,7 @@ export class Ember implements Integration {
       (reason: any): void => {
         if (getCurrentHub().getIntegration(Ember)) {
           getCurrentHub().withScope(scope => {
-            if (reason instanceof Error) {
+            if (isInstanceOf(reason, Error)) {
               scope.setExtra('context', 'Unhandled Promise error detected');
               getCurrentHub().captureException(reason, { originalException: reason });
             } else {

packages/node/src/integrations/linkederrors.ts

@@ -1,6 +1,6 @@
 import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';
 import { Event, EventHint, Exception, ExtendedError, Integration } from '@sentry/types';
-import { SyncPromise } from '@sentry/utils';
+import { isInstanceOf, SyncPromise } from '@sentry/utils';
 
 import { getExceptionFromError } from '../parsers';
 
@@ -53,12 +53,12 @@ export class LinkedErrors implements Integration {
    * @inheritDoc
    */
   public handler(event: Event, hint?: EventHint): PromiseLike<Event> {
-    if (!event.exception || !event.exception.values || !hint || !(hint.originalException instanceof Error)) {
+    if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
       return SyncPromise.resolve(event);
     }
 
     return new SyncPromise<Event>(resolve => {
-      this.walkErrorTree(hint.originalException as ExtendedError, this._key)
+      this.walkErrorTree(hint.originalException as Error, this._key)
         .then((linkedErrors: Exception[]) => {
           if (event && event.exception && event.exception.values) {
             event.exception.values = [...linkedErrors, ...event.exception.values];
@@ -75,7 +75,7 @@ export class LinkedErrors implements Integration {
    * @inheritDoc
    */
   public walkErrorTree(error: ExtendedError, key: string, stack: Exception[] = []): PromiseLike<Exception[]> {
-    if (!(error[key] instanceof Error) || stack.length + 1 >= this._limit) {
+    if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {
       return SyncPromise.resolve(stack);
     }
     return new SyncPromise<Exception[]>((resolve, reject) => {

packages/utils/src/instrument.ts

@@ -2,7 +2,7 @@
 
 import { WrappedFunction } from '@sentry/types';
 
-import { isString } from './is';
+import { isInstanceOf, isString } from './is';
 import { logger } from './logger';
 import { getFunctionName, getGlobalObject } from './misc';
 import { fill } from './object';
@@ -172,7 +172,7 @@ interface SentryWrappedXMLHttpRequest extends XMLHttpRequest {
 
 /** Extract `method` from fetch call arguments */
 function getFetchMethod(fetchArgs: any[] = []): string {
-  if ('Request' in global && fetchArgs[0] instanceof Request && fetchArgs[0].method) {
+  if ('Request' in global && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {
     return String(fetchArgs[0].method).toUpperCase();
   }
   if (fetchArgs[1] && fetchArgs[1].method) {
@@ -186,7 +186,7 @@ function getFetchUrl(fetchArgs: any[] = []): string {
   if (typeof fetchArgs[0] === 'string') {
     return fetchArgs[0];
   }
-  if ('Request' in global && fetchArgs[0] instanceof Request) {
+  if ('Request' in global && isInstanceOf(fetchArgs[0], Request)) {
     return fetchArgs[0].url;
   }
   return String(fetchArgs[0]);

packages/utils/src/is.ts

@@ -14,7 +14,7 @@ export function isError(wat: any): boolean {
     case '[object DOMException]':
       return true;
     default:
-      return wat instanceof Error;
+      return isInstanceOf(wat, Error);
   }
 }
 
@@ -93,7 +93,7 @@ export function isPlainObject(wat: any): boolean {
  */
 export function isEvent(wat: any): boolean {
   // tslint:disable-next-line:strict-type-predicates
-  return typeof Event !== 'undefined' && wat instanceof Event;
+  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);
 }
 
 /**
@@ -105,7 +105,7 @@ export function isEvent(wat: any): boolean {
  */
 export function isElement(wat: any): boolean {
   // tslint:disable-next-line:strict-type-predicates
-  return typeof Element !== 'undefined' && wat instanceof Element;
+  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);
 }
 
 /**
@@ -140,3 +140,19 @@ export function isSyntheticEvent(wat: any): boolean {
   // tslint:disable-next-line:no-unsafe-any
   return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;
 }
+/**
+ * Checks whether given value's type is an instance of provided constructor.
+ * {@link isInstanceOf}.
+ *
+ * @param wat A value to be checked.
+ * @param base A constructor to be used in a check.
+ * @returns A boolean representing the result.
+ */
+export function isInstanceOf(wat: any, base: any): boolean {
+  try {
+    // tslint:disable-next-line:no-unsafe-any
+    return wat instanceof base;
+  } catch (_e) {
+    return false;
+  }
+}

packages/utils/src/object.ts

@@ -1,6 +1,6 @@
 import { ExtendedError, WrappedFunction } from '@sentry/types';
 
-import { isElement, isError, isEvent, isPrimitive, isSyntheticEvent } from './is';
+import { isElement, isError, isEvent, isInstanceOf, isPrimitive, isSyntheticEvent } from './is';
 import { Memo } from './memo';
 import { getFunctionName, htmlTreeAsString } from './misc';
 import { truncate } from './string';
@@ -135,7 +135,7 @@ function getWalkSource(
     }
 
     // tslint:disable-next-line:strict-type-predicates
-    if (typeof CustomEvent !== 'undefined' && value instanceof CustomEvent) {
+    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {
       source.detail = event.detail;
     }
 

packages/utils/test/is.test.ts

@@ -1,4 +1,4 @@
-import { isDOMError, isDOMException, isError, isErrorEvent, isPrimitive, isThenable } from '../src/is';
+import { isDOMError, isDOMException, isError, isErrorEvent, isInstanceOf, isPrimitive, isThenable } from '../src/is';
 import { supportsDOMError, supportsDOMException, supportsErrorEvent } from '../src/supports';
 import { SyncPromise } from '../src/syncpromise';
 
@@ -89,3 +89,24 @@ describe('isThenable()', () => {
     expect(isThenable(new Date())).toEqual(false);
   });
 });
+
+describe('isInstanceOf()', () => {
+  test('should work as advertised', () => {
+    function Foo(): void {
+      /* no-empty */
+    }
+    expect(isInstanceOf(new Error('wat'), Error)).toEqual(true);
+    expect(isInstanceOf(new Date(), Date)).toEqual(true);
+    expect(isInstanceOf(new Foo(), Foo)).toEqual(true);
+
+    expect(isInstanceOf(new Error('wat'), Foo)).toEqual(false);
+    expect(isInstanceOf(new Date('wat'), Error)).toEqual(false);
+  });
+
+  test('should not break with incorrect input', () => {
+    expect(isInstanceOf(new Error('wat'), 1)).toEqual(false);
+    expect(isInstanceOf(new Error('wat'), 'wat')).toEqual(false);
+    expect(isInstanceOf(new Error('wat'), null)).toEqual(false);
+    expect(isInstanceOf(new Error('wat'), undefined)).toEqual(false);
+  });
+});