fix: observability reporting

Author: maxprilutskiy

.changeset/big-numbers-end.md

@@ -0,0 +1,5 @@
+---
+"lingo.dev": patch
+---
+
+fix observability tracking

packages/cli/src/cli/utils/observability.ts

@@ -1,48 +1,90 @@
 import pkg from "node-machine-id";
 const { machineIdSync } = pkg;
+import https from "https";
 
-export async function createPosthogClient() {
-  const { PostHog } = await import("posthog-node");
-  const posthog = new PostHog(
-    "phc_eR0iSoQufBxNY36k0f0T15UvHJdTfHlh8rJcxsfhfXk",
-    {
-      host: "https://eu.i.posthog.com",
-      flushAt: 1,
-      flushInterval: 0,
-    },
-  );
-
-  return posthog;
-}
+const POSTHOG_API_KEY = "phc_eR0iSoQufBxNY36k0f0T15UvHJdTfHlh8rJcxsfhfXk";
+const POSTHOG_HOST = "eu.i.posthog.com";
+const POSTHOG_PATH = "/i/v0/e/";  // Correct PostHog capture endpoint
+const REQUEST_TIMEOUT_MS = 1000;
 
-export default async function trackEvent(
+/**
+ * Sends an analytics event to PostHog using direct HTTPS API.
+ * This is a fire-and-forget implementation that won't block the process.
+ *
+ * @param distinctId - Unique identifier for the user/device
+ * @param event - Name of the event to track
+ * @param properties - Additional properties to attach to the event
+ */
+export default function trackEvent(
   distinctId: string | null | undefined,
   event: string,
   properties?: Record<string, any>,
-) {
-  if (process.env.DO_NOT_TRACK) {
+): void {
+  // Skip tracking if explicitly disabled or in CI environment
+  if (process.env.DO_NOT_TRACK === "1") {
     return;
   }
 
-  try {
-    const actualId = distinctId || `device-${machineIdSync()}`;
+  // Defer execution to next tick to avoid blocking
+  setImmediate(() => {
+    try {
+      const actualId = distinctId || `device-${machineIdSync()}`;
+
+      // PostHog expects distinct_id at the root level, not nested in properties
+      const eventData = {
+        api_key: POSTHOG_API_KEY,
+        event,
+        distinct_id: actualId,
+        properties: {
+          ...properties,
+          $lib: "lingo.dev-cli",
+          $lib_version: process.env.npm_package_version || "unknown",
+        },
+        timestamp: new Date().toISOString(),
+      };
 
-    const posthog = await createPosthogClient();
+      const payload = JSON.stringify(eventData);
 
-    await posthog.capture({
-      distinctId: actualId,
-      event,
-      properties: {
-        ...properties,
-        meta: {
-          version: process.env.npm_package_version,
-          isCi: process.env.CI === "true",
+      const options: https.RequestOptions = {
+        hostname: POSTHOG_HOST,
+        path: POSTHOG_PATH,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload).toString(),
         },
-      },
-    });
-  } catch (error) {
-    if (process.env.DEBUG) {
-      console.error(error);
+        timeout: REQUEST_TIMEOUT_MS,
+      };
+
+      const req = https.request(options);
+
+      // Handle timeout by destroying the request
+      req.on("timeout", () => {
+        req.destroy();
+      });
+
+      // Silently ignore errors to prevent crashes
+      req.on("error", (error) => {
+        if (process.env.DEBUG === "true") {
+          console.error("[Tracking] Error ignored:", error.message);
+        }
+      });
+
+      // Send payload and close the request
+      req.write(payload);
+      req.end();
+
+      // Ensure cleanup after timeout
+      setTimeout(() => {
+        if (!req.destroyed) {
+          req.destroy();
+        }
+      }, REQUEST_TIMEOUT_MS);
+    } catch (error) {
+      // Catch-all for any synchronous errors
+      if (process.env.DEBUG === "true") {
+        console.error("[Tracking] Failed to send event:", error);
+      }
     }
-  }
+  });
 }