@webiny/telemetry 0.0.0-unstable.b14eaecf38 → 0.0.0-unstable.b6d7105cee

package/README.md

@@ -1 +1,11 @@
 # @webiny/telemetry
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/cli.d.ts

@@ -0,0 +1,11 @@
+export declare interface SendEventParams {
+    event: string;
+    version?: string;
+    properties: Record<string, any>;
+}
+
+export declare function sendEvent(params: SendEventParams): Promise<void>;
+
+export declare function isEnabled(): boolean;
+export declare function enable(): boolean;
+export declare function disable(): boolean;

package/cli.js

@@ -1,40 +1,89 @@
-const createSendEvent = require("./sendEvent");
-const { globalConfig } = require("@webiny/global-config");
+import { globalConfig } from "@webiny/global-config";
+import { isCI } from "ci-info";
+import { WTS } from "@webiny/wts-client/node";
+import baseSendEvent from "./sendEvent.js";
+import { loadJsonFileSync } from "load-json-file";
+import path from "path";
 
-const sendEvent = ({ event, user, version, properties, extraPayload }) => {
+export const sendEvent = async ({ event, version, properties }) => {
     const shouldSend = isEnabled();
+    if (!shouldSend) {
+        return;
+    }
+
+    // Use the canonical Webiny machine id — the top-level `id` field in
+    // `~/.webiny/config`, owned by @webiny/global-config. The admin app
+    // (REACT_APP_WEBINY_TELEMETRY_USER_ID) and the website install/finish alias
+    // both key off this same id, so passing it here keeps CLI, admin, and
+    // website events on a single PostHog person. Without it, the WTS client
+    // falls back to its own `user.id` field, which is a different UUID and
+    // fragments funnels across surfaces.
+    const wts = new WTS({ source: "cli", distinctId: globalConfig.get("id") });
+
+    const wcpProperties = {};
+    const [wcpOrgId, wcpProjectId] = getWcpOrgProjectId();
+    if (wcpOrgId && wcpProjectId) {
+        wcpProperties.wcpOrgId = wcpOrgId;
+        wcpProperties.wcpProjectId = wcpProjectId;
+    }
+
+    const installationProperties = {};
+    const installationId = getInstallationId();
+    if (installationId) {
+        installationProperties.installation_id = installationId;
+    }
+
+    const packageJsonPath = path.join(import.meta.dirname, "package.json");
+    const packageJson = loadJsonFileSync(packageJsonPath);
 
+    return baseSendEvent({
+        event,
+        properties: {
+            ...properties,
+            ...wcpProperties,
+            ...installationProperties,
+            version: version || packageJson.version,
+            ci: isCI,
+            newUser: Boolean(globalConfig.get("newUser"))
+        },
+        wts
+    });
+};
+
+const getWcpOrgProjectId = () => {
+    // In CLI, project ID is stored in the `WEBINY_PROJECT_ID` or `WCP_PROJECT_ID` environment variable.
+    const id = process.env.WEBINY_PROJECT_ID || process.env.WCP_PROJECT_ID;
+    if (typeof id === "string") {
+        return id.split("/");
+    }
+    return [];
+};
+
+/**
+ * Reads the anonymous per-project installation id from
+ * `<project-root>/package.json` → `webiny.installationId`. Generated once at
+ * `create-webiny-project` time and tracked in git so it stays stable across
+ * machines that share the project. Returns null if the file is missing or
+ * unreadable — telemetry events still fire, just without the property.
+ */
+const getInstallationId = () => {
     try {
-        const sendTelemetry = createSendEvent({
-            event,
-            user: user || globalConfig.get("id"),
-            version: version || require("./package.json").version,
-            properties,
-            extraPayload
-        });
-
-        if (shouldSend) {
-            return sendTelemetry();
-        }
-    } catch (err) {
-        // Ignore errors if telemetry is disabled.
-        if (!shouldSend) {
-            return;
-        }
-
-        throw err;
+        const data = loadJsonFileSync(path.join(process.cwd(), "package.json"));
+        return typeof data?.webiny?.installationId === "string" ? data.webiny.installationId : null;
+    } catch {
+        return null;
     }
 };
 
-const enable = () => {
+export const enable = () => {
     globalConfig.set("telemetry", true);
 };
 
-const disable = () => {
+export const disable = () => {
     globalConfig.set("telemetry", false);
 };
 
-const isEnabled = () => {
+export const isEnabled = () => {
     const config = globalConfig.get();
 
     if (config.telemetry === false) {
@@ -44,5 +93,3 @@ const isEnabled = () => {
     // `tracking` is left here for backwards compatibility with previous versions of Webiny.
     return config.tracking !== false;
 };
-
-module.exports = { sendEvent, enable, disable, isEnabled };

package/package.json

@@ -1,15 +1,17 @@
 {
 	"name": "@webiny/telemetry",
-	"version": "0.0.0-unstable.b14eaecf38",
+	"version": "0.0.0-unstable.b6d7105cee",
+	"type": "module",
 	"license": "MIT",
 	"dependencies": {
-		"@webiny/global-config": "0.0.0-unstable.b14eaecf38",
-		"form-data": "3.0.0",
-		"node-fetch": "2.6.1"
+		"@webiny/global-config": "0.0.0-unstable.b6d7105cee",
+		"@webiny/wts-client": "3.1.4",
+		"ci-info": "4.4.0",
+		"jsesc": "3.1.0",
+		"load-json-file": "7.0.1",
+		"strip-ansi": "7.2.0"
 	},
 	"publishConfig": {
-		"access": "public",
-		"directory": "."
-	},
-	"gitHead": "b14eaecf387253ed23cb96f8d31b7d16b5061936"
+		"access": "public"
+	}
 }

package/react.d.ts

@@ -0,0 +1,2 @@
+export declare function sendEvent(ev: string, properties?: Record<string, any>): Promise<any>;
+export declare function getMachineId(): string | null;

package/react.js

@@ -1,36 +1,122 @@
-const createSendEvent = require("./sendEvent");
+import baseSendEvent from "./sendEvent.js";
+import { WTS } from "@webiny/wts-client/web";
+
+const STORAGE_MACHINE_ID = "wts_machine_id";
+const STORAGE_PROJECT_ID = "wts_project_id";
+
+let wtsInstance = null;
+let projectId = null;
+let distinctId = null;
 
-const setProperties = data => {
-    return sendEvent("$identify", data);
-};
 /**
+ * Resolves the WTS client identity for the admin app.
  *
- * @param event {String}
- * @param data {Record<string, string>}
- * @return {Promise<T>}
+ * Priority for `distinct_id` (machine_id):
+ *   1. URL param `wts_did` on first load. Persisted to localStorage.
+ *   2. localStorage (subsequent loads).
+ *   3. `process.env.REACT_APP_WEBINY_TELEMETRY_USER_ID` (build-time fallback,
+ *      set by `SetAdminAppEnvVarsBefore{Build,Watch}` from `~/.webiny/config`).
+ *
+ * Priority for `project_id` (installation_id):
+ *   1. URL param `iid` on first load. Persisted to localStorage.
+ *   2. localStorage.
+ *   3. `process.env.REACT_APP_WEBINY_INSTALLATION_ID` (build-time fallback,
+ *      set from `<project>/package.json` → `webiny.installationId`).
+ *
+ * Attached as a super-property on every admin event so PostHog funnels can
+ * group per-install.
  */
-const sendEvent = (event, data = {}) => {
-    let properties = {};
-    let extraPayload = {};
-    if (event !== "$identify") {
-        properties = data;
-    } else {
-        extraPayload = {
-            $set: data
-        };
+const initWts = () => {
+    if (wtsInstance) {
+        return wtsInstance;
+    }
+
+    distinctId = process.env.REACT_APP_WEBINY_TELEMETRY_USER_ID;
+    projectId = process.env.REACT_APP_WEBINY_INSTALLATION_ID || null;
+
+    if (typeof window !== "undefined") {
+        const params = new URLSearchParams(window.location.search);
+
+        const fromUrl = params.get("wts_did");
+        if (fromUrl) {
+            distinctId = fromUrl;
+            try {
+                window.localStorage.setItem(STORAGE_MACHINE_ID, fromUrl);
+            } catch {
+                // localStorage unavailable; URL value is used for this session only.
+            }
+        } else {
+            try {
+                distinctId = window.localStorage.getItem(STORAGE_MACHINE_ID) || distinctId;
+            } catch {
+                // ignore
+            }
+        }
+
+        const iidFromUrl = params.get("iid");
+        if (iidFromUrl) {
+            projectId = iidFromUrl;
+            try {
+                window.localStorage.setItem(STORAGE_PROJECT_ID, iidFromUrl);
+            } catch {
+                // ignore
+            }
+        } else {
+            try {
+                projectId = window.localStorage.getItem(STORAGE_PROJECT_ID) || projectId;
+            } catch {
+                // env-var value (set above) is used as fallback.
+            }
+        }
     }
 
+    wtsInstance = new WTS({ source: "admin", distinctId });
+    return wtsInstance;
+};
+
+/**
+ * Returns the machine_id used by admin events, if known. Used by the
+ * install/finish CTA to construct the alias handoff URL.
+ */
+export const getMachineId = () => {
+    initWts();
+    return distinctId || null;
+};
+
+export const sendEvent = async (event, properties = {}) => {
     const shouldSend = process.env.REACT_APP_WEBINY_TELEMETRY !== "false";
+    if (!shouldSend) {
+        return;
+    }
+
+    const wts = initWts();
 
-    const sendTelemetry = createSendEvent({
+    const wcpProperties = {};
+    const [wcpOrgId, wcpProjectId] = getWcpOrgProjectId();
+    if (wcpOrgId && wcpProjectId) {
+        wcpProperties.wcpOrgId = wcpOrgId;
+        wcpProperties.wcpProjectId = wcpProjectId;
+    }
+
+    return baseSendEvent({
         event,
-        properties,
-        extraPayload,
-        user: process.env.REACT_APP_USER_ID,
-        version: process.env.REACT_APP_WEBINY_VERSION
+        properties: {
+            ...properties,
+            ...wcpProperties,
+            ...(projectId ? { project_id: projectId } : {}),
+            version: process.env.REACT_APP_WEBINY_VERSION,
+            ci: process.env.REACT_APP_IS_CI === "true",
+            newUser: process.env.REACT_APP_WEBINY_TELEMETRY_NEW_USER === "true"
+        },
+        wts
     });
-
-    return shouldSend ? sendTelemetry() : Promise.resolve();
 };
 
-module.exports = { setProperties, sendEvent };
+const getWcpOrgProjectId = () => {
+    // In React applications, project ID is stored in the `REACT_APP_WEBINY_PROJECT_ID` or `REACT_APP_WCP_PROJECT_ID` environment variable.
+    const id = process.env.REACT_APP_WEBINY_PROJECT_ID || process.env.REACT_APP_WCP_PROJECT_ID;
+    if (typeof id === "string") {
+        return id.split("/");
+    }
+    return [];
+};

package/sendEvent.js

@@ -1,56 +1,57 @@
-const FormData = require("form-data");
-const fetch = require("node-fetch");
-
-const API_KEY = "ZdDZgkeOt4Z_m-UWmqFsE1d6-kcCK3BH0ypYTUIFty4";
-const API_URL = "https://t.webiny.com";
+import stripAnsi from "strip-ansi";
+import jsesc from "jsesc";
 
 /**
  * The main `sendEvent` function.
  * NOTE: don't use this in your app directly. Instead, use the one from `cli.js` or `react.js` files accordingly.
+ *
+ * Identity is owned by the WTS instance — `cli.js` reads `~/.webiny/config`,
+ * `react.js` reads URL params / localStorage / env. This function only
+ * validates and sanitises the event payload before dispatching.
  */
-module.exports = ({ event, user, version, properties, extraPayload } = {}) => {
+export default ({ event, properties, wts } = {}) => {
     if (!event) {
         throw new Error(`Cannot send event - missing "event" name.`);
     }
 
-    if (!user) {
-        throw new Error(`Cannot send event - missing "user" property.`);
+    if (!properties) {
+        throw new Error(`Cannot send event - missing "properties" object.`);
     }
 
-    if (!version) {
+    if (!wts) {
+        throw new Error(`Cannot send event - missing "wts" instance.`);
+    }
+
+    if (!properties.version) {
         throw new Error(`Cannot send event - missing "version" property.`);
     }
 
-    if (!properties) {
-        properties = {};
+    const hasCiProp = "ci" in properties;
+    if (!hasCiProp) {
+        throw new Error(`Cannot send event - missing "ci" boolean property.`);
     }
 
-    if (!extraPayload) {
-        extraPayload = {};
+    const hasNewUserProp = "newUser" in properties;
+    if (!hasNewUserProp) {
+        throw new Error(`Cannot send event - missing "newUser" boolean property.`);
     }
 
-    const payload = {
-        ...extraPayload,
-        event,
-        properties: {
-            ...properties,
-            version
-        },
-        distinct_id: user,
-        api_key: API_KEY,
-        timestamp: new Date().toISOString()
+    const sanitizedProperties = {
+        ...properties,
+        newUser: properties.newUser === true ? "yes" : "no",
+        ci: properties.ci === true ? "yes" : "no"
     };
 
-    const body = new FormData();
-    body.append("data", Buffer.from(JSON.stringify(payload)).toString("base64"));
-
-    // Return a function which will send the prepared body when invoked.
-    return () => {
-        return fetch(API_URL + "/capture/", {
-            body,
-            method: "POST"
-        }).catch(() => {
-            // Ignore errors
-        });
-    };
+    for (const key in sanitizedProperties) {
+        let sanitizedValue = sanitizedProperties[key];
+        if (typeof sanitizedValue === "string") {
+            sanitizedValue = sanitizedValue.trim();
+            sanitizedValue = stripAnsi(sanitizedValue);
+            sanitizedValue = jsesc(sanitizedValue);
+        }
+
+        sanitizedProperties[key] = sanitizedValue;
+    }
+
+    return wts.track(event, sanitizedProperties);
 };