ref(github): Cache full repo list and filter locally instead of Search API

Switch from Search API + cached ID set to caching the full repo list
and filtering locally. This avoids the Search API's shared 30 req/min
rate limit and uses sentry.cache.default_cache (Redis-backed) instead
of django.core.cache (DummyCache in Sentry).

Refs VDY-68

Author: jaydgoss

src/sentry/integrations/github/client.py

@@ -8,9 +8,9 @@
 
 import orjson
 import sentry_sdk
-from django.core.cache import cache
 from requests import PreparedRequest
 
+from sentry.cache import default_cache
 from sentry.constants import ObjectStatus
 from sentry.integrations.github.blame import (
     create_blame_query,
@@ -550,21 +550,33 @@ def get_repos(self, page_number_limit: int | None = None) -> list[dict[str, Any]
                 page_number_limit=page_number_limit,
             )
 
-    def get_accessible_repo_ids(self, ttl: int = 300) -> set[int]:
+    def get_accessible_repos_cached(self, ttl: int = 300) -> list[dict[str, Any]]:
         """
-        Return the set of GitHub repo IDs accessible to this installation.
-        Cached in Django cache (Redis) for ``ttl`` seconds to avoid
-        re-fetching all pages on every keystroke.
+        Return all non-archived repos accessible to this installation.
+        Cached in Django cache for ``ttl`` seconds so that debounced
+        search keystrokes don't re-fetch all pages from GitHub.
         """
-        cache_key = f"github:accessible_repo_ids:{self.integration.id}"
-        cached = cache.get(cache_key)
+        cache_key = f"github:accessible_repos:{self.integration.id}"
+        cached = default_cache.get(cache_key)
         if cached is not None:
-            return set(cached)
+            logger.info(
+                "get_accessible_repos_cached.cache_hit",
+                extra={"integration_id": self.integration.id, "count": len(cached)},
+            )
+            return cached
 
+        logger.info(
+            "get_accessible_repos_cached.cache_miss",
+            extra={"integration_id": self.integration.id},
+        )
         all_repos = self.get_repos()
-        repo_ids = {r["id"] for r in all_repos if not r.get("archived")}
-        cache.set(cache_key, list(repo_ids), ttl)
-        return repo_ids
+        repos = [r for r in all_repos if not r.get("archived")]
+        default_cache.set(cache_key, repos, ttl)
+        logger.info(
+            "get_accessible_repos_cached.cached",
+            extra={"integration_id": self.integration.id, "count": len(repos)},
+        )
+        return repos
 
     def search_repositories(self, query: bytes) -> Mapping[str, Sequence[Any]]:
         """

src/sentry/integrations/github/integration.py

@@ -352,20 +352,21 @@ def get_repositories(
                 if not i.get("archived")
             ]
 
-        # Query + accessible_only: use Search API + cached ID set
+        # Query + accessible_only: filter cached repo list locally.
+        # Avoids re-fetching all pages on every debounced keystroke and
+        # avoids the Search API's 30 req/min shared rate limit.
         if accessible_only:
-            accessible_ids = client.get_accessible_repo_ids()
-            full_query = build_repository_query(self.model.metadata, self.model.name, query)
-            response = client.search_repositories(full_query)
+            all_repos = client.get_accessible_repos_cached()
+            query_lower = query.lower()
             return [
                 {
                     "name": i["name"],
                     "identifier": i["full_name"],
                     "external_id": self.get_repo_external_id(i),
                     "default_branch": i.get("default_branch"),
                 }
-                for i in response.get("items", [])
-                if i["id"] in accessible_ids
+                for i in all_repos
+                if query_lower in i["full_name"].lower()
             ]
 
         # Query without accessible_only: existing search behavior

tests/sentry/integrations/github/test_integration.py

@@ -679,40 +679,16 @@ def test_get_repositories_search_param(self) -> None:
 
     @responses.activate
     def test_get_repositories_accessible_only(self) -> None:
-        """accessible_only+query uses Search API filtered by cached accessible IDs."""
+        """accessible_only+query filters cached repo list locally."""
         with self.tasks():
             self.assert_setup_flow()
 
-        querystring = urlencode({"q": "fork:true org:Test Organization foo"})
-        responses.add(
-            responses.GET,
-            f"{self.base_url}/search/repositories?{querystring}",
-            json={
-                "items": [
-                    {
-                        "id": 1296269,
-                        "name": "foo",
-                        "full_name": "Test-Organization/foo",
-                        "default_branch": "master",
-                    },
-                    {
-                        "id": 9999999,
-                        "name": "foo-external",
-                        "full_name": "Other-Org/foo-external",
-                        "default_branch": "main",
-                    },
-                ]
-            },
-        )
-
         integration = Integration.objects.get(provider=self.provider.key)
         installation = get_installation_of_type(
             GitHubIntegration, integration, self.organization.id
         )
 
         result = installation.get_repositories("foo", accessible_only=True)
-        # foo-external is filtered out: its id (9999999) is the archived repo's id,
-        # which is excluded from the accessible set
         assert result == [
             {
                 "name": "foo",
@@ -724,17 +700,10 @@ def test_get_repositories_accessible_only(self) -> None:
 
     @responses.activate
     def test_get_repositories_accessible_only_no_match(self) -> None:
-        """When accessible_only=True and search returns no accessible repos, returns empty list."""
+        """accessible_only+query with no matching repos returns empty list."""
         with self.tasks():
             self.assert_setup_flow()
 
-        querystring = urlencode({"q": "fork:true org:Test Organization nonexistent"})
-        responses.add(
-            responses.GET,
-            f"{self.base_url}/search/repositories?{querystring}",
-            json={"items": []},
-        )
-
         integration = Integration.objects.get(provider=self.provider.key)
         installation = get_installation_of_type(
             GitHubIntegration, integration, self.organization.id
@@ -744,41 +713,25 @@ def test_get_repositories_accessible_only_no_match(self) -> None:
         assert result == []
 
     @responses.activate
-    def test_get_repositories_accessible_only_caches_ids(self) -> None:
-        """Second accessible_only call uses cached IDs instead of re-fetching all repos."""
+    def test_get_repositories_accessible_only_caches_repos(self) -> None:
+        """Second accessible_only call uses cached repos instead of re-fetching from GitHub."""
         with self.tasks():
             self.assert_setup_flow()
 
-        querystring = urlencode({"q": "fork:true org:Test Organization foo"})
-        responses.add(
-            responses.GET,
-            f"{self.base_url}/search/repositories?{querystring}",
-            json={
-                "items": [
-                    {
-                        "id": 1296269,
-                        "name": "foo",
-                        "full_name": "Test-Organization/foo",
-                        "default_branch": "master",
-                    },
-                ]
-            },
-        )
-
         integration = Integration.objects.get(provider=self.provider.key)
         installation = get_installation_of_type(
             GitHubIntegration, integration, self.organization.id
         )
 
-        # First call: cache miss, fetches /installation/repositories + search
+        # First call: cache miss, fetches /installation/repositories
         result1 = installation.get_repositories("foo", accessible_only=True)
         install_repo_calls = [
             c for c in responses.calls if "/installation/repositories" in c.request.url
         ]
         first_fetch_count = len(install_repo_calls)
         assert first_fetch_count > 0
 
-        # Second call: cache hit, only search is called (no new /installation/repositories)
+        # Second call: cache hit, no new /installation/repositories calls
         result2 = installation.get_repositories("foo", accessible_only=True)
         install_repo_calls = [
             c for c in responses.calls if "/installation/repositories" in c.request.url