@indigoai-us/hq-cloud 6.14.3 → 6.14.5

package/src/cli/sync.ts

@@ -722,18 +722,20 @@ export async function reportNewFilesToNotify(
         }),
         signal: controller.signal,
       });
-      void emitCloudTelemetry(telemetryClient, {
-        eventName: "new_files_notification_reported",
-        source: "hq-sync",
-        companyUid,
-        properties: {
-          result: response.ok ? "success" : "failure",
-          fileCount: batch.length,
-          batchIndex,
-          batchCount,
-          statusCode: response.status,
-        },
-      }, { claims: telemetryClaims });
+      if (!response.ok) {
+        void emitCloudTelemetry(telemetryClient, {
+          eventName: "new_files_notification_reported",
+          source: "hq-sync",
+          companyUid,
+          properties: {
+            status: "failure",
+            fileCount: batch.length,
+            batchIndex,
+            batchCount,
+            statusCode: response.status,
+          },
+        }, { claims: telemetryClaims });
+      }
     } catch (err) {
       // Best-effort per chunk: never let notification reporting affect the sync
       // result, and a failed chunk must not abort the remaining chunks.
@@ -743,11 +745,11 @@ export async function reportNewFilesToNotify(
         source: "hq-sync",
         companyUid,
         properties: {
-          result: "failure",
+          status: "failure",
           fileCount: batch.length,
           batchIndex,
           batchCount,
-          errorCode: safeErrorName(err),
+          errorClass: safeErrorName(err),
         },
       }, { claims: telemetryClaims });
     } finally {

package/src/watcher.test.ts

@@ -12,6 +12,7 @@ import {
 import { StaticFlagProvider } from "./sync/feature-flags.js";
 import type { PushEvent } from "./sync/push-event.js";
 import type { PushTransport } from "./sync/push-transport.js";
+import type { TelemetryEventsBatch } from "./vault-client.js";
 
 /**
  * US-001 — Phase 1 test harness: watch-triggered push seam + latency assertion.
@@ -736,4 +737,62 @@ describe("PushEventEmitter — directory and delete tombstone handling", () => {
     expect(published[0]).not.toHaveProperty("contentHash");
     expect(published[0]).not.toHaveProperty("mtime");
   });
+
+  it("emits push telemetry only when publication fails", async () => {
+    const posts: TelemetryEventsBatch[] = [];
+    const telemetryClient = {
+      postTelemetryEvents: vi.fn(async (batch: TelemetryEventsBatch) => {
+        posts.push(batch);
+        return { ok: true, written: batch.events.length, skipped: [] };
+      }),
+    };
+    const changed = path.join(dir, "changed.md");
+    fs.writeFileSync(changed, "changed");
+    const success = new PushEventEmitter({
+      originTenantId: "tenant-indigo",
+      originDeviceId: "device-a",
+      transport: {
+        start: async () => {},
+        dispose: async () => {},
+        connected: true,
+        publish: async () => {},
+      },
+      flagProvider: new StaticFlagProvider(["tenant-indigo"]),
+      telemetryClient,
+    });
+
+    await success.emitForBatch({ paths: new Map([[changed, "changed.md"]]) });
+    await flushImmediate();
+    expect(posts).toEqual([]);
+
+    const failed = new PushEventEmitter({
+      originTenantId: "tenant-indigo",
+      originDeviceId: "device-a",
+      transport: {
+        start: async () => {},
+        dispose: async () => {},
+        connected: true,
+        publish: async () => {
+          throw new Error("network down");
+        },
+      },
+      flagProvider: new StaticFlagProvider(["tenant-indigo"]),
+      telemetryClient,
+      onError: vi.fn(),
+    });
+
+    await failed.emitForBatch({ paths: new Map([[changed, "changed.md"]]) });
+    await flushImmediate();
+    expect(posts.flatMap((post) => post.events)).toEqual([
+      expect.objectContaining({
+        eventName: "push_event_failed",
+        properties: {
+          kind: "upsert",
+          count: 1,
+          status: "failure",
+          stage: "publish",
+        },
+      }),
+    ]);
+  });
 });

package/src/watcher.ts

@@ -989,7 +989,7 @@ export class PushEventEmitter {
         this.onError(err instanceof Error ? err : new Error(String(err)), {
           relativePath,
         });
-        this.emitPublishTelemetry("push_event_failed", "unknown", "capture");
+        this.emitPublishFailureTelemetry("unknown", "capture");
         return;
       }
 
@@ -1025,31 +1025,29 @@ export class PushEventEmitter {
 
     try {
       await this.transport.publish(event);
-      this.emitPublishTelemetry("push_event_published", event.kind, "publish");
     } catch (err) {
       // Push failure (network / non-2xx / timeout). The cadence poll is the
       // safety net — log + continue, never throw.
       this.onError(err instanceof Error ? err : new Error(String(err)), {
         relativePath,
       });
-      this.emitPublishTelemetry("push_event_failed", event.kind, "publish");
+      this.emitPublishFailureTelemetry(event.kind, "publish");
     }
   }
 
-  private emitPublishTelemetry(
-    eventName: "push_event_published" | "push_event_failed",
+  private emitPublishFailureTelemetry(
     kind: string,
-    stage: string,
+    stage: "capture" | "publish",
   ): void {
     void emitCloudTelemetry(
       this.telemetryClient,
       {
-        eventName,
+        eventName: "push_event_failed",
         source: "watcher",
         properties: {
           kind,
           count: 1,
-          result: eventName === "push_event_published" ? "success" : "failure",
+          status: "failure",
           stage,
         },
       },