fix(integrations): Handle null items in organization integrations serialization

The OrganizationIntegrationSerializer could produce null entries in API
responses when per-item serialization failed. The _serialize catch-all
in base.py swallowed exceptions and returned None, which was included
directly in the response list, crashing the frontend.

- Use .get() in get_attrs to handle missing Integration records
  gracefully instead of KeyError-ing the entire request
- Add null guards for missing integration and failed inner serialization
- Catch broad exceptions in get_installation and installation methods
  with specific log messages instead of relying on the generic
  _serialize catch-all
- Filter null items from both organization-integrations endpoints

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: leeandher

src/sentry/api/endpoints/user_organizationintegrations.py

@@ -53,6 +53,6 @@ def get(self, request: Request, user) -> Response:
         return self.paginate(
             request=request,
             queryset=queryset,
-            on_results=lambda x: serialize(x, request.user),
+            on_results=lambda x: [item for item in serialize(x, request.user) if item is not None],
             paginator_cls=OffsetPaginator,
         )

src/sentry/integrations/api/endpoints/organization_integrations_index.py

@@ -125,7 +125,11 @@ def get(
         def on_results(results: Sequence[OrganizationIntegration]) -> Sequence[Mapping[str, Any]]:
             if feature_filters:
                 results = filter_by_features(results, feature_filters)
-            return serialize(results, request.user, include_config=include_config)
+            return [
+                item
+                for item in serialize(results, request.user, include_config=include_config)
+                if item is not None
+            ]
 
         return self.paginate(
             queryset=queryset,

src/sentry/integrations/api/serializers/models/integration.py

@@ -135,7 +135,7 @@ def get_attrs(
         )
         integrations_by_id: dict[int, RpcIntegration] = {i.id: i for i in integrations}
         return {
-            item: {"integration": integrations_by_id[item.integration_id]} for item in item_list
+            item: {"integration": integrations_by_id.get(item.integration_id)} for item in item_list
         }
 
     def serialize(
@@ -145,27 +145,40 @@ def serialize(
         user: User | RpcUser | AnonymousUser,
         include_config: bool = True,
         **kwargs: Any,
-    ) -> MutableMapping[str, Any]:
+    ) -> MutableMapping[str, Any] | None:
+        logging_name = "sentry.serializers.model.organizationintegration"
+        logging_ctx = {"organization_integration_id": obj.id, "integration_id": obj.integration_id}
         # XXX(epurkhiser): This is O(n) for integrations, especially since
         # we're using the IntegrationConfigSerializer which pulls in the
         # integration installation config object which very well may be making
         # API request for config options.
-        integration: RpcIntegration = attrs.get("integration")  # type: ignore[assignment]
+        integration: RpcIntegration | None = attrs.get("integration")
+        if integration is None:
+            logger.warning(f"{logging_name}.missing_integration", extra=logging_ctx)
+            return None
+
         serialized_integration: MutableMapping[str, Any] = serialize(
             objects=integration,
             user=user,
             serializer=IntegrationConfigSerializer(obj.organization_id, params=self.params),
             include_config=include_config,
         )
+        if serialized_integration is None:
+            logger.warning(f"{logging_name}.serialize_integration_failed", extra=logging_ctx)
+            return None
 
         dynamic_display_information = None
         config_data = None
+        logging_ctx["provider"] = integration.provider
 
         try:
             installation = integration.get_installation(organization_id=obj.organization_id)
         except NotImplementedError:
             # slack doesn't have an installation implementation
             config_data = obj.config if include_config else None
+        except Exception:
+            logger.exception(f"{logging_name}.get_installation_failed", extra=logging_ctx)
+            config_data = obj.config if include_config else None
         else:
             try:
                 installation.org_integration = obj
@@ -183,6 +196,8 @@ def serialize(
                     "integration_provider": integration.provider,
                 }
                 logger.info(name, extra=log_info)
+            except Exception:
+                logger.exception(f"{logging_name}.serialize_installation_failed", extra=logging_ctx)
 
         serialized_integration.update(
             {

tests/sentry/integrations/api/endpoints/test_user_organizationintegration.py

@@ -2,6 +2,7 @@
 
 import orjson
 
+from sentry.integrations.models.integration import Integration
 from sentry.testutils.cases import APITestCase
 from sentry.testutils.silo import control_silo_test
 
@@ -72,3 +73,32 @@ def test_billing_users_dont_see_integrations(self) -> None:
             assert response.status_code == 200
             content = orjson.loads(response.content)
             assert content == []
+
+    def test_missing_integration_filtered_from_response(self) -> None:
+        """OrganizationIntegrations whose Integration was deleted don't produce null entries."""
+        integration = self.create_provider_integration(provider="github")
+        self.create_organization_integration(
+            organization_id=self.organization.id, integration_id=integration.id
+        )
+
+        # Delete the Integration row directly to simulate orphaned state
+        Integration.objects.filter(id=integration.id).delete()
+
+        response = self.get_success_response(self.user.id)
+        assert response.data == []
+
+    def test_installation_error_still_returns_item(self) -> None:
+        """An exception in get_dynamic_display_information shouldn't null out the item."""
+        integration = self.create_provider_integration(provider="github")
+        self.create_organization_integration(
+            organization_id=self.organization.id, integration_id=integration.id
+        )
+
+        with patch(
+            "sentry.integrations.base.IntegrationInstallation.get_dynamic_display_information",
+            side_effect=RuntimeError("boom"),
+        ):
+            response = self.get_success_response(self.user.id)
+
+        assert len(response.data) == 1
+        assert response.data[0]["organizationId"] == self.organization.id