chore(sentryapp): new SentryAppWebhookRequestsEndpoint control endpoint

src/sentry/api/urls.py

@@ -302,6 +302,9 @@
 from sentry.sentry_apps.api.endpoints.sentry_app_requests import SentryAppRequestsEndpoint
 from sentry.sentry_apps.api.endpoints.sentry_app_rotate_secret import SentryAppRotateSecretEndpoint
 from sentry.sentry_apps.api.endpoints.sentry_app_stats_details import SentryAppStatsEndpoint
+from sentry.sentry_apps.api.endpoints.sentry_app_webhook_requests import (
+    SentryAppWebhookRequestsEndpoint,
+)
 from sentry.sentry_apps.api.endpoints.sentry_apps import SentryAppsEndpoint
 from sentry.sentry_apps.api.endpoints.sentry_apps_stats import SentryAppsStatsEndpoint
 from sentry.sentry_apps.api.endpoints.sentry_internal_app_token_details import (
@@ -2906,6 +2909,11 @@ def create_group_urls(name_prefix: str) -> list[URLPattern | URLResolver]:
         SentryAppPublishRequestEndpoint.as_view(),
         name="sentry-api-0-sentry-app-publish-request",
     ),
+    re_path(
+        r"^(?P<sentry_app_id_or_slug>[^\/]+)/webhook-requests/$",
+        SentryAppWebhookRequestsEndpoint.as_view(),
+        name="sentry-api-0-sentry-app-webhook-requests",
+    ),
     # The following a region endpoints as interactions and request logs
     # are per-region.
     re_path(

src/sentry/conf/api_pagination_allowlist_do_not_modify.py

@@ -92,6 +92,7 @@
     "ProjectUsersEndpoint",
     "ReleaseThresholdEndpoint",
     "SentryAppRequestsEndpoint",
+    "SentryAppWebhookRequestsEndpoint",
     "SentryAppsStatsEndpoint",
     "SentryInternalAppTokensEndpoint",
     "TeamGroupsOldEndpoint",

src/sentry/sentry_apps/api/endpoints/sentry_app_webhook_requests.py

@@ -0,0 +1,136 @@
+from datetime import datetime, timezone
+
+from dateutil.parser import parse as parse_date
+from rest_framework import serializers, status
+from rest_framework.request import Request
+from rest_framework.response import Response
+
+from sentry.api.api_owners import ApiOwner
+from sentry.api.api_publish_status import ApiPublishStatus
+from sentry.api.base import control_silo_endpoint
+from sentry.api.serializers import serialize
+from sentry.models.organizationmapping import OrganizationMapping
+from sentry.sentry_apps.api.bases.sentryapps import SentryAppBaseEndpoint, SentryAppStatsPermission
+from sentry.sentry_apps.api.serializers.sentry_app_webhook_request import (
+    SentryAppWebhookRequestSerializer,
+)
+from sentry.sentry_apps.api.utils.webhook_requests import (
+    BufferedRequest,
+    DatetimeOrganizationFilterArgs,
+    get_buffer_requests_from_control,
+    get_buffer_requests_from_regions,
+)
+from sentry.sentry_apps.models.sentry_app import SentryApp
+from sentry.sentry_apps.services.app_request import SentryAppRequestFilterArgs
+from sentry.utils.sentry_apps import EXTENDED_VALID_EVENTS
+
+
+class IncomingRequestSerializer(serializers.Serializer):
+    date_format = "%Y-%m-%d %H:%M:%S"
+    eventType = serializers.ChoiceField(
+        choices=EXTENDED_VALID_EVENTS,
+        required=False,
+    )
+    errorsOnly = serializers.BooleanField(default=False, required=False)
+    organizationSlug = serializers.CharField(required=False)
+    start = serializers.DateTimeField(
+        format=date_format,
+        default=datetime.strptime("2000-01-01 00:00:00", date_format).replace(tzinfo=timezone.utc),
+        default_timezone=timezone.utc,
+        required=False,
+    )
+    end = serializers.DateTimeField(
+        format=date_format, default=None, default_timezone=timezone.utc, required=False
+    )
+
+    def validate(self, data):
+        if "start" in data and "end" in data and data["start"] > data["end"]:
+            raise serializers.ValidationError("Invalid timestamp (start must be before end).")
+        return data
+
+    def validate_end(self, end):
+        if end is None:
+            end = datetime.now(tz=timezone.utc)
+        return end
+
+
+@control_silo_endpoint
+class SentryAppWebhookRequestsEndpoint(SentryAppBaseEndpoint):
+    owner = ApiOwner.ECOSYSTEM
+    publish_status = {
+        "GET": ApiPublishStatus.EXPERIMENTAL,
+    }
+    permission_classes = (SentryAppStatsPermission,)
+
+    def get(self, request: Request, sentry_app: SentryApp) -> Response:
+        """
+        :qparam string eventType: Optionally specify a specific event type to filter requests
+        :qparam bool errorsOnly: If this is true, only return error/warning requests (300-599)
+        :qparam string organizationSlug: Optionally specify an org slug to filter requests
+        :qparam string start: Optionally specify a date to begin at. Format must be YYYY-MM-DD HH:MM:SS
+        :qparam string end: Optionally specify a date to end at. Format must be YYYY-MM-DD HH:MM:SS
+        """
+        serializer = IncomingRequestSerializer(data=request.GET)
+        if not serializer.is_valid():
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        serialized = serializer.validated_data
+
+        event_type = serialized.get("eventType")
+        errors_only = serialized.get("errorsOnly")
+        org_slug = serialized.get("organizationSlug")
+        start_time = serialized.get("start")
+        end_time = serialized.get("end")
+
+        organization = None
+        if org_slug:
+            try:
+                organization = OrganizationMapping.objects.get(slug=org_slug)
+            except OrganizationMapping.DoesNotExist:
+                return Response({"detail": "Invalid organization."}, status=400)
+
+        requests: list[BufferedRequest] = []
+        control_filter: SentryAppRequestFilterArgs = {}
+        region_filter: SentryAppRequestFilterArgs = {}
+        control_filter["errors_only"] = region_filter["errors_only"] = errors_only
+        datetime_org_filter: DatetimeOrganizationFilterArgs = {
+            "start_time": start_time,
+            "end_time": end_time,
+            "organization": organization,
+        }
+
+        # If event type is installation.created or installation.deleted, we only need to fetch requests from the control buffer
+        if event_type == "installation.created" or event_type == "installation.deleted":
+            control_filter["event"] = event_type
+            requests.extend(
+                get_buffer_requests_from_control(sentry_app, control_filter, datetime_org_filter)
+            )
+        # If event type has been specified, we only need to fetch requests from region buffers
+        elif event_type:
+            region_filter["event"] = event_type
+            requests.extend(
+                get_buffer_requests_from_regions(sentry_app.id, region_filter, datetime_org_filter)
+            )
+        else:
+            control_filter["event"] = [
+                "installation.created",
+                "installation.deleted",
+            ]
+            requests.extend(
+                get_buffer_requests_from_control(sentry_app, control_filter, datetime_org_filter)
+            )
+            region_filter["event"] = list(
+                set(EXTENDED_VALID_EVENTS)
+                - {
+                    "installation.created",
+                    "installation.deleted",
+                }
+            )
+            requests.extend(
+                get_buffer_requests_from_regions(sentry_app.id, region_filter, datetime_org_filter)
+            )
+
+        requests.sort(key=lambda x: parse_date(x.data.date), reverse=True)
+
+        return Response(
+            serialize(requests, request.user, SentryAppWebhookRequestSerializer(sentry_app))
+        )

src/sentry/sentry_apps/api/serializers/sentry_app_webhook_request.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, MutableMapping, Sequence
+from typing import Any, NotRequired, TypedDict
+
+from sentry.api.serializers import Serializer
+from sentry.hybridcloud.services.organization_mapping import (
+    RpcOrganizationMapping,
+    organization_mapping_service,
+)
+from sentry.sentry_apps.api.utils.webhook_requests import BufferedRequest
+from sentry.sentry_apps.models.sentry_app import SentryApp
+from sentry.users.models.user import User
+from sentry.users.services.user import RpcUser
+
+
+class _BufferedRequestAttrs(TypedDict):
+    organization: RpcOrganizationMapping | None
+
+
+class OrganizationResponse(TypedDict):
+    name: str
+    slug: str
+
+
+class SentryAppWebhookRequestSerializerResponse(TypedDict):
+    webhookUrl: str
+    sentryAppSlug: str
+    eventType: str
+    date: str
+    responseCode: int
+    organization: NotRequired[OrganizationResponse]
+
+
+class SentryAppWebhookRequestSerializer(Serializer):
+    def __init__(self, sentry_app: SentryApp) -> None:
+        self.sentry_app = sentry_app
+
+    def get_attrs(
+        self, item_list: Sequence[BufferedRequest], user: User | RpcUser, **kwargs: Any
+    ) -> MutableMapping[BufferedRequest, _BufferedRequestAttrs]:
+        organization_ids = {item.data.organization_id for item in item_list}
+        organizations = organization_mapping_service.get_many(organization_ids=organization_ids)
+        organizations_by_id = {organization.id: organization for organization in organizations}
+
+        return {
+            item: {
+                "organization": (
+                    organizations_by_id.get(item.data.organization_id)
+                    if item.data.organization_id
+                    else None
+                )
+            }
+            for item in item_list
+        }
+
+    def serialize(
+        self, obj: BufferedRequest, attrs: Mapping[Any, Any], user: Any, **kwargs: Any
+    ) -> SentryAppWebhookRequestSerializerResponse:
+        organization = attrs.get("organization")
+        response_code = obj.data.response_code
+
+        data: SentryAppWebhookRequestSerializerResponse = {
+            "webhookUrl": obj.data.webhook_url,
+            "sentryAppSlug": self.sentry_app.slug,
+            "eventType": obj.data.event_type,
+            "date": obj.data.date,
+            "responseCode": response_code,
+        }
+
+        if organization:
+            data["organization"] = {"name": organization.name, "slug": organization.slug}
+
+        return data

src/sentry/sentry_apps/api/utils/webhook_requests.py

@@ -0,0 +1,99 @@
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import TypedDict
+
+from sentry.models.organizationmapping import OrganizationMapping
+from sentry.sentry_apps.models.sentry_app import SentryApp
+from sentry.sentry_apps.services.app_request import RpcSentryAppRequest, SentryAppRequestFilterArgs
+from sentry.sentry_apps.services.app_request.serial import serialize_rpc_sentry_app_request
+from sentry.sentry_apps.services.app_request.service import app_request_service
+from sentry.types.region import find_all_region_names
+from sentry.utils.sentry_apps import SentryAppWebhookRequestsBuffer
+
+
+@dataclass
+class BufferedRequest:
+    id: int
+    data: RpcSentryAppRequest
+
+    def __hash__(self):
+        return self.id
+
+
+class DatetimeOrganizationFilterArgs(TypedDict):
+    start_time: datetime
+    end_time: datetime
+    organization: OrganizationMapping | None
+
+
+def _filter_by_date(request: RpcSentryAppRequest, start: datetime, end: datetime) -> bool:
+    date_str = request.date
+    if not date_str:
+        return False
+    timestamp = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S.%f+00:00").replace(
+        microsecond=0, tzinfo=timezone.utc
+    )
+    return start <= timestamp <= end
+
+
+def _filter_by_organization(
+    request: RpcSentryAppRequest, organization: OrganizationMapping | None
+) -> bool:
+    if not organization:
+        return True
+    return request.organization_id == organization.organization_id
+
+
+def filter_requests(
+    unfiltered_requests: list[RpcSentryAppRequest],
+    filter: DatetimeOrganizationFilterArgs,
+) -> list[BufferedRequest]:
+    requests: list[BufferedRequest] = []
+    for i, req in enumerate(unfiltered_requests):
+        start_time = filter.get("start_time")
+        end_time = filter.get("end_time")
+        if (
+            start_time
+            and end_time
+            and _filter_by_date(req, start_time, end_time)
+            and _filter_by_organization(req, organization=filter.get("organization"))
+        ):
+            requests.append(BufferedRequest(id=i, data=req))
+    return requests
+
+
+def get_buffer_requests_from_control(
+    sentry_app: SentryApp,
+    filter: SentryAppRequestFilterArgs,
+    datetime_org_filter: DatetimeOrganizationFilterArgs,
+) -> list[BufferedRequest]:
+    control_buffer = SentryAppWebhookRequestsBuffer(sentry_app)
+
+    event = filter.get("event", None) if filter else None
+    errors_only = filter.get("errors_only", False) if filter else False
+
+    unfiltered_requests = [
+        serialize_rpc_sentry_app_request(req)
+        for req in control_buffer.get_requests(event=event, errors_only=errors_only)
+    ]
+    return filter_requests(
+        unfiltered_requests,
+        datetime_org_filter,
+    )
+
+
+def get_buffer_requests_from_regions(
+    sentry_app_id: int,
+    filter: SentryAppRequestFilterArgs,
+    datetime_org_filter: DatetimeOrganizationFilterArgs,
+) -> list[BufferedRequest]:
+    requests: list[RpcSentryAppRequest] = []
+    for region_name in find_all_region_names():
+        buffer_requests = app_request_service.get_buffer_requests_for_region(
+            sentry_app_id=sentry_app_id,
+            region_name=region_name,
+            filter=filter,
+        )
+        if buffer_requests:
+            requests.extend(buffer_requests)
+    return filter_requests(requests, datetime_org_filter)

src/sentry/sentry_apps/services/app_request/model.py

@@ -12,10 +12,10 @@ class RpcSentryAppRequest(RpcModel):
     date: str
     response_code: int
     webhook_url: str
-    organization_id: int
+    organization_id: int | None
     event_type: str
 
 
 class SentryAppRequestFilterArgs(TypedDict, total=False):
-    event: str
+    event: str | list[str]
     errors_only: bool