test: enable trace_events tests with perfetto

Signed-off-by: Chengzhong Wu <cwu631@bloomberg.net>

Author: legendecas

.github/workflows/test-linux-perfetto.yml

@@ -62,6 +62,9 @@ jobs:
       - name: Build
         working-directory: node
         run: make build-ci -j4 V=1 CONFIG_FLAGS="--error-on-warn --v8-enable-temporal-support --with-perfetto"
+      - name: Get trace_processor
+        working-directory: node
+        run: make trace_processor
       - name: Test
         working-directory: node
         run: make test-ci -j1 V=1 TEST_CI_ARGS="-p actions --measure-flakiness 9"

.gitignore

@@ -116,6 +116,10 @@ tools/*/*.i.tmp
 /tools/eslint/node_modules
 /tools/lint-md/node_modules
 
+# === Rules for tools/perfetto ===
+/tools/perfetto/trace_processor_shell
+/tools/perfetto/.version
+
 # === Rules for test artifacts ===
 /*.tap
 /*.xml

Makefile

@@ -235,6 +235,7 @@ distclean: ## Remove all build and test artifacts.
 	$(RM) -r node_modules
 	$(RM) -r deps/icu
 	$(RM) -r deps/icu4c*.tgz deps/icu4c*.zip deps/icu-tmp
+	$(RM) tools/perfetto/trace_processor_shell tools/perfetto/.version
 	$(RM) $(BINARYTAR).* $(TARBALL).*
 
 .PHONY: check
@@ -338,6 +339,10 @@ coverage-run-js: ## Run JavaScript tests with coverage.
 					TEST_CI_ARGS="$(TEST_CI_ARGS) --type=coverage" $(MAKE) jstest
 	$(MAKE) coverage-report-js
 
+.PHONY: trace-processor
+trace-processor: ## Download perfetto's trace_processor_shell.
+	@tools/perfetto/get_trace_processor
+
 .PHONY: test
 # This does not run tests of third-party libraries inside deps.
 test: all ## Run default tests and build docs.

test/common/index.js

@@ -1029,6 +1029,7 @@ const common = {
   hasSQLite,
   hasFFI,
   hasLocalStorage,
+  hasPerfetto,
   invalidArgTypeHelper,
   isAlive,
   isASan,

test/common/trace_events.js

@@ -0,0 +1,66 @@
+'use strict';
+
+// Reads back the trace file a Node.js process wrote, whichever tracing backend
+// produced it. Legacy builds write the Chrome JSON trace format directly.
+// Perfetto builds write a binary protobuf trace, which perfetto's
+// `trace_processor_shell` converts to the same format. Run `make trace-processor`
+// to download it.
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const common = require('./');
+
+const traceProcessor = path.resolve(
+  __dirname, '..', '..', 'tools', 'perfetto', 'trace_processor_shell');
+
+// The JSON form of a trace runs about three times the size of the trace it was
+// converted from, and the traces these tests produce are a few hundred KiB at
+// most. This is an assumed MAX size of a JSON conversion size limit for tests.
+const kMaxTraceJsonBytes = 64 * 1024 * 1024;
+
+// Perfetto builds default the file pattern to a .pftrace extension.
+const defaultTraceFileName = common.hasPerfetto ? 'node_trace.1.pftrace' :
+  'node_trace.1.log';
+
+// Only perfetto traces need converting, so a missing trace_processor_shell
+// does not stop anything on a legacy build.
+function skipIfTraceReaderMissing() {
+  if (common.hasPerfetto && !fs.existsSync(traceProcessor)) {
+    common.skip('trace_processor_shell is missing, ' +
+                'run `make trace-processor` to download it');
+  }
+}
+
+function readTraceEvents(file) {
+  if (!common.hasPerfetto) {
+    return JSON.parse(fs.readFileSync(file, 'utf8')).traceEvents;
+  }
+
+  const converted = spawnSync(traceProcessor, ['convert', 'json', file],
+                              { maxBuffer: kMaxTraceJsonBytes });
+  assert.ifError(converted.error);
+  assert.strictEqual(
+    converted.status, 0,
+    `trace_processor_shell failed: ${converted.stderr}`);
+  return JSON.parse(converted.stdout.toString()).traceEvents;
+}
+
+// A perfetto trace event carries the single category it was emitted with. The
+// legacy backend instead groups it with every ancestor category, so
+// `node.net.native` is recorded as `node,node.net,node.net.native`.
+function traceCategory(name) {
+  if (common.hasPerfetto) {
+    return name;
+  }
+  const parts = name.split('.');
+  return parts.map((_, i) => parts.slice(0, i + 1).join('.')).join(',');
+}
+
+module.exports = {
+  defaultTraceFileName,
+  readTraceEvents,
+  skipIfTraceReaderMissing,
+  traceCategory,
+};

test/parallel/test-inspector-tracing-domain.js

@@ -3,6 +3,9 @@
 const common = require('../common');
 
 common.skipIfInspectorDisabled();
+// The inspector NodeTracing domain is not wired up on a perfetto build, see
+// src/inspector_agent.cc, so every command here fails with
+// ERR_INSPECTOR_COMMAND.
 common.skipIfPerfettoEnabled();
 
 const { isMainThread } = require('worker_threads');

test/parallel/test-module-print-timing.mjs

@@ -7,6 +7,8 @@ import tmpdir from '../common/tmpdir.js';
 import { spawnSyncAndAssert } from '../common/child_process.js';
 import fixtures from '../common/fixtures.js';
 
+// The dynamic tracing case below records nothing on a perfetto build: a
+// category enabled after the tracing session started stays off.
 skipIfPerfettoEnabled();
 tmpdir.refresh();
 

test/parallel/test-permission-fs-write-trace-events.js

@@ -1,18 +1,17 @@
-// Flags: --expose-internals
 'use strict';
 
 const common = require('../common');
 const { spawnSyncAndExitWithoutError } = require('../common/child_process');
 const { isMainThread } = require('worker_threads');
 
-common.skipIfPerfettoEnabled();
 if (!isMainThread) {
   common.skip('This test only works on a main thread');
 }
 
 const assert = require('assert');
 const fs = require('fs');
 const tmpdir = require('../common/tmpdir');
+const { defaultTraceFileName } = require('../common/trace_events');
 
 try {
   require('trace_events');
@@ -56,7 +55,7 @@ assert.throws(() => {
 }, common.expectsError({
   code: 'ERR_ACCESS_DENIED',
   permission: 'FileSystemWrite',
-  resource: 'node_trace.1.log',
+  resource: defaultTraceFileName,
 }));
 
-assert.strictEqual(fs.existsSync('node_trace.1.log'), false);
+assert.strictEqual(fs.existsSync(defaultTraceFileName), false);

test/parallel/test-trace-events-all.js

@@ -10,6 +10,8 @@ try {
   common.skip('missing trace events');
 }
 
+// Perfetto records nothing for a category enabled after the tracing session
+// started, so there is no dynamic enabling to test there yet.
 common.skipIfPerfettoEnabled();
 
 const assert = require('assert');