internal: (studio) pass the getProjectOptions function (#32573)

Author: mschile

packages/server/lib/cloud/api/axios_middleware/transform_error.ts

@@ -13,9 +13,15 @@ export const transformError = (err: AxiosError | Error & { error?: any, statusCo
     { data: err.error, status: err.statusCode }
 
   if (isObject(data)) {
-    const body = JSON.stringify(data, null, 2)
+    let body: string | null = null
 
-    err.message = [status, body].join('\n\n')
+    try {
+      body = JSON.stringify(data, null, 2)
+    } catch (e) {
+      // do nothing
+    }
+
+    err.message = body ? [status, body].join('\n\n') : `${status}`
   }
 
   err.isApiError = true

packages/server/lib/cloud/studio/StudioLifecycleManager.ts

@@ -11,7 +11,7 @@ import { CloudRequest } from '../api/cloud_request'
 import { isRetryableError } from '../network/is_retryable_error'
 import { asyncRetry } from '../../util/async_retry'
 import { postStudioSession } from '../api/studio/post_studio_session'
-import type { StudioStatus } from '@packages/types'
+import type { StudioServerOptions, StudioStatus } from '@packages/types'
 import path from 'path'
 import os from 'os'
 import { ensureStudioBundle } from './ensure_studio_bundle'
@@ -39,7 +39,6 @@ export class StudioLifecycleManager {
   private currentStudioHash?: string
 
   private initializationParams?: {
-    projectId?: string
     cloudDataSource: CloudDataSource
     cfg: Cfg
     debugData: any
@@ -55,20 +54,17 @@ export class StudioLifecycleManager {
   /**
    * Initialize the studio manager and possibly set up protocol.
    * Also registers this instance in the data context.
-   * @param projectId The project ID
    * @param cloudDataSource The cloud data source
    * @param cfg The project configuration
    * @param debugData Debug data for the configuration
    * @param ctx Data context to register this instance with
    */
   initializeStudioManager ({
-    projectId,
     cloudDataSource,
     cfg,
     debugData,
     ctx,
   }: {
-    projectId?: string
     cloudDataSource: CloudDataSource
     cfg: Cfg
     debugData: any
@@ -77,7 +73,7 @@ export class StudioLifecycleManager {
     debug('Initializing studio manager')
 
     // Store initialization parameters for retry
-    this.initializationParams = { projectId, cloudDataSource, cfg, debugData, ctx }
+    this.initializationParams = { cloudDataSource, cfg, debugData, ctx }
 
     // Register this instance in the data context
     ctx.update((data) => {
@@ -88,48 +84,64 @@ export class StudioLifecycleManager {
 
     this.updateStatus('INITIALIZING')
 
+    const getProjectOptions = async () => {
+      const [user, config] = await Promise.all([
+        ctx.actions.auth.authApi.getUser(),
+        ctx.project.getConfig(),
+      ])
+
+      return {
+        user,
+        projectSlug: config.projectId || undefined,
+      }
+    }
+
     const studioManagerPromise = this.createStudioManager({
-      projectId,
       cloudDataSource,
       cfg,
       debugData,
+      getProjectOptions,
     }).catch(async (error) => {
       debug('Error during studio manager setup: %o', error)
 
-      const { cloudUrl, cloudHeaders } = await getCloudMetadata(cloudDataSource)
-
-      reportStudioError({
-        cloudApi: {
-          cloudUrl,
-          cloudHeaders,
-          CloudRequest,
-          isRetryableError,
-          asyncRetry,
-        },
-        studioHash: projectId,
-        projectSlug: cfg.projectId,
-        error,
-        studioMethod: 'initializeStudioManager',
-        studioMethodArgs: [],
-      })
+      try {
+        const { cloudUrl, cloudHeaders } = await getCloudMetadata(cloudDataSource)
+
+        reportStudioError({
+          cloudApi: {
+            cloudUrl,
+            cloudHeaders,
+            CloudRequest,
+            isRetryableError,
+            asyncRetry,
+          },
+          studioHash: this.currentStudioHash,
+          projectSlug: (await getProjectOptions()).projectSlug,
+          error,
+          studioMethod: 'initializeStudioManager',
+          studioMethodArgs: [],
+        })
 
-      this.updateStatus('IN_ERROR')
+        this.updateStatus('IN_ERROR')
 
-      telemetryManager.mark(BUNDLE_LIFECYCLE_MARK_NAMES.BUNDLE_LIFECYCLE_END)
-      reportTelemetry(BUNDLE_LIFECYCLE_TELEMETRY_GROUP_NAMES.COMPLETE_BUNDLE_LIFECYCLE, {
-        success: false,
-      })
+        telemetryManager.mark(BUNDLE_LIFECYCLE_MARK_NAMES.BUNDLE_LIFECYCLE_END)
+        reportTelemetry(BUNDLE_LIFECYCLE_TELEMETRY_GROUP_NAMES.COMPLETE_BUNDLE_LIFECYCLE, {
+          success: false,
+        })
+      } catch (error) {
+        debug('Error reporting studio error: %o', error)
+      }
 
       return null
     })
 
     this.studioManagerPromise = studioManagerPromise
 
     this.setupWatcher({
-      projectId,
       cloudDataSource,
       cfg,
       debugData,
+      getProjectOptions,
     })
   }
 
@@ -158,30 +170,32 @@ export class StudioLifecycleManager {
   }
 
   private async createStudioManager ({
-    projectId,
     cloudDataSource,
     cfg,
     debugData,
+    getProjectOptions,
   }: {
-    projectId?: string
     cloudDataSource: CloudDataSource
     cfg: Cfg
     debugData: any
+    getProjectOptions: StudioServerOptions['getProjectOptions']
   }): Promise<StudioManager> {
     let studioPath: string
     let studioHash: string
     let manifest: Record<string, string>
 
+    const currentProjectOptions = await getProjectOptions()
+
     initializeTelemetryReporter({
-      projectSlug: projectId,
+      projectSlug: currentProjectOptions.projectSlug,
       cloudDataSource,
     })
 
     telemetryManager.mark(BUNDLE_LIFECYCLE_MARK_NAMES.BUNDLE_LIFECYCLE_START)
 
     telemetryManager.mark(BUNDLE_LIFECYCLE_MARK_NAMES.POST_STUDIO_SESSION_START)
     const studioSession = await postStudioSession({
-      projectId,
+      projectId: currentProjectOptions.projectSlug,
     })
 
     telemetryManager.mark(BUNDLE_LIFECYCLE_MARK_NAMES.POST_STUDIO_SESSION_END)
@@ -192,22 +206,27 @@ export class StudioLifecycleManager {
       studioHash = studioSession.studioUrl.split('/').pop()?.split('.')[0] ?? ''
       studioPath = path.join(os.tmpdir(), 'cypress', 'studio', studioHash)
 
+      debug('Setting current studio hash: %s', studioHash)
       // Store the current studio hash so that we can clear the cache entry when retrying
       this.currentStudioHash = studioHash
 
       let hashLoadingPromise = StudioLifecycleManager.hashLoadingMap.get(studioHash)
 
       if (!hashLoadingPromise) {
+        debug('Ensuring studio bundle for hash: %s', studioHash)
+
         hashLoadingPromise = ensureStudioBundle({
           studioUrl: studioSession.studioUrl,
           studioPath,
-          projectId,
+          projectId: currentProjectOptions.projectSlug,
         })
 
         StudioLifecycleManager.hashLoadingMap.set(studioHash, hashLoadingPromise)
       }
 
       manifest = await hashLoadingPromise
+
+      debug('Manifest: %o', manifest)
     } else {
       studioPath = process.env.CYPRESS_LOCAL_STUDIO_PATH
       studioHash = 'local'
@@ -226,10 +245,14 @@ export class StudioLifecycleManager {
       const actualHash = crypto.createHash('sha256').update(script).digest('hex')
 
       if (!expectedHash) {
+        debug('Expected hash %s for studio server script not found in manifest: %o', expectedHash, manifest)
+
         throw new Error('Expected hash for studio server script not found in manifest')
       }
 
       if (actualHash !== expectedHash) {
+        debug('Invalid hash for studio server script: %s !== %s', actualHash, expectedHash)
+
         throw new Error('Invalid hash for studio server script')
       }
     }
@@ -244,16 +267,15 @@ export class StudioLifecycleManager {
       script,
       studioPath,
       studioHash,
-      projectSlug: projectId,
       cloudApi: {
         cloudUrl,
         cloudHeaders,
         CloudRequest,
         isRetryableError,
         asyncRetry,
       },
-      shouldEnableStudio: this.cloudStudioRequested,
       manifest,
+      getProjectOptions,
     })
 
     telemetryManager.mark(BUNDLE_LIFECYCLE_MARK_NAMES.STUDIO_MANAGER_SETUP_END)
@@ -270,7 +292,7 @@ export class StudioLifecycleManager {
       telemetryManager.mark(BUNDLE_LIFECYCLE_MARK_NAMES.STUDIO_PROTOCOL_PREPARE_START)
       await protocolManager.prepareProtocol(script, {
         runId: 'studio',
-        projectId: cfg.projectId,
+        projectId: currentProjectOptions.projectSlug,
         testingType: cfg.testingType,
         cloudApi: {
           url: routes.apiUrl,
@@ -320,15 +342,15 @@ export class StudioLifecycleManager {
   }
 
   private setupWatcher ({
-    projectId,
     cloudDataSource,
     cfg,
     debugData,
+    getProjectOptions,
   }: {
-    projectId?: string
     cloudDataSource: CloudDataSource
     cfg: Cfg
     debugData: any
+    getProjectOptions: StudioServerOptions['getProjectOptions']
   }) {
     // Don't setup a watcher if the studio bundle is NOT local
     if (!process.env.CYPRESS_LOCAL_STUDIO_PATH) {
@@ -348,10 +370,10 @@ export class StudioLifecycleManager {
       await this.studioManager?.destroy()
       this.studioManager = undefined
       this.studioManagerPromise = this.createStudioManager({
-        projectId,
         cloudDataSource,
         cfg,
         debugData,
+        getProjectOptions,
       }).then((studioManager) => {
         // eslint-disable-next-line no-console
         console.log('Studio manager reloaded')

packages/server/lib/cloud/studio/studio.ts

@@ -1,4 +1,4 @@
-import type { StudioManagerShape, StudioStatus, StudioServerDefaultShape, StudioServerShape, ProtocolManagerShape, StudioCloudApi, StudioAIInitializeOptions, StudioEvent, StudioAddSocketListenersOptions } from '@packages/types'
+import type { StudioManagerShape, StudioStatus, StudioServerDefaultShape, StudioServerShape, ProtocolManagerShape, StudioCloudApi, StudioAIInitializeOptions, StudioEvent, StudioAddSocketListenersOptions, StudioServerOptions } from '@packages/types'
 import type { Router } from 'express'
 import Debug from 'debug'
 import { requireScript } from '../require_script'
@@ -13,10 +13,9 @@ interface SetupOptions {
   script: string
   studioPath: string
   studioHash?: string
-  projectSlug?: string
   cloudApi: StudioCloudApi
-  shouldEnableStudio: boolean
   manifest: Record<string, string>
+  getProjectOptions: StudioServerOptions['getProjectOptions']
 }
 
 const debug = Debug('cypress:server:studio')
@@ -27,30 +26,12 @@ export class StudioManager implements StudioManagerShape {
   private _studioServer: StudioServerShape | undefined
   private _studioElectron: StudioElectron | undefined
 
-  static createInErrorManager ({ cloudApi, studioHash, projectSlug, error, studioMethod, studioMethodArgs }: ReportStudioErrorOptions): StudioManager {
-    const manager = new StudioManager()
-
-    manager.status = 'IN_ERROR'
-
-    reportStudioError({
-      cloudApi,
-      studioHash,
-      projectSlug,
-      error,
-      studioMethod,
-      studioMethodArgs,
-    })
-
-    return manager
-  }
-
-  async setup ({ script, studioPath, studioHash, projectSlug, cloudApi, shouldEnableStudio, manifest }: SetupOptions): Promise<void> {
+  async setup ({ script, studioPath, studioHash, cloudApi, manifest, getProjectOptions }: SetupOptions): Promise<void> {
     const { createStudioServer } = requireScript<StudioServer>(script).default
 
     this._studioServer = await createStudioServer({
       studioHash,
       studioPath,
-      projectSlug,
       cloudApi,
       betterSqlite3Path: path.dirname(require.resolve('better-sqlite3/package.json')),
       manifest,
@@ -65,9 +46,10 @@ export class StudioManager implements StudioManagerShape {
 
         return actualHash === expectedHash
       },
+      getProjectOptions,
     })
 
-    this.status = shouldEnableStudio ? 'ENABLED' : 'INITIALIZED'
+    this.status = 'ENABLED'
   }
 
   initializeRoutes (router: Router): void {
@@ -79,10 +61,8 @@ export class StudioManager implements StudioManagerShape {
   async captureStudioEvent (event: StudioEvent): Promise<void> {
     if (this._studioServer) {
       // this request is not essential - we don't want studio to error out if a telemetry request fails
-      return (await this.invokeAsync('captureStudioEvent', { isEssential: false }, event))
+      await this.invokeAsync('captureStudioEvent', { isEssential: false }, event)
     }
-
-    return Promise.resolve()
   }
 
   addSocketListeners (options: StudioAddSocketListenersOptions): void {