Merge pull request #7141 from NomicFoundation/project-type-ga-hit

Send selected project type to GA

Author: kanej

.changeset/strong-actors-count.md

@@ -0,0 +1,5 @@
+---
+"hardhat": patch
+---
+
+Send selected project type to GA

v-next/hardhat/src/internal/cli/init/init.ts

@@ -24,6 +24,7 @@ import * as semver from "semver";
 import { findClosestHardhatConfig } from "../../config-loading.js";
 import { HARDHAT_NAME } from "../../constants.js";
 import { getHardhatVersion } from "../../utils/package.js";
+import { sendProjectTypeAnalytics } from "../telemetry/analytics/analytics.js";
 
 import {
   getDevDependenciesInstallationCommand,
@@ -96,7 +97,10 @@ export async function initHardhat(options?: InitHardhatOptions): Promise<void> {
 
     // Ask the user for the template to use for the project initialization
     // if it was not provided, and validate that it exists
-    const template = await getTemplate(hardhatVersion, options?.template);
+    const [template, projectTypeAnalyticsPromise] = await getTemplate(
+      hardhatVersion,
+      options?.template,
+    );
 
     // Create the package.json file if it does not exist
     // and validate that it is an esm package
@@ -112,7 +116,11 @@ export async function initHardhat(options?: InitHardhatOptions): Promise<void> {
 
     // Print the commands to install the project dependencies
     // Run them only if the user opts-in to it
-    await installProjectDependencies(workspace, template, options?.install);
+    // Concurrently, await the analytics hit
+    await Promise.all([
+      installProjectDependencies(workspace, template, options?.install),
+      projectTypeAnalyticsPromise,
+    ]);
 
     showStarOnGitHubMessage();
   } catch (e) {
@@ -241,26 +249,34 @@ export async function getWorkspace(workspace?: string): Promise<string> {
  * NOTE: This function is exported for testing purposes
  *
  * @param template The name of the template to use for the project initialization.
- * @returns
+ * @returns A tuple with two elements: the template and a promise with the analytics hit.
  */
 export async function getTemplate(
   hardhatVersion: "hardhat-2" | "hardhat-3",
   template?: string,
-): Promise<Template> {
+): Promise<[Template, Promise<boolean>]> {
   const templates = await getTemplates(hardhatVersion);
 
   // Ask the user for the template to use for the project initialization if it was not provided
   if (template === undefined) {
     template = await promptForTemplate(templates);
   }
 
+  const projectTypeAnalyticsPromise = sendProjectTypeAnalytics(
+    hardhatVersion,
+    template,
+  );
+
   // Validate that the template exists
   for (const t of templates) {
     if (t.name === template) {
-      return t;
+      return [t, projectTypeAnalyticsPromise];
     }
   }
 
+  // we wait for the GA hit before throwing
+  await projectTypeAnalyticsPromise;
+
   throw new HardhatError(HardhatError.ERRORS.CORE.GENERAL.TEMPLATE_NOT_FOUND, {
     template,
   });

v-next/hardhat/src/internal/cli/telemetry/analytics/analytics.ts

@@ -1,7 +1,6 @@
 import type {
-  EventNames,
+  AnalyticsEvent,
   Payload,
-  TaskParams,
   TelemetryConfigPayload,
 } from "./types.js";
 
@@ -54,23 +53,38 @@ export async function sendTelemetryConfigAnalytics(
 }
 
 export async function sendTaskAnalytics(taskId: string[]): Promise<boolean> {
-  const eventParams: TaskParams = {
-    task: taskId.join(", "),
+  const taskAnalyticsEvent: AnalyticsEvent = {
+    name: "task",
+    params: {
+      task: taskId.join(", "),
+    },
   };
 
-  return sendAnalytics("task", eventParams);
+  return sendAnalytics(taskAnalyticsEvent);
 }
 
-// Return a boolean for testing purposes to confirm whether analytics were sent based on the consent value and not in CI environments
-async function sendAnalytics(
-  eventName: EventNames,
-  eventParams: TaskParams,
+export async function sendProjectTypeAnalytics(
+  hardhatVersion: "hardhat-2" | "hardhat-3",
+  template: string,
 ): Promise<boolean> {
+  const initAnalyticsEvent: AnalyticsEvent = {
+    name: "init",
+    params: {
+      hardhatVersion,
+      template,
+    },
+  };
+
+  return sendAnalytics(initAnalyticsEvent);
+}
+
+// Return a boolean for testing purposes to confirm whether analytics were sent based on the consent value and not in CI environments
+async function sendAnalytics(analyticsEvent: AnalyticsEvent): Promise<boolean> {
   if (!(await isTelemetryAllowed())) {
     return false;
   }
 
-  const payload = await buildPayload(eventName, eventParams);
+  const payload = await buildPayload(analyticsEvent);
 
   await createSubprocessToSendAnalytics(payload);
 
@@ -104,10 +118,7 @@ async function createSubprocessToSendAnalytics(
   log("Payload sent to detached subprocess");
 }
 
-async function buildPayload(
-  eventName: EventNames,
-  eventParams: TaskParams,
-): Promise<Payload> {
+async function buildPayload(analyticsEvent: AnalyticsEvent): Promise<Payload> {
   const clientId = await getAnalyticsClientId();
 
   return {
@@ -121,11 +132,11 @@ async function buildPayload(
     },
     events: [
       {
-        name: eventName,
+        name: analyticsEvent.name,
         params: {
           engagement_time_msec: ENGAGEMENT_TIME_MSEC,
           session_id: SESSION_ID,
-          ...eventParams,
+          ...analyticsEvent.params,
         },
       },
     ],

v-next/hardhat/src/internal/cli/telemetry/analytics/types.ts

@@ -32,11 +32,20 @@ export interface TelemetryConfigPayload extends BasePayload {
   }>;
 }
 
-export type EventNames = "task";
-
-export interface TaskParams {
-  task: string;
-}
+export type AnalyticsEvent =
+  | {
+      name: "task";
+      params: {
+        task: string;
+      };
+    }
+  | {
+      name: "init";
+      params: {
+        hardhatVersion: "hardhat-2" | "hardhat-3";
+        template: string;
+      };
+    };
 
 export interface Payload extends BasePayload {
   user_properties: {
@@ -54,10 +63,10 @@ export interface Payload extends BasePayload {
     };
   };
   events: Array<{
-    name: EventNames;
+    name: AnalyticsEvent["name"];
     params: {
       engagement_time_msec: string;
       session_id: string;
-    } & TaskParams;
+    } & AnalyticsEvent["params"];
   }>;
 }

v-next/hardhat/test/internal/cli/init/init.ts

@@ -90,7 +90,7 @@ describe("getTemplate", () => {
     );
   });
   it("should return the provided template", async () => {
-    const template = await getTemplate("hardhat-3", "mocha-ethers");
+    const [template] = await getTemplate("hardhat-3", "mocha-ethers");
     assert.equal(template.name, "mocha-ethers");
   });
 });
@@ -284,7 +284,7 @@ describe("copyProjectFiles", () => {
 
   describe("when force is true", () => {
     it("should copy the template files to the workspace and overwrite existing files", async () => {
-      const template = await getTemplate("hardhat-3", "mocha-ethers");
+      const [template] = await getTemplate("hardhat-3", "mocha-ethers");
       // Create template files with "some content" in the workspace
       const workspaceFiles = template.files.map(
         relativeTemplateToWorkspacePath,
@@ -303,7 +303,7 @@ describe("copyProjectFiles", () => {
       }
     });
     it("should copy the .gitignore file correctly", async () => {
-      const template = await getTemplate("hardhat-3", "mocha-ethers");
+      const [template] = await getTemplate("hardhat-3", "mocha-ethers");
       // Copy the template files to the workspace
       await copyProjectFiles(process.cwd(), template, true);
       // Check that the .gitignore exists but gitignore does not
@@ -319,7 +319,7 @@ describe("copyProjectFiles", () => {
   });
   describe("when force is false", () => {
     it("should copy the template files to the workspace and NOT overwrite existing files", async () => {
-      const template = await getTemplate("hardhat-3", "mocha-ethers");
+      const [template] = await getTemplate("hardhat-3", "mocha-ethers");
       // Create template files with "some content" in the workspace
       const workspaceFiles = template.files.map(
         relativeTemplateToWorkspacePath,
@@ -338,7 +338,7 @@ describe("copyProjectFiles", () => {
       }
     });
     it("should copy the .gitignore file correctly", async () => {
-      const template = await getTemplate("hardhat-3", "mocha-ethers");
+      const [template] = await getTemplate("hardhat-3", "mocha-ethers");
       // Copy the template files to the workspace
       await copyProjectFiles(process.cwd(), template, false);
       // Check that the .gitignore exists but gitignore does not
@@ -396,7 +396,7 @@ describe("installProjectDependencies", async () => {
   }
 
   it("should not install any template dependencies if the user opts-out of the installation", async () => {
-    const template = await getTemplate("hardhat-3", "mocha-ethers");
+    const [template] = await getTemplate("hardhat-3", "mocha-ethers");
     await writeUtf8File("package.json", JSON.stringify({ type: "module" }));
     await installProjectDependencies(process.cwd(), template, false, false);
     assert.ok(!(await exists("node_modules")), "node_modules should not exist");
@@ -412,7 +412,7 @@ describe("installProjectDependencies", async () => {
         process.env.GITHUB_HEAD_REF?.startsWith("changeset-release/"),
     },
     async () => {
-      const template = await getTemplate("hardhat-3", "mocha-ethers");
+      const [template] = await getTemplate("hardhat-3", "mocha-ethers");
       await writeUtf8File(
         "package.json",
         JSON.stringify({

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

@@ -7,6 +7,7 @@ import { after, afterEach, before, beforeEach, describe, it } from "node:test";
 import { readJsonFile, remove } from "@nomicfoundation/hardhat-utils/fs";
 
 import {
+  sendProjectTypeAnalytics,
   sendTaskAnalytics,
   sendTelemetryConfigAnalytics,
 } from "../../../../../src/internal/cli/telemetry/analytics/analytics.js";
@@ -133,9 +134,46 @@ describe("analytics", () => {
       assert.equal(result.events[0].name, "task");
       assert.equal(result.events[0].params.engagement_time_msec, "10000");
       assert.notEqual(result.events[0].params.session_id, undefined);
+      assert(
+        "task" in result.events[0].params,
+        "params should have a task field",
+      );
       assert.equal(result.events[0].params.task, "task, subtask");
     });
 
+    it("should create the correct payload for the init analytics", async () => {
+      const wasSent = await sendProjectTypeAnalytics(
+        "hardhat-3",
+        "mocha-ethers",
+      );
+
+      await checkIfSubprocessWasExecuted(RESULT_FILE_PATH);
+
+      const result: Payload = await readJsonFile(RESULT_FILE_PATH);
+
+      assert.equal(wasSent, true);
+
+      // Check payload properties
+      assert.notEqual(result.client_id, undefined);
+      assert.notEqual(result.user_id, undefined);
+      assert.equal(result.user_properties.projectId.value, "hardhat-project");
+      assert.equal(
+        result.user_properties.hardhatVersion.value,
+        await getHardhatVersion(),
+      );
+      assert.notEqual(result.user_properties.operatingSystem.value, undefined);
+      assert.notEqual(result.user_properties.nodeVersion.value, undefined);
+      assert.equal(result.events[0].name, "init");
+      assert.equal(result.events[0].params.engagement_time_msec, "10000");
+      assert.notEqual(result.events[0].params.session_id, undefined);
+      assert(
+        "hardhatVersion" in result.events[0].params,
+        "params should have a task field",
+      );
+      assert.equal(result.events[0].params.hardhatVersion, "hardhat-3");
+      assert.equal(result.events[0].params.template, "mocha-ethers");
+    });
+
     it("should not send analytics because the user explicitly opted out of telemetry", async () => {
       process.env.HARDHAT_TEST_TELEMETRY_ENABLED = "false";