feat(telemetry): instrument cloud funnel gaps (auth, onboarding, canvas, output)

src/platform/cloud/onboarding/UserCheckView.vue

@@ -32,6 +32,8 @@ import {
   getSurveyCompletedStatus,
   getUserCloudStatus
 } from '@/platform/cloud/onboarding/auth'
+import { isCloud } from '@/platform/distribution/types'
+import { useTelemetry } from '@/platform/telemetry'
 
 import CloudLoginViewSkeleton from './skeletons/CloudLoginViewSkeleton.vue'
 import CloudSurveyViewSkeleton from './skeletons/CloudSurveyViewSkeleton.vue'
@@ -42,6 +44,7 @@ const { flags } = useFeatureFlags()
 const onboardingSurveyEnabled = computed(
   () => flags.onboardingSurveyEnabled ?? true
 )
+const telemetry = isCloud ? useTelemetry() : undefined
 
 const skeletonType = ref<'login' | 'survey' | 'waitlist' | 'loading'>('loading')
 
@@ -54,6 +57,11 @@ const {
     await nextTick()
 
     if (!onboardingSurveyEnabled.value) {
+      telemetry?.trackOnboardingRouted({
+        destination: 'onboarded',
+        survey_completed: false,
+        has_cloud_status: false
+      })
       await router.replace({ path: '/' })
       return
     }
@@ -65,19 +73,34 @@ const {
 
     // Navigate based on user status
     if (!cloudUserStats) {
+      telemetry?.trackOnboardingRouted({
+        destination: 'waitlist',
+        survey_completed: !!surveyStatus,
+        has_cloud_status: false
+      })
       skeletonType.value = 'login'
       await router.replace({ name: 'cloud-login' })
       return
     }
 
     // Survey is required for all users when feature flag is enabled
     if (!surveyStatus) {
+      telemetry?.trackOnboardingRouted({
+        destination: 'survey',
+        survey_completed: false,
+        has_cloud_status: true
+      })
       skeletonType.value = 'survey'
       await router.replace({ name: 'cloud-survey' })
       return
     }
 
     // User is fully onboarded (active or whitelist check disabled)
+    telemetry?.trackOnboardingRouted({
+      destination: 'onboarded',
+      survey_completed: true,
+      has_cloud_status: true
+    })
     globalThis.location.href = '/'
   }),
   null,

src/platform/cloud/subscription/composables/useSubscription.ts

@@ -204,9 +204,19 @@ function useSubscriptionInternal() {
   )
 
   const subscribe = wrapWithErrorHandlingAsync(async () => {
-    const response = await initiateSubscriptionCheckout()
+    let response: CloudSubscriptionCheckoutResponse
+    try {
+      response = await initiateSubscriptionCheckout()
+    } catch (error) {
+      telemetry?.trackCheckoutInitiateFailed({
+        stage: 'server_error',
+        error_code: error instanceof Error ? error.message : undefined
+      })
+      throw error
+    }
 
     if (!response.checkout_url) {
+      telemetry?.trackCheckoutInitiateFailed({ stage: 'no_url' })
       throw new Error(
         t('toastMessages.failedToInitiateSubscription', {
           error: 'No checkout URL returned'
@@ -216,6 +226,7 @@ function useSubscriptionInternal() {
 
     const checkoutWindow = window.open(response.checkout_url, '_blank')
     if (!checkoutWindow) {
+      telemetry?.trackCheckoutWindowBlocked()
       return
     }
 

src/platform/cloud/subscription/composables/useSubscriptionDialog.ts

@@ -14,6 +14,12 @@ export type SubscriptionDialogReason =
   | 'subscription_required'
   | 'out_of_credits'
   | 'top_up_blocked'
+  // Workspace member-invite upsell. A NON-activation cohort: the activation
+  // funnel must be able to EXCLUDE these so single-user activation is not
+  // diluted by team seat-expansion prompts.
+  | 'member_invite'
+  | 'upload_model'
+  | 'run_workflow'
 
 export const useSubscriptionDialog = () => {
   const { flags } = useFeatureFlags()

src/platform/telemetry/TelemetryRegistry.ts

@@ -1,8 +1,13 @@
 import type { AuditLog } from '@/services/customerEventsService'
 
 import type {
+  AuthFailedMetadata,
+  AuthMethodSelectedMetadata,
   AuthMetadata,
   BeginCheckoutMetadata,
+  CanvasReadyMetadata,
+  CheckoutInitiateFailedMetadata,
+  CheckoutWindowBlockedMetadata,
   DefaultViewSetMetadata,
   EnterLinearMetadata,
   ShareFlowMetadata,
@@ -16,6 +21,9 @@ import type {
   NodeAddedMetadata,
   NodeSearchMetadata,
   NodeSearchResultMetadata,
+  OAuthPopupResultMetadata,
+  OnboardingRoutedMetadata,
+  OutputViewedMetadata,
   SearchQueryMetadata,
   PageViewMetadata,
   PageVisibilityMetadata,
@@ -67,6 +75,18 @@ export class TelemetryRegistry implements TelemetryDispatcher {
     this.dispatch((provider) => provider.trackSignupOpened?.())
   }
 
+  trackAuthMethodSelected(metadata: AuthMethodSelectedMetadata): void {
+    this.dispatch((provider) => provider.trackAuthMethodSelected?.(metadata))
+  }
+
+  trackOAuthPopupResult(metadata: OAuthPopupResultMetadata): void {
+    this.dispatch((provider) => provider.trackOAuthPopupResult?.(metadata))
+  }
+
+  trackAuthFailed(metadata: AuthFailedMetadata): void {
+    this.dispatch((provider) => provider.trackAuthFailed?.(metadata))
+  }
+
   trackAuth(metadata: AuthMetadata): void {
     this.dispatch((provider) => provider.trackAuth?.(metadata))
   }
@@ -75,6 +95,14 @@ export class TelemetryRegistry implements TelemetryDispatcher {
     this.dispatch((provider) => provider.trackUserLoggedIn?.())
   }
 
+  trackCanvasReady(metadata: CanvasReadyMetadata): void {
+    this.dispatch((provider) => provider.trackCanvasReady?.(metadata))
+  }
+
+  trackOnboardingRouted(metadata: OnboardingRoutedMetadata): void {
+    this.dispatch((provider) => provider.trackOnboardingRouted?.(metadata))
+  }
+
   trackSubscription(
     event: 'modal_opened' | 'subscribe_clicked',
     metadata?: SubscriptionMetadata
@@ -86,6 +114,16 @@ export class TelemetryRegistry implements TelemetryDispatcher {
     this.dispatch((provider) => provider.trackBeginCheckout?.(metadata))
   }
 
+  trackCheckoutInitiateFailed(metadata: CheckoutInitiateFailedMetadata): void {
+    this.dispatch((provider) =>
+      provider.trackCheckoutInitiateFailed?.(metadata)
+    )
+  }
+
+  trackCheckoutWindowBlocked(metadata?: CheckoutWindowBlockedMetadata): void {
+    this.dispatch((provider) => provider.trackCheckoutWindowBlocked?.(metadata))
+  }
+
   trackMonthlySubscriptionSucceeded(
     metadata?: SubscriptionSuccessMetadata
   ): void {
@@ -145,10 +183,6 @@ export class TelemetryRegistry implements TelemetryDispatcher {
     this.dispatch((provider) => provider.trackSurvey?.(stage, responses))
   }
 
-  trackEmailVerification(stage: 'opened' | 'requested' | 'completed'): void {
-    this.dispatch((provider) => provider.trackEmailVerification?.(stage))
-  }
-
   trackTemplate(metadata: TemplateMetadata): void {
     this.dispatch((provider) => provider.trackTemplate?.(metadata))
   }
@@ -251,6 +285,10 @@ export class TelemetryRegistry implements TelemetryDispatcher {
     this.dispatch((provider) => provider.trackExecutionSuccess?.(metadata))
   }
 
+  trackOutputViewed(metadata: OutputViewedMetadata): void {
+    this.dispatch((provider) => provider.trackOutputViewed?.(metadata))
+  }
+
   trackSharedWorkflowRun(metadata: SharedWorkflowRunMetadata): void {
     this.dispatch((provider) => provider.trackSharedWorkflowRun?.(metadata))
   }

src/platform/telemetry/authActivationMarker.test.ts

@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  consumeAuthActivation,
+  markAuthForActivation
+} from '@/platform/telemetry/authActivationMarker'
+
+const MARKER_KEY = 'comfy:telemetry:auth-activation'
+
+describe('authActivationMarker', () => {
+  beforeEach(() => {
+    sessionStorage.clear()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    vi.useRealTimers()
+  })
+
+  describe('mark then consume', () => {
+    it('returns the stored marker once and then clears the key', () => {
+      vi.useFakeTimers()
+      vi.setSystemTime(new Date('2026-06-16T00:00:00.000Z'))
+      const expectedAt = Date.now()
+
+      markAuthForActivation(true)
+
+      const marker = consumeAuthActivation()
+      expect(marker).toEqual({ at: expectedAt, isNewUser: true })
+
+      // The marker is single-use: a second consume finds nothing.
+      expect(consumeAuthActivation()).toBeNull()
+      expect(sessionStorage.getItem(MARKER_KEY)).toBeNull()
+    })
+
+    it('preserves isNewUser=false through a round trip', () => {
+      markAuthForActivation(false)
+
+      const marker = consumeAuthActivation()
+      expect(marker?.isNewUser).toBe(false)
+      expect(typeof marker?.at).toBe('number')
+    })
+  })
+
+  describe('consume without a valid marker', () => {
+    it('returns null when no marker is present', () => {
+      expect(consumeAuthActivation()).toBeNull()
+    })
+
+    it('returns null and clears the key when the value is garbage', () => {
+      sessionStorage.setItem(MARKER_KEY, 'not-json-{')
+
+      expect(consumeAuthActivation()).toBeNull()
+      expect(sessionStorage.getItem(MARKER_KEY)).toBeNull()
+    })
+
+    it('returns null for a wrong-shape object missing fields', () => {
+      sessionStorage.setItem(MARKER_KEY, JSON.stringify({ at: 123 }))
+
+      expect(consumeAuthActivation()).toBeNull()
+      // It still consumes (removes) the malformed marker so it is not retried.
+      expect(sessionStorage.getItem(MARKER_KEY)).toBeNull()
+    })
+
+    it('returns null when fields are present but wrong types', () => {
+      sessionStorage.setItem(
+        MARKER_KEY,
+        JSON.stringify({ at: 'soon', isNewUser: 'yes' })
+      )
+
+      expect(consumeAuthActivation()).toBeNull()
+      expect(sessionStorage.getItem(MARKER_KEY)).toBeNull()
+    })
+
+    it('returns null for a non-object JSON payload', () => {
+      sessionStorage.setItem(MARKER_KEY, JSON.stringify(42))
+
+      expect(consumeAuthActivation()).toBeNull()
+      expect(sessionStorage.getItem(MARKER_KEY)).toBeNull()
+    })
+  })
+
+  describe('markAuthForActivation error handling', () => {
+    it('swallows a sessionStorage failure without throwing', () => {
+      const setItemSpy = vi
+        .spyOn(sessionStorage, 'setItem')
+        .mockImplementation(() => {
+          throw new Error('QuotaExceededError')
+        })
+
+      expect(() => markAuthForActivation(true)).not.toThrow()
+      expect(setItemSpy).toHaveBeenCalledOnce()
+    })
+  })
+})

src/platform/telemetry/authActivationMarker.ts

@@ -0,0 +1,51 @@
+/**
+ * Bridges the auth -> canvas gap for the `canvas_ready` activation event.
+ *
+ * The onboarded path navigates with a full `location.href` reload, which wipes
+ * in-memory state (including the auth store) before the graph canvas mounts.
+ * `auth_completed` therefore cannot carry forward whether the user was new or
+ * when they authenticated. We stash a small marker in `sessionStorage` at auth
+ * completion and consume it exactly once when the canvas first becomes
+ * interactive. sessionStorage is per-tab and cleared on tab close, which is the
+ * correct scope for a single activation.
+ */
+const MARKER_KEY = 'comfy:telemetry:auth-activation'
+
+interface AuthActivationMarker {
+  at: number
+  isNewUser: boolean
+}
+
+/** Records that an authentication just completed, for the next canvas load. */
+export function markAuthForActivation(isNewUser: boolean): void {
+  try {
+    const marker: AuthActivationMarker = { at: Date.now(), isNewUser }
+    sessionStorage.setItem(MARKER_KEY, JSON.stringify(marker))
+  } catch {
+    // sessionStorage may be unavailable (private mode, SSR); skip silently.
+  }
+}
+
+/**
+ * Reads and clears the activation marker. Returns null when no auth happened in
+ * this tab (e.g. a plain reload by a returning user).
+ */
+export function consumeAuthActivation(): AuthActivationMarker | null {
+  try {
+    const raw = sessionStorage.getItem(MARKER_KEY)
+    if (!raw) return null
+    sessionStorage.removeItem(MARKER_KEY)
+    const parsed: unknown = JSON.parse(raw)
+    if (
+      parsed &&
+      typeof parsed === 'object' &&
+      typeof (parsed as AuthActivationMarker).at === 'number' &&
+      typeof (parsed as AuthActivationMarker).isNewUser === 'boolean'
+    ) {
+      return parsed as AuthActivationMarker
+    }
+  } catch {
+    // Corrupt or unavailable; treat as no marker.
+  }
+  return null
+}

src/platform/telemetry/providers/cloud/GtmTelemetryProvider.test.ts

@@ -270,22 +270,6 @@ describe('GtmTelemetryProvider', () => {
       })
     })
 
-    it('pushes email_verify_opened for opened stage', () => {
-      const provider = createInitializedProvider()
-      provider.trackEmailVerification('opened')
-      expect(lastDataLayerEntry()).toMatchObject({
-        event: 'email_verify_opened'
-      })
-    })
-
-    it('pushes email_verify_completed for completed stage', () => {
-      const provider = createInitializedProvider()
-      provider.trackEmailVerification('completed')
-      expect(lastDataLayerEntry()).toMatchObject({
-        event: 'email_verify_completed'
-      })
-    })
-
     it('pushes search for node search (GA4 recommended)', () => {
       const provider = createInitializedProvider()
       provider.trackNodeSearch({ query: 'KSampler' })

src/platform/telemetry/providers/cloud/GtmTelemetryProvider.ts

@@ -256,15 +256,6 @@ export class GtmTelemetryProvider implements TelemetryProvider {
     this.pushEvent(ga4EventName, responses ? { ...responses } : undefined)
   }
 
-  trackEmailVerification(stage: 'opened' | 'requested' | 'completed'): void {
-    const eventMap = {
-      opened: 'email_verify_opened',
-      requested: 'email_verify_requested',
-      completed: 'email_verify_completed'
-    } as const
-    this.pushEvent(eventMap[stage])
-  }
-
   trackWorkflowOpened(metadata: WorkflowImportMetadata): void {
     this.pushEvent('workflow_opened', {
       missing_node_count: metadata.missing_node_count,