feat: enrich assign_server_event with outcome and configuration

Captures the requested configuration (variant, accelerator, shape,
version), whether one or more fallback accelerators were attempted,
and the final outcome via a new nested `AssignmentOutcome` enum
distinguishing success from
`ASSIGNMENT_OUTCOME_ACCELERATOR_UNAVAILABLE`,
`ASSIGNMENT_OUTCOME_ALL_ACCELERATORS_UNAVAILABLE`,
`ASSIGNMENT_OUTCOME_TOO_MANY_ASSIGNMENTS`,
`ASSIGNMENT_OUTCOME_INSUFFICIENT_QUOTA`,
`ASSIGNMENT_OUTCOME_DENYLISTED`, and
`ASSIGNMENT_OUTCOME_OTHER_FAILURE`. The enum is intentionally
distinct from the top-level `Outcome` enum to avoid name
collisions in generated code.

`hadFallback` is derived in `assignServer` by comparing the
returned assignment's accelerator to the requested one (success
path), or by checking the thrown
`AllAcceleratorsUnavailableError`'s `attempted` array length
(failure path).

Author: kevineger

src/jupyter/assignments.ts

@@ -38,7 +38,7 @@ import {
 } from '../colab/headers';
 import { log } from '../common/logging';
 import { telemetry } from '../telemetry';
-import { CommandSource } from '../telemetry/api';
+import { AssignmentOutcome, CommandSource } from '../telemetry/api';
 import { ProxiedJupyterClient } from './client';
 import { colabProxyWebSocket } from './colab-proxy-websocket';
 import {
@@ -327,60 +327,76 @@ export class AssignmentManager implements Disposable {
     this.guardDisposed();
     const id = randomUUID();
     const { label, variant, accelerator, shape, version } = descriptor;
-    let assignment: Assignment;
+    let outcome = AssignmentOutcome.ASSIGNMENT_OUTCOME_UNSPECIFIED;
+    let hadFallback = false;
     try {
-      if (isColabServerDescriptorWithAccelerator(descriptor)) {
-        assignment = await this.assignWithFallback(
-          id,
-          descriptor,
-          /* fallbacks= */ undefined,
-          signal,
-        );
-      } else {
-        ({ assignment } = await this.client.assign(
-          id,
-          { variant, accelerator, shape, version },
-          signal,
-        ));
-      }
-    } catch (error) {
-      log.trace(`Failed assigning server ${id}`, error);
-      if (error instanceof AllAcceleratorsUnavailableError) {
-        void this.notifyAllAcceleratorsUnavailable(error);
-      }
-      // TODO: Consider listing assignments to check if there are too many
-      // before the user goes through the assignment flow. This handling logic
-      // would still be needed for the rare race condition where an assignment
-      // is made (e.g. in Colab web) during the extension assignment flow.
-      if (error instanceof TooManyAssignmentsError) {
-        void this.notifyMaxAssignmentsExceeded();
-      }
-      if (error instanceof InsufficientQuotaError) {
-        void this.notifyInsufficientQuota(error);
-      }
-      if (error instanceof DenylistedError) {
-        this.notifyBanned(error);
+      let assignment: Assignment;
+      try {
+        if (isColabServerDescriptorWithAccelerator(descriptor)) {
+          assignment = await this.assignWithFallback(
+            id,
+            descriptor,
+            /* fallbacks= */ undefined,
+            signal,
+          );
+          hadFallback = assignment.accelerator !== descriptor.accelerator;
+        } else {
+          ({ assignment } = await this.client.assign(
+            id,
+            { variant, accelerator, shape, version },
+            signal,
+          ));
+        }
+      } catch (error) {
+        log.trace(`Failed assigning server ${id}`, error);
+        outcome = errorToAssignmentOutcome(error);
+        if (error instanceof AllAcceleratorsUnavailableError) {
+          hadFallback = error.attempted.length > 1;
+          void this.notifyAllAcceleratorsUnavailable(error);
+        }
+        // TODO: Consider listing assignments to check if there are too many
+        // before the user goes through the assignment flow. This handling logic
+        // would still be needed for the rare race condition where an assignment
+        // is made (e.g. in Colab web) during the extension assignment flow.
+        if (error instanceof TooManyAssignmentsError) {
+          void this.notifyMaxAssignmentsExceeded();
+        }
+        if (error instanceof InsufficientQuotaError) {
+          void this.notifyInsufficientQuota(error);
+        }
+        if (error instanceof DenylistedError) {
+          this.notifyBanned(error);
+        }
+        throw error;
       }
-      throw error;
+      const server = this.toAssignedServer(
+        {
+          id,
+          label,
+          variant: assignment.variant,
+          accelerator: assignment.accelerator,
+        },
+        assignment.endpoint,
+        assignment.runtimeProxyInfo,
+        new Date(),
+      );
+      await this.storage.store([server]);
+      this.assignmentChange.fire({
+        added: [server],
+        removed: [],
+        changed: [],
+      });
+      outcome = AssignmentOutcome.ASSIGNMENT_OUTCOME_SUCCEEDED;
+      return server;
+    } finally {
+      telemetry.logAssignServer(outcome, {
+        variant,
+        accelerator: accelerator ?? '',
+        shape: shape !== undefined ? Shape[shape] : '',
+        version: version ?? '',
+        hadFallback,
+      });
     }
-    const server = this.toAssignedServer(
-      {
-        id,
-        label,
-        variant: assignment.variant,
-        accelerator: assignment.accelerator,
-      },
-      assignment.endpoint,
-      assignment.runtimeProxyInfo,
-      new Date(),
-    );
-    await this.storage.store([server]);
-    this.assignmentChange.fire({
-      added: [server],
-      removed: [],
-      changed: [],
-    });
-    return server;
   }
 
   /**
@@ -854,3 +870,22 @@ function isColabServerDescriptorWithAccelerator(
 ): descriptor is ColabServerDescriptorWithAccelerator {
   return !!descriptor.accelerator;
 }
+
+function errorToAssignmentOutcome(error: unknown): AssignmentOutcome {
+  if (error instanceof AllAcceleratorsUnavailableError) {
+    return AssignmentOutcome.ASSIGNMENT_OUTCOME_ALL_ACCELERATORS_UNAVAILABLE;
+  }
+  if (error instanceof AcceleratorUnavailableError) {
+    return AssignmentOutcome.ASSIGNMENT_OUTCOME_ACCELERATOR_UNAVAILABLE;
+  }
+  if (error instanceof TooManyAssignmentsError) {
+    return AssignmentOutcome.ASSIGNMENT_OUTCOME_TOO_MANY_ASSIGNMENTS;
+  }
+  if (error instanceof InsufficientQuotaError) {
+    return AssignmentOutcome.ASSIGNMENT_OUTCOME_INSUFFICIENT_QUOTA;
+  }
+  if (error instanceof DenylistedError) {
+    return AssignmentOutcome.ASSIGNMENT_OUTCOME_DENYLISTED;
+  }
+  return AssignmentOutcome.ASSIGNMENT_OUTCOME_OTHER_FAILURE;
+}