fix: DH-20255 Limit maximum depth to serialize redux log data (#2544)

Follow up PR to #2531
which failed testing, with an error from `JSON.stringify()` of
`RangeError: Invalid string length`.

These errors are caused by linked structures such as a Java
LinkedHashMap that's included in the Redux data in various API related
keys. We use the blacklist to filter out keys containing these
structures, but these keys are not stable and will need to be constantly
updated to prevent the log export from outright failing.

To preemptively deal with this, the maximum depth to serialize to can be
limited in the
[safe-stable-stringify](https://www.npmjs.com/package/safe-stable-stringify)
library to avoid linked structures from blowing up the log size. With no
blacklist entries, the exported log size is only `1.2MB`.

With an updated blacklist, exporting the logs with or without the limit
both yield log files of almost the exact same size, meaning that no
useful data has been lost by limiting the depth. However, I'm open to
suggestions to the default depth to serialize to, or whether it should
be optional to have a limit on the depth instead of mandating a limit
(`Infinity` is not accepted by the library).

Author: ericlln

packages/log/src/LogExport.test.ts

@@ -172,4 +172,27 @@ describe('getReduxDataString', () => {
     const result = getReduxDataString(reduxData, [['*']]);
     expect(result).toBe('{}');
   });
+
+  it('should respect maximum depth', () => {
+    const reduxData = {
+      key1: {
+        key2: {
+          key3: 'too deep',
+        },
+        key4: ['too deep'],
+      },
+    };
+    const result = getReduxDataString(reduxData, [], 2);
+    const expected = JSON.stringify(
+      {
+        key1: {
+          key2: '[Object]',
+          key4: '[Array]',
+        },
+      },
+      null,
+      2
+    );
+    expect(result).toBe(expected);
+  });
 });

packages/log/src/LogExport.ts

@@ -1,5 +1,5 @@
 import JSZip from 'jszip';
-import stringify from 'safe-stable-stringify';
+import { configure } from 'safe-stable-stringify';
 import type LogHistory from './LogHistory';
 
 // List of objects to blacklist
@@ -14,11 +14,19 @@ export const DEFAULT_PATH_BLACKLIST: string[][] = [
   ['dashboardData', '*', 'openedMap'],
   ['draftManager', 'draftStorage'],
   ['layoutStorage'],
+  ['storage'],
+
+  // Below are confirmed enterprise specific keys, and will be moved in DH-20410
   ['schemaService', 'client'],
+  ['schemaService', 'clientUtils'],
   ['schemaService', 'schemaStorage'],
-  ['storage'],
+  ['corePlusManager', 'dheClient'],
+  ['dheClient'],
 ];
 
+// The default maximum depth to serialize to in the redux data
+const DEFAULT_MAXIMUM_DEPTH = 10;
+
 function stringifyReplacer(blacklist: string[][]) {
   // modified from:
   // https://stackoverflow.com/questions/61681176/json-stringify-replacer-how-to-get-full-path
@@ -63,8 +71,15 @@ function isOnBlackList(currPath: string[], blacklist: string[][]): boolean {
 
 export function getReduxDataString(
   reduxData: Record<string, unknown>,
-  blacklist: string[][] = []
+  blacklist: string[][] = [],
+  maximumDepth: number = DEFAULT_MAXIMUM_DEPTH
 ): string {
+  // Limit the maximum depth to prevent linked structures from blowing up the log size
+  // All objects at the maximum depth are replaced with "[Object]" or "[Array]"
+  const stringify = configure({
+    maximumDepth,
+  });
+
   return (
     // Using safe-stable-stringify which handles circular references and BigInt
     // All circular references are replaced with "[Circular]", and BigInt values are converted to a number
@@ -102,14 +117,16 @@ function formatDate(date: Date): string {
  * @param reduxData Redux data to include in the redux.json file
  * @param blacklist List of JSON paths to blacklist in redux data. A JSON path is a list representing the path to that value (e.g. client.data would be `['client', 'data']`). Wildcards (*) are accepted in the path.
  * @param fileNamePrefix The zip file name without the .zip extension. Ex: test will be saved as test.zip
+ * @param maximumDepth The maximum depth to serialize the redux data to. Objects at the maximum depth will be replaced with "[Object]" or "[Array]".
  * @returns A promise that resolves successfully if the log archive is created and downloaded successfully, rejected if there's an error
  */
 export async function exportLogs(
   logHistory: LogHistory,
   metadata?: Record<string, unknown>,
   reduxData?: Record<string, unknown>,
   blacklist: string[][] = DEFAULT_PATH_BLACKLIST,
-  fileNamePrefix = `${formatDate(new Date())}_support_logs`
+  fileNamePrefix = `${formatDate(new Date())}_support_logs`,
+  maximumDepth: number = DEFAULT_MAXIMUM_DEPTH
 ): Promise<void> {
   const zip = new JSZip();
   const folder = zip.folder(fileNamePrefix) as JSZip;
@@ -118,7 +135,10 @@ export async function exportLogs(
     folder.file('metadata.json', getFormattedMetadata(metadata));
   }
   if (reduxData != null) {
-    folder.file('redux.json', getReduxDataString(reduxData, blacklist));
+    folder.file(
+      'redux.json',
+      getReduxDataString(reduxData, blacklist, maximumDepth)
+    );
   }
 
   const blob = await zip.generateAsync({ type: 'blob' });