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.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,

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

@@ -209,28 +209,6 @@ describe('MixpanelTelemetryProvider — with configured token', () => {
     )
   })
 
-  it.for<
-    [
-      'opened' | 'requested' | 'completed',
-      (typeof TelemetryEvents)[keyof typeof TelemetryEvents]
-    ]
-  >([
-    ['opened' as const, TelemetryEvents.USER_EMAIL_VERIFY_OPENED],
-    ['requested' as const, TelemetryEvents.USER_EMAIL_VERIFY_REQUESTED],
-    ['completed' as const, TelemetryEvents.USER_EMAIL_VERIFY_COMPLETED]
-  ])(
-    'trackEmailVerification(%s) dispatches %s',
-    async ([stage, expectedEvent]) => {
-      const provider = new MixpanelTelemetryProvider()
-      await waitForMixpanelInit()
-      mockMixpanel.track.mockClear()
-
-      provider.trackEmailVerification(stage)
-
-      expect(mockMixpanel.track).toHaveBeenCalledWith(expectedEvent, {})
-    }
-  )
-
   it.for<
     [
       'modal_opened' | 'subscribe_clicked',

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

@@ -329,24 +329,6 @@ export class MixpanelTelemetryProvider implements TelemetryProvider {
     }
   }
 
-  trackEmailVerification(stage: 'opened' | 'requested' | 'completed'): void {
-    let eventName: TelemetryEventName
-
-    switch (stage) {
-      case 'opened':
-        eventName = TelemetryEvents.USER_EMAIL_VERIFY_OPENED
-        break
-      case 'requested':
-        eventName = TelemetryEvents.USER_EMAIL_VERIFY_REQUESTED
-        break
-      case 'completed':
-        eventName = TelemetryEvents.USER_EMAIL_VERIFY_COMPLETED
-        break
-    }
-
-    this.trackEvent(eventName)
-  }
-
   trackTemplate(metadata: TemplateMetadata): void {
     this.trackEvent(TelemetryEvents.TEMPLATE_WORKFLOW_OPENED, metadata)
   }

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

@@ -450,10 +450,7 @@ describe('PostHogTelemetryProvider', () => {
       const provider = createProvider()
       await vi.dynamicImportSettled()
 
-      provider.trackWorkflowOpened({
-        missing_node_count: 0,
-        missing_node_types: []
-      })
+      provider.trackPageVisibilityChanged({ visibility_state: 'hidden' })
 
       expect(hoisted.mockCapture).not.toHaveBeenCalled()
     })