feat(perf-issues): initialize giant http payload detector (#47264)

Initializes the giant http payload detector. This is a simple detector
that just compares the payload size to a threshold (10mb).
We won't be able to detect issues from this as the SDK changes to get
the payload size for fetch and xhr is not in place, but putting this in
place to have it ready.

---------

Co-authored-by: George Gritsouk <[email protected]>

Author: DominikB2014

src/sentry/conf/server.py

@@ -1272,6 +1272,8 @@ def SOCIAL_AUTH_DEFAULT_USERNAME():
     "organizations:performance-consecutive-db-issue": False,
     # Enable consecutive http performance issue type
     "organizations:performance-consecutive-http-detector": False,
+    # Enable consecutive http performance issue type
+    "organizations:performance-large-http-payload-detector": False,
     # Enable slow DB performance issue type
     "organizations:performance-slow-db-issue": False,
     # Enable N+1 API Calls performance issue type

src/sentry/issues/grouptype.py

@@ -284,6 +284,14 @@ class PerformanceDBMainThreadGroupType(PerformanceGroupTypeDefaults, GroupType):
     category = GroupCategory.PERFORMANCE.value
 
 
+@dataclass(frozen=True)
+class PerformanceLargeHTTPPayloadGroupType(PerformanceGroupTypeDefaults, GroupType):
+    type_id = 1015
+    slug = "performance_large_http_payload"
+    description = "Large HTTP payload"
+    category = GroupCategory.PERFORMANCE.value
+
+
 @dataclass(frozen=True)
 class ProfileFileIOGroupType(GroupType):
     type_id = 2001

src/sentry/utils/performance_issues/base.py

@@ -16,6 +16,7 @@
     PerformanceConsecutiveHTTPQueriesGroupType,
     PerformanceDBMainThreadGroupType,
     PerformanceFileIOMainThreadGroupType,
+    PerformanceLargeHTTPPayloadGroupType,
     PerformanceMNPlusOneDBQueriesGroupType,
     PerformanceNPlusOneAPICallsGroupType,
     PerformanceNPlusOneGroupType,
@@ -36,6 +37,7 @@ class DetectorType(Enum):
     N_PLUS_ONE_API_CALLS = "n_plus_one_api_calls"
     CONSECUTIVE_DB_OP = "consecutive_db"
     CONSECUTIVE_HTTP_OP = "consecutive_http"
+    LARGE_HTTP_PAYLOAD = "large_http_payload"
     FILE_IO_MAIN_THREAD = "file_io_main_thread"
     M_N_PLUS_ONE_DB = "m_n_plus_one_db"
     UNCOMPRESSED_ASSETS = "uncompressed_assets"
@@ -54,6 +56,7 @@ class DetectorType(Enum):
     DetectorType.UNCOMPRESSED_ASSETS: PerformanceUncompressedAssetsGroupType,
     DetectorType.CONSECUTIVE_HTTP_OP: PerformanceConsecutiveHTTPQueriesGroupType,
     DetectorType.DB_MAIN_THREAD: PerformanceDBMainThreadGroupType,
+    DetectorType.LARGE_HTTP_PAYLOAD: PerformanceLargeHTTPPayloadGroupType,
 }
 
 
@@ -63,6 +66,7 @@ class DetectorType(Enum):
     DetectorType.N_PLUS_ONE_DB_QUERIES_EXTENDED: "performance.issues.n_plus_one_db_ext.problem-creation",
     DetectorType.CONSECUTIVE_DB_OP: "performance.issues.consecutive_db.problem-creation",
     DetectorType.CONSECUTIVE_HTTP_OP: "performance.issues.consecutive_http.flag_disabled",
+    DetectorType.LARGE_HTTP_PAYLOAD: "performance.issues.large_http_payload.flag_disabled",
     DetectorType.N_PLUS_ONE_API_CALLS: "performance.issues.n_plus_one_api_calls.problem-creation",
     DetectorType.FILE_IO_MAIN_THREAD: "performance.issues.file_io_main_thread.problem-creation",
     DetectorType.UNCOMPRESSED_ASSETS: "performance.issues.compressed_assets.problem-creation",

src/sentry/utils/performance_issues/detectors/__init__.py

@@ -1,6 +1,7 @@
 from .consecutive_db_detector import ConsecutiveDBSpanDetector  # NOQA
 from .consecutive_http_detector import ConsecutiveHTTPSpanDetector  # NOQA
 from .io_main_thread_detector import DBMainThreadDetector, FileIOMainThreadDetector  # NOQA
+from .large_payload_detector import LargeHTTPPayloadDetector  # NOQA
 from .mn_plus_one_db_span_detector import MNPlusOneDBSpanDetector  # NOQA
 from .n_plus_one_api_calls_detector import NPlusOneAPICallsDetector  # NOQA
 from .n_plus_one_db_span_detector import (  # NOQA

src/sentry/utils/performance_issues/detectors/large_payload_detector.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from sentry import features
+from sentry.issues.grouptype import PerformanceLargeHTTPPayloadGroupType
+from sentry.models import Organization, Project
+
+from ..base import DetectorType, PerformanceDetector, fingerprint_http_spans
+from ..performance_problem import PerformanceProblem
+from ..types import Span
+
+
+class LargeHTTPPayloadDetector(PerformanceDetector):
+    __slots__ = "stored_problems"
+
+    type: DetectorType = DetectorType.LARGE_HTTP_PAYLOAD
+    settings_key = DetectorType.LARGE_HTTP_PAYLOAD
+
+    def init(self):
+        self.stored_problems: dict[str, PerformanceProblem] = {}
+        self.consecutive_http_spans: list[Span] = []
+
+    def visit_span(self, span: Span) -> None:
+        if not LargeHTTPPayloadDetector._is_span_eligible(span):
+            return
+
+        data = span.get("data", None)
+        encoded_body_size = data and data.get("Encoded Body Size", None)
+        if not (encoded_body_size):
+            return
+
+        payload_size_threshold = self.settings.get("payload_size_threshold")
+        if encoded_body_size > payload_size_threshold:
+            self._store_performance_problem(span)
+
+    def _store_performance_problem(self, span) -> None:
+        fingerprint = self._fingerprint(span)
+        offender_span_ids = span.get("span_id", None)
+        desc: str = span.get("description", None)
+
+        self.stored_problems[fingerprint] = PerformanceProblem(
+            fingerprint,
+            "http",
+            desc=desc,
+            type=PerformanceLargeHTTPPayloadGroupType,
+            cause_span_ids=[],
+            parent_span_ids=None,
+            offender_span_ids=offender_span_ids,
+            evidence_display=[],
+            evidence_data={
+                "parent_span_ids": [],
+                "cause_span_ids": [],
+                "offender_span_ids": offender_span_ids,
+                "op": "http",
+            },
+        )
+
+    @classmethod
+    def _is_span_eligible(cls, span: Span) -> bool:
+        span_id = span.get("span_id", None)
+        op: str = span.get("op", "") or ""
+        hash = span.get("hash", None)
+        description: str = span.get("description", "") or ""
+
+        if not span_id or not op or not hash or not description:
+            return False
+
+        normalized_description = description.strip().upper()
+
+        if not normalized_description.startswith(
+            ("GET", "POST", "DELETE", "PUT", "PATCH")
+        ):  # Just using all methods to see if anything interesting pops up
+            return False
+
+        if normalized_description.endswith(
+            (".JS", ".CSS", ".SVG", ".PNG", ".MP3", ".JPG", ".JPEG")
+        ):
+            return False
+
+        if any([x in description for x in ["_next/static/", "_next/data/"]]):
+            return False
+
+        return True
+
+    def _fingerprint(self, span) -> str:
+        hashed_url_paths = fingerprint_http_spans([span])
+        return f"1-{PerformanceLargeHTTPPayloadGroupType.type_id}-{hashed_url_paths}"
+
+    def is_creation_allowed_for_organization(self, organization: Organization) -> bool:
+        return features.has(
+            "organizations:performance-large-http-payload-detector", organization, actor=None
+        )
+
+    def is_creation_allowed_for_project(self, project: Project) -> bool:
+        return True

src/sentry/utils/performance_issues/performance_detection.py

@@ -21,6 +21,7 @@
     ConsecutiveHTTPSpanDetector,
     DBMainThreadDetector,
     FileIOMainThreadDetector,
+    LargeHTTPPayloadDetector,
     MNPlusOneDBSpanDetector,
     NPlusOneAPICallsDetector,
     NPlusOneDBSpanDetector,
@@ -231,6 +232,7 @@ def get_detection_settings(project_id: Optional[int] = None) -> Dict[DetectorTyp
             "consecutive_count_threshold": 3,
             "max_duration_between_spans": 10000,  # ms
         },
+        DetectorType.LARGE_HTTP_PAYLOAD: {"payload_size_threshold": 10000000},  # 10mb
     }
 
 
@@ -253,6 +255,7 @@ def _detect_performance_problems(
         NPlusOneAPICallsDetector(detection_settings, data),
         MNPlusOneDBSpanDetector(detection_settings, data),
         UncompressedAssetSpanDetector(detection_settings, data),
+        LargeHTTPPayloadDetector(detection_settings, data),
     ]
 
     for detector in detectors:

tests/sentry/utils/performance_issues/test_large_http_payload_detector.py

@@ -0,0 +1,80 @@
+from typing import List
+
+import pytest
+
+from sentry.eventstore.models import Event
+from sentry.issues.grouptype import PerformanceLargeHTTPPayloadGroupType
+from sentry.testutils import TestCase
+from sentry.testutils.performance_issues.event_generators import create_event, create_span
+from sentry.testutils.silo import region_silo_test
+from sentry.utils.performance_issues.detectors import LargeHTTPPayloadDetector
+from sentry.utils.performance_issues.performance_detection import (
+    PerformanceProblem,
+    get_detection_settings,
+    run_detector_on_data,
+)
+
+
+@region_silo_test
+@pytest.mark.django_db
+class LargeHTTPPayloadDetectorTest(TestCase):
+    def setUp(self):
+        super().setUp()
+        self.settings = get_detection_settings()
+
+    def find_problems(self, event: Event) -> List[PerformanceProblem]:
+        detector = LargeHTTPPayloadDetector(self.settings, event)
+        run_detector_on_data(detector, event)
+        return list(detector.stored_problems.values())
+
+    def test_detects_large_http_payload_issue(self):
+
+        spans = [
+            create_span(
+                "http.client",
+                1000,
+                "GET /api/0/organizations/endpoint1",
+                "hash1",
+                data={
+                    "Transfer Size": 50_000_000,
+                    "Encoded Body Size": 50_000_000,
+                    "Decoded Body Size": 50_000_000,
+                },
+            )
+        ]
+
+        event = create_event(spans)
+        assert self.find_problems(event) == [
+            PerformanceProblem(
+                fingerprint="1-1015-5e5543895c0f1f12c2d468da8c7f2d9e4dca81dc",
+                op="http",
+                desc="GET /api/0/organizations/endpoint1",
+                type=PerformanceLargeHTTPPayloadGroupType,
+                parent_span_ids=None,
+                cause_span_ids=[],
+                offender_span_ids="bbbbbbbbbbbbbbbb",
+                evidence_data={
+                    "parent_span_ids": [],
+                    "cause_span_ids": [],
+                    "offender_span_ids": "bbbbbbbbbbbbbbbb",
+                    "op": "http",
+                },
+                evidence_display=[],
+            )
+        ]
+
+    def test_does_not_issue_if_url_is_an_asset(self):
+        spans = [
+            create_span(
+                "resource.script",
+                desc="https://s1.sentry-cdn.com/_static/dist/sentry/entrypoints/app.js",
+                duration=1000.0,
+                data={
+                    "Transfer Size": 50_000_000,
+                    "Encoded Body Size": 50_000_000,
+                    "Decoded Body Size": 50_000_000,
+                },
+            )
+        ]
+        event = create_event(spans)
+        assert self.find_problems(event) == []

tests/sentry/utils/performance_issues/test_performance_detection.py

@@ -398,6 +398,7 @@ def test_reports_metrics_on_uncompressed_assets(self, incr_mock):
                     "integration_mongo": False,
                     "integration_postgres": False,
                     "consecutive_db": False,
+                    "large_http_payload": False,
                     "consecutive_http": False,
                     "slow_db_query": False,
                     "render_blocking_assets": False,