feat(heap-analysis): support analyzing js source code strings in the heap string analysis

Summary: This diff adds logic in `memlab analyze string` command so that it can extract and analyze JS code strings in the heap snapshots.

Reviewed By: twobassdrum

Differential Revision: D89912914

fbshipit-source-id: 57a89778690e5b943aa931574723226ac0115502

Author: JacksonGL

packages/core/src/lib/Utils.ts

@@ -837,6 +837,29 @@ function isSlicedStringNode(node: IHeapNode): boolean {
   return node.type === 'sliced string';
 }
 
+function isCompiledCodeNode(node: IHeapNode): boolean {
+  return node.type === 'code';
+}
+
+function isJSSourceStringNode(node: IHeapNode): boolean {
+  if (!utils.isStringNode(node) || utils.isSlicedStringNode(node)) {
+    return false;
+  }
+
+  let isSourceString = false;
+
+  node.forEachReferrer((referrerEdge: IHeapEdge) => {
+    if (
+      referrerEdge.name_or_index === 'source' &&
+      isCompiledCodeNode(referrerEdge.fromNode)
+    ) {
+      isSourceString = true;
+      return {stop: true};
+    }
+  });
+  return isSourceString;
+}
+
 function getStringNodeValue(node: Optional<IHeapNode>): string {
   if (!node) {
     return '';
@@ -2426,6 +2449,7 @@ export default {
   hasReactEdges,
   isAlternateNode,
   isBlinkRootNode,
+  isCompiledCodeNode,
   isCppRootsNode,
   isDOMInternalNode,
   isDOMNodeIncomplete,
@@ -2442,6 +2466,7 @@ export default {
   isHTMLDocumentNode,
   isHermesInternalObject,
   isHostRoot,
+  isJSSourceStringNode,
   isMeaningfulEdge,
   isMeaningfulNode,
   isNodeDominatedByDeletionsArray,

packages/heap-analysis/src/plugins/StringAnalysis.ts

@@ -8,7 +8,7 @@
  * @oncall memory_lab
  */
 
-import type {IHeapSnapshot, IHeapNode} from '@memlab/core';
+import type {IHeapSnapshot, IHeapNode, Optional} from '@memlab/core';
 import type {AnalyzeSnapshotResult, HeapAnalysisOptions} from '../PluginUtils';
 
 import chalk from 'chalk';
@@ -36,6 +36,8 @@ type StringPatternRecord = {
   dupSize: number;
 };
 
+type HeapNodeFilter = (node: IHeapNode) => boolean;
+
 /**
  * duplicated string pattern information
  */
@@ -162,13 +164,20 @@ export default class StringAnalysis extends BaseAnalysis {
   async process(options: HeapAnalysisOptions): Promise<void> {
     const snapshot = await pluginUtils.loadHeapSnapshot(options);
     const stringMap = this.getPreprocessedStringMap(snapshot);
-    this.calculateStringPatternsStatistics(stringMap);
+    const sourceCodeStringMap = this.getPreprocessedStringMap(
+      snapshot,
+      utils.isJSSourceStringNode,
+    );
+    this.calculateStringPatternsStatistics(stringMap, sourceCodeStringMap);
     this.calculateTopDuplicatedStringsInCount(stringMap);
     this.calculateTopDuplicatedStringsInSize(stringMap);
     this.print();
   }
 
-  private getPreprocessedStringMap(snapshot: IHeapSnapshot): StringMap {
+  private getPreprocessedStringMap(
+    snapshot: IHeapSnapshot,
+    filter: Optional<HeapNodeFilter> = null,
+  ): StringMap {
     info.overwrite('building string map...');
     const stringMap = Object.create(null);
 
@@ -177,6 +186,9 @@ export default class StringAnalysis extends BaseAnalysis {
       if (StringAnalysis.shouldIgnoreNode(node)) {
         return;
       }
+      if (filter && filter(node) === false) {
+        return;
+      }
 
       const strValue = utils.getStringNodeValue(node);
       stringMap[strValue] = stringMap[strValue] || {
@@ -236,32 +248,44 @@ export default class StringAnalysis extends BaseAnalysis {
     );
   }
 
-  private calculateStringPatternsStatistics(stringMap: StringMap): void {
+  private calculateStringPatternsStatistics(
+    stringMap: StringMap,
+    sourceStringMap: StringMap,
+  ): void {
     info.overwrite('calculating statistics for specified string patterns...');
 
     const strPatternStat = Object.create(null);
+    function aggregatePatternStat(patternName: string, record: StringRecord) {
+      strPatternStat[patternName] = strPatternStat[patternName] || {
+        n: 0,
+        dupN: 0,
+        size: 0,
+        dupSize: 0,
+      };
+      const item = strPatternStat[patternName];
+      item.n += record.n;
+      item.size += record.size;
+      if (record.n > 1) {
+        item.dupN += record.n - 1;
+        item.dupSize += (record.size * (record.n - 1)) / record.n;
+      }
+    }
+    // calculate pattern stats for normal strings
     for (const [str, record] of Object.entries(stringMap)) {
       patternLoop: for (const [patternName, patternCheck] of Object.entries(
         StringAnalysis.stringPatternsToObserve,
       )) {
         if (!patternCheck(str)) {
           continue patternLoop;
         }
-        strPatternStat[patternName] = strPatternStat[patternName] || {
-          n: 0,
-          dupN: 0,
-          size: 0,
-          dupSize: 0,
-        };
-        const item = strPatternStat[patternName];
-        item.n += record.n;
-        item.size += record.size;
-        if (record.n > 1) {
-          item.dupN += record.n - 1;
-          item.dupSize += (record.size * (record.n - 1)) / record.n;
-        }
+        aggregatePatternStat(patternName, record);
       }
     }
+    // calculate pattern stats for source code strings
+    for (const [, record] of Object.entries(sourceStringMap)) {
+      const patternName = 'JS code string';
+      aggregatePatternStat(patternName, record);
+    }
     this.stringPatternsStat = strPatternStat;
   }
 

website/docs/api/heap-analysis/src/classes/StringAnalysis.md

@@ -1,6 +1,6 @@
 # Class: StringAnalysis
 
-Defined in: heap-analysis/src/plugins/StringAnalysis.ts:57
+Defined in: heap-analysis/src/plugins/StringAnalysis.ts:59
 
 This analysis finds duplicated string instance in JavaScript heap
 and rank them based on the duplicated string size and count.
@@ -86,7 +86,7 @@ const result = await analysis.analyzeSnapshotFromFile(snapshotFile, {
 
 > **getCommandName**(): `string`
 
-Defined in: heap-analysis/src/plugins/StringAnalysis.ts:118
+Defined in: heap-analysis/src/plugins/StringAnalysis.ts:120
 
 get CLI command name for this memory analysis;
 use it with `memlab analyze <ANALYSIS_NAME>` in CLI
@@ -107,7 +107,7 @@ command name
 
 > **getTopDuplicatedStringsInCount**(): `StringRecord`[]
 
-Defined in: heap-analysis/src/plugins/StringAnalysis.ts:68
+Defined in: heap-analysis/src/plugins/StringAnalysis.ts:70
 
 get the top duplicated string in terms of duplicated string count