fix(event): Prevent immediate retry of rate-limited org in event view fallback (#1566)

This PR fixes an issue where the `sentry event view` command could
trigger a "Consecutive HTTP" performance issue (CLI-2Y1).

**Root Cause:**
When `fetchEventWithContext` falls back to `tryEventFallbacks` and
`resolveEventInOrg` hits a 429 (Too Many Requests) rate limit, the error
was caught as a generic transient failure. This left `sameOrgSearched`
as `false`, causing the subsequent `findEventAcrossOrgs` call to
immediately retry the exact same rate-limited endpoint for the same
organization. This back-to-back identical request against a rate-limited
API endpoint caused the performance issue.

**Solution:**
1. Introduce an `orgRateLimited` flag in `tryEventFallbacks`.
2. When `resolveEventInOrg` catches an `ApiError` with status 429, set
`orgRateLimited = true`.
3. Modify the `excludeOrgs` logic for `findEventAcrossOrgs` to exclude
the organization if `sameOrgSearched` is true (meaning a definitive
not-found) OR if `orgRateLimited` is true. This prevents futile
immediate retries against rate-limited endpoints.
4. Added a `logger.debug` call to the catch block to satisfy the
`no-silent-catch` lint rule.

**Verification:**
Added a unit test to `test/commands/event/view.test.ts` to specifically
cover the 429 rate-limit scenario, ensuring the organization is
correctly excluded from the cross-org fallback.

Fixes
[CLI-2Y1](https://sentry.sentry.io/issues/7721257760/?seerDrawer=true)

<sub>`@sentry <feedback>`: Autofix iterates on these changes</sub>
<sub>`@sentry stop iterating`: Autofix stops iterating on this run</sub>

<sub>This PR was automatically generated by Sentry. You can [adjust this
setting](https://sentry.sentry.io/settings/projects/cli/seer/) at any
time.</sub>

Co-authored-by: sentry[bot] <39604003+sentry[bot]@users.noreply.github.com>

Author: sentry[bot]

src/commands/event/view.ts

@@ -703,6 +703,10 @@ async function tryEventFallbacks(
   // Track whether the search completed so we can skip the org in cross-org
   // only when we got a definitive "not found" (not a transient failure).
   let sameOrgSearched = false;
+  // Track rate-limit separately: a 429 means the org is reachable but throttled.
+  // Retrying it immediately in the cross-org fallback would just hit the same
+  // limit again, producing consecutive identical HTTP requests (CLI-2Y1).
+  let orgRateLimited = false;
   try {
     const resolved = await resolveEventInOrg(org, eventId);
     sameOrgSearched = true;
@@ -717,15 +721,20 @@ async function tryEventFallbacks(
     if (sameOrgError instanceof AuthError) {
       throw sameOrgError;
     }
-    // Transient failure — don't mark org as searched so cross-org retries it
+    if (sameOrgError instanceof ApiError && sameOrgError.status === 429) {
+      // Rate-limited — exclude the org from cross-org search; an immediate
+      // retry against the same endpoint would hit the same limit.
+      orgRateLimited = true;
+    }
+    logger.debug("Same-org event lookup failed", sameOrgError);
   }
 
   // Cross-org fallback: the event may exist in a different organization.
-  // Only exclude the org if the same-org search completed successfully
-  // (returned null). If it threw a transient error, let cross-org retry it.
+  // Exclude the org when the same-org search completed (returned null) OR
+  // when it was rate-limited — either way, re-querying it immediately is futile.
   try {
     const crossOrg = await findEventAcrossOrgs(eventId, {
-      excludeOrgs: sameOrgSearched ? [org] : undefined,
+      excludeOrgs: sameOrgSearched || orgRateLimited ? [org] : undefined,
     });
     if (crossOrg) {
       // Use project-scoped phrasing when found in same org (different project)

test/commands/event/view.test.ts

@@ -1370,6 +1370,29 @@ describe("fetchEventWithContext", () => {
     });
   });
 
+  test("cross-org excludes org when same-org search was rate-limited (429)", async () => {
+    vi.spyOn(apiClient, "getEvent").mockRejectedValue(
+      new ApiError("Not found", 404)
+    );
+    // Same-org search hit a rate limit — retrying it immediately is futile (CLI-2Y1)
+    vi.spyOn(apiClient, "resolveEventInOrg").mockRejectedValue(
+      new ApiError("Too Many Requests", 429)
+    );
+    const findSpy = vi
+      .spyOn(apiClient, "findEventAcrossOrgs")
+      .mockResolvedValue(null);
+
+    await expect(
+      fetchEventWithContext(null, "my-org", "my-project", "abc123")
+    ).rejects.toThrow(ResolutionError);
+
+    // org must be excluded — re-querying a rate-limited endpoint immediately
+    // produces consecutive identical HTTP requests (the Consecutive HTTP issue).
+    expect(findSpy).toHaveBeenCalledWith("abc123", {
+      excludeOrgs: ["my-org"],
+    });
+  });
+
   test("swallows non-auth cross-org errors and throws ResolutionError", async () => {
     vi.spyOn(apiClient, "getEvent").mockRejectedValue(
       new ApiError("Not found", 404)