[DI] Allow testing of primitives with instanceof (#5541)

Author: watson

packages/dd-trace/src/debugger/devtools_client/condition.js

@@ -33,6 +33,8 @@ const reservedWords = new Set([
   'NaN'
 ])
 
+const PRIMITIVE_TYPES = new Set(['string', 'number', 'bigint', 'boolean', 'undefined', 'symbol', 'null'])
+
 // TODO: Consider storing some of these functions on `process` so they can be reused across probes
 function compile (node) {
   if (node === null || typeof node === 'number' || typeof node === 'boolean' || typeof node === 'string') {
@@ -57,7 +59,11 @@ function compile (node) {
       }
     })()`
   } else if (type === 'instanceof') {
-    return `Function.prototype[Symbol.hasInstance].call(${assertIdentifier(value[1])}, ${compile(value[0])})`
+    if (isPrimitiveType(value[1])) {
+      return `(typeof ${compile(value[0])} === '${value[1]}')` // TODO: Is parenthesizing necessary?
+    } else {
+      return `Function.prototype[Symbol.hasInstance].call(${assertIdentifier(value[1])}, ${compile(value[0])})`
+    }
   } else if (type === 'ref') {
     if (value === '@it') {
       return '$dd_it'
@@ -149,6 +155,10 @@ function isString (variable) {
   return `(typeof ${variable} === 'string' || ${variable} instanceof String)`
 }
 
+function isPrimitiveType (type) {
+  return PRIMITIVE_TYPES.has(type)
+}
+
 function isIterableCollection (variable) {
   return `(${isArrayOrTypedArray(variable)} || ${isInstanceOfCoreType('Set', variable)} || ` +
     `${isInstanceOfCoreType('WeakSet', variable)})`

packages/dd-trace/test/debugger/devtools_client/condition-test-cases.js

@@ -621,8 +621,21 @@ const membershipAndMatching = [
 ]
 
 const typeAndDefinitionChecks = [
+  // Primitive types
+  [{ instanceof: [{ ref: 'foo' }, 'string'] }, { foo: 'foo' }, true],
+  [{ instanceof: [{ ref: 'foo' }, 'number'] }, { foo: 42 }, true],
+  [{ instanceof: [{ ref: 'foo' }, 'number'] }, { foo: '42' }, false],
+  [{ instanceof: [{ ref: 'foo' }, 'bigint'] }, { foo: 42n }, true],
+  [{ instanceof: [{ ref: 'foo' }, 'boolean'] }, { foo: false }, true],
+  [{ instanceof: [{ ref: 'foo' }, 'boolean'] }, { foo: 0 }, false],
+  [{ instanceof: [{ ref: 'foo' }, 'undefined'] }, { foo: undefined }, true],
+  [{ instanceof: [{ ref: 'foo' }, 'symbol'] }, { foo: Symbol('foo') }, true],
+  [{ instanceof: [{ ref: 'foo' }, 'null'] }, { foo: null }, false], // typeof null is 'object'
+
+  // Objects
   [{ instanceof: [{ ref: 'bar' }, 'Object'] }, { bar: {} }, true],
   [{ instanceof: [{ ref: 'bar' }, 'Error'] }, { bar: new Error() }, true],
+  [{ instanceof: [{ ref: 'bar' }, 'Error'] }, { bar: {} }, false],
   [{ instanceof: [{ ref: 'bar' }, 'CustomObject'] }, { bar: new CustomObject(), CustomObject }, true],
   [
     { instanceof: [{ ref: 'bar' }, 'HasInstanceSideEffect'] },

packages/dd-trace/test/debugger/devtools_client/condition.spec.js

@@ -100,12 +100,21 @@ function generateTestCaseName (ast, dataOrSuffix, expected) {
     ? JSON.stringify(dataOrSuffix)
     : Object
       .entries(dataOrSuffix)
-      .map(([key, value]) => `${key} = ${JSON.stringify(value)}`)
+      .map(([key, value]) => `${key} = ${serialize(value)}`)
       .join('; ')
 
   return `${JSON.stringify(ast)} + "${code}" = ${expected}`
 }
 
+function serialize (value) {
+  try {
+    return JSON.stringify(value)
+  } catch (e) {
+    // Some values are not serializable to JSON, so we fall back to stringification
+    return String(value)
+  }
+}
+
 function runWithDebug (fn, args = []) {
   try {
     return fn(...args)