fix(typedMap): Support converting circular/nested structures

typedMap(obj) would exceed the max stack size if it was given a circular or deeply nested data
structure. This change replaces circular references and levels of nesting above 10 with the strings
"[circular]" and "[max depth exceeded]" respectively.

Fixes #218

Author: bengourley

src/Bugsnag.js

@@ -379,7 +379,8 @@ const allowedMapObjectTypes = ['string', 'number', 'boolean'];
  * Convert an object into a structure with types suitable for serializing
  * across to native code.
  */
-const typedMap = function(map) {
+const typedMap = function(map, maxDepth = 10, depth = 0, seen = new Set()) {
+  seen.add(map)
   const output = {};
   for (const key in map) {
     if (!{}.hasOwnProperty.call(map, key)) continue;
@@ -390,7 +391,13 @@ const typedMap = function(map) {
     if (value == undefined || (typeof value === 'number' && isNaN(value))) {
       output[key] = {type: 'string', value: String(value)}
     } else if (typeof value === 'object') {
-      output[key] = {type: 'map', value: typedMap(value)};
+      if (seen.has(value)) {
+        output[key] = {type: 'string', value: '[circular]'}
+      } else if (depth === maxDepth) {
+        output[key] = {type: 'string', value: '[max depth exceeded]'}
+      } else {
+        output[key] = {type: 'map', value: typedMap(value, maxDepth, depth + 1, seen)};
+      }
     } else {
       const type = typeof value;
       if (allowedMapObjectTypes.includes(type)) {
@@ -402,3 +409,5 @@ const typedMap = function(map) {
   }
   return output;
 }
+
+export { typedMap };

src/__tests__/Bugsnag.test.js

@@ -356,3 +356,138 @@ test('{enable|disable}ConsoleBreadCrumbs(): gracefully handles serialization edg
   // switched off for the next test ¯\_(ツ)_/¯
   c.disableConsoleBreadCrumbs()
 })
+
+
+test('typedMap converts arrays, objects, strings and numbers', () => {
+  const { typedMap } = require('../Bugsnag')
+  expect(typedMap({
+    arr: [ 0, 1, 2 ],
+    obj: {
+      a: 'a',
+      b: 'b',
+      c: 'c'
+    },
+    x: 10,
+    y: 'str'
+  })).toEqual({
+    arr: {
+      type: 'map',
+      value: {
+        '0': { type: 'number', value: 0 },
+        '1': { type: 'number', value: 1 },
+        '2': { type: 'number', value: 2 }
+      }
+    },
+    obj: {
+      type: 'map',
+      value: {
+        a: { type: 'string', value: 'a' },
+        b: { type: 'string', value: 'b' },
+        c: { type: 'string', value: 'c' }
+      }
+    },
+    x: { type: 'number', value: 10 },
+    y: { type: 'string', value: 'str' }
+  })
+})
+
+test('typedMap handles circular structures', () => {
+  const { typedMap } = require('../Bugsnag')
+  const objA = {};
+  objA.ref = objA;
+
+  // this tests the top level object being referred to as a node
+  expect(typedMap(objA)).toEqual({ ref: { type: 'string', value: '[circular]' } })
+
+  const objB = {};
+  objB.leafA = {};
+  objB.leafB = {};
+  objB.leafA.ref = objB.leafB
+  objB.leafB.ref = objB.leafA
+
+  // this tests subtrees referring to eachother
+  expect(typedMap(objB)).toEqual({
+    leafA: {
+      type: 'map',
+      value: {
+        ref: {
+          type: 'map',
+          value: {
+            ref: { type: 'string', value: '[circular]' }
+          }
+        }
+      }
+    },
+    leafB: { type: 'string', value: '[circular]' }
+  })
+})
+
+test('typedMap handles deep nesting', () => {
+  const { typedMap } = require('../Bugsnag')
+  const nesty = {
+    zero: {
+      one: {
+        two: {
+          three: {
+            four: {
+              five: { six: { seven: { eight: { nine: { ten: { eleven: 'TOO_DEEP!' } } } } } }
+            }
+          }
+        }
+      }
+    }
+  };
+  expect(typedMap(nesty)).toEqual({
+    zero: {
+      type: 'map',
+      value: {
+        one: {
+          type: 'map',
+          value: {
+            two: {
+              type: 'map',
+              value: {
+                three: {
+                  type: 'map',
+                  value: {
+                    four: {
+                      type: 'map',
+                      value: {
+                        five: {
+                          type: 'map',
+                          value: {
+                            six: {
+                              type: 'map',
+                              value: {
+                                seven: {
+                                  type: 'map',
+                                  value: {
+                                    eight: {
+                                      type: 'map',
+                                      value: {
+                                        nine: {
+                                          type: 'map',
+                                          value: {
+                                            ten: { type: 'string', value: '[max depth exceeded]' }
+                                          }
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+})