perf(issue): skip getProject round-trip in project-search resolution (#473)

betegon · claude · BYK · web-flow · commit 0ac022e014c2 · 2026-03-19T22:01:45.000Z
## Summary When resolving a project-search issue argument (e.g., `sentry issue view acme-web-4F2K`), `resolveProjectSearch()` was doing two sequential API steps: `findProjectsBySlug()` (calls `getProject` per org) then `getIssueByShortId()`. Since the shortid endpoint already validates both project and issue existence, the `getProject` call is redundant. Now tries `tryGetIssueByShortId()` directly across all orgs in parallel, saving one HTTP round-trip (~500-800ms). Falls back to `findProjectsBySlug()` only when all orgs 404, so error messages stay specific. Addresses [CLI-EV](https://sentry.sentry.io/issues/7340600304/) (Consecutive HTTP performance issue). ## Example: `sentry issue view acme-web-4F2K` **Before** (6 sequential HTTP calls, ~3.5s): ``` resolveProjectSearch("acme-web", "4F2K") | +- tryResolveFromAlias() <-- cache miss +- resolveFromDsn() <-- no DSN match | +- findProjectsBySlug("acme-web") | +- listOrganizations() | | +- GET /users/me/regions/ ~273ms --+ | | +- GET /organizations/ ~619ms | sequential | | | | +- Promise.all(orgs.map(getProject)) | | +- GET /projects/acme-corp/acme-web/ ~783ms | | +- getIssueByShortId("acme-corp", ...) | | +- GET /shortids/ACME-WEB-4F2K/ ~581ms | | | +- tryGetLatestEvent() | | +- GET /issues/{id}/events/latest/ ~544ms | | | +- getSpanTreeLines() | +- GET /trace/{trace_id}/ ~539ms --+ total: ~3.3s HTTP ``` **After** (5 sequential HTTP calls, ~2.5s): ``` resolveProjectSearch("acme-web", "4F2K") | +- tryResolveFromAlias() <-- cache miss +- resolveFromDsn() <-- no DSN match | +- listOrganizations() | +- GET /users/me/regions/ ~273ms --+ | +- GET /organizations/ ~619ms | | | +- Promise.all(orgs.map(tryGetIssueByShortId)) <-- skips getProject | +- GET /shortids/ACME-WEB-4F2K/ ~581ms | one fewer | | round-trip +- tryGetLatestEvent() | | +- GET /issues/{id}/events/latest/ ~544ms | | | +- getSpanTreeLines() | +- GET /trace/{trace_id}/ ~539ms --+ total: ~2.5s HTTP saved: ~783ms ``` With a warm org cache (the common case after PR #446), the regions + organizations calls are instant, bringing the total down further. ## Changes ### Performance - `src/lib/api/issues.ts` -- add `tryGetIssueByShortId()` (returns null on 404 instead of throwing) - `src/lib/api-client.ts` -- barrel export - `src/commands/issue/utils.ts` -- rewrite `resolveProjectSearch()`: fan out shortid lookups directly across all orgs in parallel, skipping the intermediate `getProject()` call ### Error handling - Surface real API errors (403, 5xx) and network errors when every org fails, instead of masking them with "not found" - Only throw when ALL orgs returned real errors -- a 403 from an unrelated org does not preempt the fallback when other orgs returned clean 404s - Retry `getIssueByShortId` when the fallback finds the project (handles transient failures from the fast path) - Extract `resolveProjectSearchFallback()` to stay under cognitive complexity lint limit ## Test plan - `bun run typecheck` passes - `bun run lint` passes (complexity now under 15) - `bun test --filter "issue"` -- all 137 tests pass - Manual: `sentry issue view <project>-<suffix>` resolves without the extra `getProject` call --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com> Co-authored-by: Burak Yigit Kaya <byk@sentry.io>
diff --git a/src/commands/issue/utils.ts b/src/commands/issue/utils.ts
@@ -12,12 +12,20 @@ import {
   getIssueInOrg,
   type IssueSort,
   listIssuesPaginated,
+  listOrganizations,
   triggerRootCauseAnalysis,
+  tryGetIssueByShortId,
 } from "../../lib/api-client.js";
 import { type IssueSelector, parseIssueArg } from "../../lib/arg-parsing.js";
 import { getProjectByAlias } from "../../lib/db/project-aliases.js";
 import { detectAllDsns } from "../../lib/dsn/index.js";
-import { ApiError, ContextError, ResolutionError } from "../../lib/errors.js";
+import {
+  ApiError,
+  type AuthGuardFailure,
+  ContextError,
+  ResolutionError,
+  withAuthGuard,
+} from "../../lib/errors.js";
 import { getProgressMessage } from "../../lib/formatters/seer.js";
 import { expandToFullShortId, isShortSuffix } from "../../lib/issue-id.js";
 import { logger } from "../../lib/logger.js";
@@ -124,12 +132,66 @@ async function tryResolveFromAlias(
   return { org: projectEntry.orgSlug, issue };
 }
 
+/**
+ * Fallback for when the fast shortid fan-out found no matches.
+ * Uses findProjectsBySlug to give a precise error ("project not found" vs
+ * "issue not found") and retries the issue lookup on transient failures.
+ */
+async function resolveProjectSearchFallback(
+  projectSlug: string,
+  suffix: string,
+  commandHint: string
+): Promise<StrictResolvedIssue> {
+  const { projects } = await findProjectsBySlug(projectSlug.toLowerCase());
+
+  if (projects.length === 0) {
+    throw new ResolutionError(
+      `Project '${projectSlug}'`,
+      "not found",
+      commandHint,
+      ["No project with this slug found in any accessible organization"]
+    );
+  }
+
+  if (projects.length > 1) {
+    const orgList = projects.map((p) => p.orgSlug).join(", ");
+    throw new ResolutionError(
+      `Project '${projectSlug}'`,
+      "is ambiguous",
+      commandHint,
+      [
+        `Found in: ${orgList}`,
+        `Specify the org: sentry issue ... <org>/${projectSlug}-${suffix}`,
+      ]
+    );
+  }
+
+  // Project exists — retry the issue lookup. The fast path may have failed
+  // due to a transient error (5xx, timeout); retrying here either succeeds
+  // or propagates the real error to the user.
+  const matchedProject = projects[0];
+  const matchedOrg = matchedProject?.orgSlug;
+  if (matchedOrg && matchedProject) {
+    const retryShortId = expandToFullShortId(suffix, matchedProject.slug);
+    const issue = await getIssueByShortId(matchedOrg, retryShortId);
+    return { org: matchedOrg, issue };
+  }
+
+  throw new ResolutionError(
+    `Project '${projectSlug}'`,
+    "not found",
+    commandHint
+  );
+}
+
 /**
  * Resolve project-search type: search for project across orgs, then fetch issue.
  *
  * Resolution order:
  * 1. Try alias cache (fast, local)
- * 2. Search for project across orgs via API
+ * 2. Check DSN detection cache
+ * 3. Try shortid endpoint directly across all orgs (fast path)
+ * 4. Fall back to findProjectsBySlug for precise error messages
  *
  * @param projectSlug - Project slug to search for
  * @param suffix - Issue suffix (uppercase)
@@ -173,20 +235,33 @@ async function resolveProjectSearch(
     return { org: dsnTarget.org, issue };
   }
 
-  // 3. Search for project across all accessible orgs
-  const { projects } = await findProjectsBySlug(projectSlug.toLowerCase());
+  // 3. Fast path: try resolving the short ID directly across all orgs.
+  //    The shortid endpoint validates both project existence and issue existence
+  //    in a single call, eliminating the separate getProject() round-trip.
+  const fullShortId = expandToFullShortId(suffix, projectSlug);
+  const orgs = await listOrganizations();
 
-  if (projects.length === 0) {
-    throw new ResolutionError(
-      `Project '${projectSlug}'`,
-      "not found",
-      commandHint,
-      ["No project with this slug found in any accessible organization"]
-    );
+  const results = await Promise.all(
+    orgs.map((org) =>
+      withAuthGuard(() => tryGetIssueByShortId(org.slug, fullShortId))
+    )
+  );
+
+  const successes: StrictResolvedIssue[] = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const org = orgs[i];
+    if (result && org && result.ok && result.value) {
+      successes.push({ org: org.slug, issue: result.value });
+    }
   }
 
-  if (projects.length > 1) {
-    const orgList = projects.map((p) => p.orgSlug).join(", ");
+  if (successes.length === 1 && successes[0]) {
+    return successes[0];
+  }
+
+  if (successes.length > 1) {
+    const orgList = successes.map((s) => s.org).join(", ");
     throw new ResolutionError(
       `Project '${projectSlug}'`,
       "is ambiguous",
@@ -198,18 +273,24 @@ async function resolveProjectSearch(
     );
   }
 
-  const project = projects[0];
-  if (!project) {
-    throw new ResolutionError(
-      `Project '${projectSlug}'`,
-      "not found",
-      commandHint
-    );
+  // If every org failed with a real error (403, 5xx, network timeout),
+  // surface it instead of falling through to a misleading "not found".
+  // Only throw when ALL results are errors — if some orgs returned clean
+  // 404s ({ok: true, value: null}), fall through to the fallback for a
+  // precise error message.
+  const realErrors = results.filter(
+    (r): r is AuthGuardFailure => r !== undefined && !r.ok
+  );
+  if (realErrors.length === results.length && realErrors.length > 0) {
+    const firstError = realErrors[0]?.error;
+    if (firstError instanceof Error) {
+      throw firstError;
+    }
   }
 
-  const fullShortId = expandToFullShortId(suffix, project.slug);
-  const issue = await getIssueByShortId(project.orgSlug, fullShortId);
-  return { org: project.orgSlug, issue };
+  // 4. Fall back to findProjectsBySlug for precise error messages
+  //    and retry the issue lookup (handles transient failures).
+  return resolveProjectSearchFallback(projectSlug, suffix, commandHint);
 }
 
 /**
diff --git a/src/lib/api-client.ts b/src/lib/api-client.ts
@@ -49,6 +49,7 @@ export {
   type IssuesPage,
   listIssuesAllPages,
   listIssuesPaginated,
+  tryGetIssueByShortId,
   updateIssueStatus,
 } from "./api/issues.js";
 export {
diff --git a/src/lib/api/issues.ts b/src/lib/api/issues.ts
@@ -251,6 +251,31 @@ export async function getIssueByShortId(
   return resolved.group;
 }
 
+/**
+ * Try to get an issue by short ID, returning null on 404.
+ *
+ * Same as {@link getIssueByShortId} but returns null instead of throwing
+ * when the short ID is not found. Useful for parallel fan-out across orgs
+ * where most will 404.
+ *
+ * @param orgSlug - Organization slug
+ * @param shortId - Full short ID (e.g., "CONSUMER-MOBILE-1QNEK")
+ * @returns The resolved issue, or null if not found in this org
+ */
+export async function tryGetIssueByShortId(
+  orgSlug: string,
+  shortId: string
+): Promise<SentryIssue | null> {
+  try {
+    return await getIssueByShortId(orgSlug, shortId);
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 404) {
+      return null;
+    }
+    throw error;
+  }
+}
+
 /**
  * Update an issue's status.
  */
diff --git a/test/commands/issue/utils.test.ts b/test/commands/issue/utils.test.ts
