move the subprocess code in a single file and modify test config variables

Author: ChristopherDedominici

v-next/hardhat/src/internal/cli/telemetry/sentry/send-to-sentry.ts

@@ -1,3 +1,79 @@
-import { main } from "./send-to-sentry.js";
+import type { Event } from "@sentry/node";
 
-await main();
+import { writeUtf8File } from "@ignored/hardhat-vnext-utils/fs";
+import { captureEvent, captureMessage, init } from "@sentry/node";
+
+import { Anonymizer } from "./anonymizer.js";
+import { SENTRY_DSN } from "./reporter.js";
+
+try {
+  init({
+    dsn: SENTRY_DSN,
+  });
+} catch (error) {
+  process.exit(1);
+}
+
+const serializedEvent = process.argv[2];
+const configPath = process.argv[3];
+
+if (serializedEvent === undefined) {
+  await sendMsgToSentry(
+    "There was an error parsing an event: 'process.argv[2]' argument is not set",
+  );
+
+  process.exit(1);
+}
+
+let event: any;
+try {
+  event = JSON.parse(serializedEvent);
+} catch {
+  await sendMsgToSentry(
+    "There was an error parsing an event: 'process.argv[2]' doesn't have a valid JSON",
+  );
+
+  process.exit(1);
+}
+
+try {
+  const anonymizer = new Anonymizer(configPath);
+  const anonymizedEvent = await anonymizer.anonymize(event);
+
+  if (anonymizedEvent.isRight()) {
+    if (anonymizer.raisedByHardhat(anonymizedEvent.value)) {
+      await sendEventToSentry(anonymizedEvent.value);
+    }
+  } else {
+    await sendMsgToSentry(
+      `There was an error anonymizing an event: ${anonymizedEvent.value}`,
+    );
+  }
+} catch (error: any) {
+  await sendMsgToSentry(
+    `There was an error capturing an event: ${error.message}`,
+  );
+}
+
+async function sendMsgToSentry(msg: string) {
+  if (process.env.HARDHAT_TEST_SUBPROCESS_RESULT_PATH !== undefined) {
+    // ATTENTION: only for testing
+    await writeUtf8File(process.env.HARDHAT_TEST_SUBPROCESS_RESULT_PATH, msg);
+    return;
+  }
+
+  captureMessage(msg);
+}
+
+async function sendEventToSentry(sentryEvent: Event) {
+  if (process.env.HARDHAT_TEST_SUBPROCESS_RESULT_PATH !== undefined) {
+    // ATTENTION: only for testing
+    await writeUtf8File(
+      process.env.HARDHAT_TEST_SUBPROCESS_RESULT_PATH,
+      JSON.stringify(sentryEvent),
+    );
+    return;
+  }
+
+  captureEvent(sentryEvent);
+}

v-next/hardhat/src/internal/cli/telemetry/sentry/subprocess.ts

@@ -29,7 +29,7 @@ export async function checkIfSubprocessWasExecuted(
   // Checks if the subprocess was executed by waiting for a file to be created.
   // Uses an interval to periodically check for the file. If the file isn't found
   // within a specified number of attempts, an error is thrown, indicating a failure in subprocess execution.
-  const MAX_COUNTER = 20;
+  const MAX_COUNTER = 100;
 
   return new Promise((resolve, reject) => {
     let counter = 0;

v-next/hardhat/test/internal/cli/telemetry/helpers.ts

@@ -67,7 +67,7 @@ const TEST_HARDHAT_ERROR = new HardhatError({
 
 const PATH_TO_FIXTURE = path.join(ROOT_PATH_TO_FIXTURE, "sentry");
 
-const RESULT_FILE_PATH = path.join(PATH_TO_FIXTURE, "result.txt");
+const RESULT_FILE_PATH = path.join(PATH_TO_FIXTURE, "reporter-result.txt");
 
 describe("Reporter", () => {
   beforeEach(async () => {

v-next/hardhat/test/internal/cli/telemetry/sentry/reporter.ts

@@ -3,41 +3,50 @@ import path from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
 
 import { readUtf8File, remove } from "@ignored/hardhat-vnext-utils/fs";
+import { spawnDetachedSubProcess } from "@ignored/hardhat-vnext-utils/subprocess";
 
-import { main } from "../../../../../src/internal/cli/telemetry/sentry/send-to-sentry.js";
 import {
   checkIfSubprocessWasExecuted,
   ROOT_PATH_TO_FIXTURE,
 } from "../helpers.js";
 
 const PATH_TO_FIXTURE = path.join(ROOT_PATH_TO_FIXTURE, "sentry");
 const RESULT_FILE_PATH = path.join(PATH_TO_FIXTURE, "sub-process-result.txt");
+const SUBPROCESS_FILE_PATH = path.join(
+  process.cwd(),
+  "src",
+  "internal",
+  "cli",
+  "telemetry",
+  "sentry",
+  "subprocess.ts",
+);
 
 describe("sentry-subprocess", function () {
   beforeEach(async () => {
-    process.env.HARDHAT_TEST_SUBPROCESS_RESULT_PATH = RESULT_FILE_PATH;
     await remove(RESULT_FILE_PATH);
   });
 
   afterEach(async () => {
-    delete process.env.HARDHAT_TEST_SUBPROCESS_RESULT_PATH;
     await remove(RESULT_FILE_PATH);
   });
 
   it("should send an event to Sentry", async () => {
-    process.argv[2] = "{}"; // Send an empty object, the real payload will be tested in the tests for the "Reporter"
+    await spawnDetachedSubProcess(SUBPROCESS_FILE_PATH, ["{}"], {
+      HARDHAT_TEST_SUBPROCESS_RESULT_PATH: RESULT_FILE_PATH,
+    });
 
-    await main();
     await checkIfSubprocessWasExecuted(RESULT_FILE_PATH);
     const fileRes = await readUtf8File(RESULT_FILE_PATH);
 
     assert.equal(fileRes, "{}");
   });
 
   it("should send a failure message to Sentry because no argument is passed in argv[2] (serializedEvent)", async () => {
-    delete process.argv[2];
+    await spawnDetachedSubProcess(SUBPROCESS_FILE_PATH, [], {
+      HARDHAT_TEST_SUBPROCESS_RESULT_PATH: RESULT_FILE_PATH,
+    });
 
-    await main();
     await checkIfSubprocessWasExecuted(RESULT_FILE_PATH);
     const fileRes = await readUtf8File(RESULT_FILE_PATH);
 
@@ -48,9 +57,10 @@ describe("sentry-subprocess", function () {
   });
 
   it("should send a failure message to Sentry because the argument in argv[2] is not a valid JSON", async () => {
-    process.argv[2] = "not a valid JSON";
+    await spawnDetachedSubProcess(SUBPROCESS_FILE_PATH, ["not a valid JSON"], {
+      HARDHAT_TEST_SUBPROCESS_RESULT_PATH: RESULT_FILE_PATH,
+    });
 
-    await main();
     await checkIfSubprocessWasExecuted(RESULT_FILE_PATH);
     const fileRes = await readUtf8File(RESULT_FILE_PATH);
 
@@ -61,9 +71,10 @@ describe("sentry-subprocess", function () {
   });
 
   it("should send a failure message to Sentry because there is an anonymization error", async () => {
-    process.argv[2] = "null";
+    await spawnDetachedSubProcess(SUBPROCESS_FILE_PATH, ["null"], {
+      HARDHAT_TEST_SUBPROCESS_RESULT_PATH: RESULT_FILE_PATH,
+    });
 
-    await main();
     await checkIfSubprocessWasExecuted(RESULT_FILE_PATH);
     const fileRes = await readUtf8File(RESULT_FILE_PATH);