feat(releases): Add organization issue-metrics endpoint

src/sentry/issues/endpoints/organization_issue_metrics.py

@@ -1,6 +1,7 @@
 import collections
 from collections.abc import Iterator
 from datetime import datetime, timedelta
+from heapq import nlargest
 from itertools import chain
 from typing import TypedDict
 
@@ -84,12 +85,37 @@ def gen_ts(
                 end,
             )
 
+            grouped_counter: collections.defaultdict[str, int] = collections.defaultdict(int)
             grouped_series: dict[str, list[TimeSeries]] = collections.defaultdict(list)
             for row in qs:
                 grouping = [row[g] for g in group_by]
                 key = "||||".join(grouping)
+                grouped_counter[key] += row["value"]
                 grouped_series[key].append({"timestamp": row["timestamp"], "value": row["value"]})
 
+            # Group the smallest series into the "other" bucket.
+            if len(grouped_series) > 4:
+                keys = [v[0] for v in nlargest(4, grouped_counter.items(), key=lambda i: i[0])]
+
+                new_grouped_series: dict[str, list[TimeSeries]] = {}
+                other_series = collections.defaultdict(int)
+                for key, series in grouped_series.items():
+                    if key in keys:
+                        new_grouped_series[key] = series
+                    else:
+                        for s in series:
+                            other_series[s["timestamp"]] += s["value"]
+
+                if other_series:
+                    new_grouped_series["other"] = list(
+                        map(
+                            lambda i: {"timestamp": i[0], "value": i[1]},
+                            sorted(list(other_series.items()), key=lambda i: i[0]),
+                        )
+                    )
+            else:
+                new_grouped_series = grouped_series
+
             return [
                 make_timeseries_result(
                     axis=axis,
@@ -100,7 +126,7 @@ def gen_ts(
                     order=i,
                     values=series,
                 )
-                for i, (key, series) in enumerate(grouped_series.items())
+                for i, (key, series) in enumerate(new_grouped_series.items())
             ]
 
         return Response(

tests/sentry/issues/endpoints/test_organization_issue_metrics.py

@@ -209,3 +209,121 @@ def test_get_zero_interval(self):
         response = self.client.get(self.url + "?interval=0")
         assert response.status_code == 400
         assert response.json() == {"detail": "Interval must be greater than 1000 milliseconds."}
+
+    def test_other_grouping(self):
+        project1 = self.create_project(teams=[self.team], slug="foo")
+        project2 = self.create_project(teams=[self.team], slug="bar")
+        one = self.create_release(project1, version="1.0.0")
+        two = self.create_release(project2, version="1.1.0")
+        three = self.create_release(project2, version="1.2.0")
+        four = self.create_release(project2, version="1.3.0")
+        fifth = self.create_release(project2, version="1.4.0")
+        sixth = self.create_release(project2, version="1.5.0")
+
+        curr = datetime.now(tz=timezone.utc)
+        prev = curr - timedelta(hours=1)
+
+        # Release issues.
+        self.create_group(project=project1, status=0, first_seen=curr, first_release=one, type=1)
+        self.create_group(project=project1, status=0, first_seen=curr, first_release=two, type=1)
+        self.create_group(project=project1, status=0, first_seen=curr, first_release=three, type=1)
+        self.create_group(project=project1, status=0, first_seen=curr, first_release=four, type=1)
+        self.create_group(project=project1, status=0, first_seen=curr, first_release=fifth, type=1)
+        self.create_group(project=project1, status=0, first_seen=curr, first_release=sixth, type=1)
+
+        response = self.client.get(
+            self.url + f"?start={prev.isoformat()[:-6]}&end={curr.isoformat()[:-6]}&category=error"
+        )
+        response_json = response.json()
+        assert response_json["timeseries"] == [
+            {
+                "axis": "new_issues_count",
+                "groupBy": [],
+                "meta": {
+                    "interval": 3600000,
+                    "isOther": False,
+                    "order": 0,
+                    "valueType": "integer",
+                    "valueUnit": None,
+                },
+                "values": [
+                    {"timestamp": int(prev.timestamp()), "value": 0},
+                    {"timestamp": int(curr.timestamp()), "value": 6},
+                ],
+            },
+            {
+                "axis": "new_issues_count_by_release",
+                "groupBy": ["1.2.0"],
+                "meta": {
+                    "interval": 3600000,
+                    "isOther": False,
+                    "order": 0,
+                    "valueType": "integer",
+                    "valueUnit": None,
+                },
+                "values": [
+                    {"timestamp": int(prev.timestamp()), "value": 0},
+                    {"timestamp": int(curr.timestamp()), "value": 1},
+                ],
+            },
+            {
+                "axis": "new_issues_count_by_release",
+                "groupBy": ["1.3.0"],
+                "meta": {
+                    "interval": 3600000,
+                    "isOther": False,
+                    "order": 1,
+                    "valueType": "integer",
+                    "valueUnit": None,
+                },
+                "values": [
+                    {"timestamp": int(prev.timestamp()), "value": 0},
+                    {"timestamp": int(curr.timestamp()), "value": 1},
+                ],
+            },
+            {
+                "axis": "new_issues_count_by_release",
+                "groupBy": ["1.4.0"],
+                "meta": {
+                    "interval": 3600000,
+                    "isOther": False,
+                    "order": 2,
+                    "valueType": "integer",
+                    "valueUnit": None,
+                },
+                "values": [
+                    {"timestamp": int(prev.timestamp()), "value": 0},
+                    {"timestamp": int(curr.timestamp()), "value": 1},
+                ],
+            },
+            {
+                "axis": "new_issues_count_by_release",
+                "groupBy": ["1.5.0"],
+                "meta": {
+                    "interval": 3600000,
+                    "isOther": False,
+                    "order": 3,
+                    "valueType": "integer",
+                    "valueUnit": None,
+                },
+                "values": [
+                    {"timestamp": int(prev.timestamp()), "value": 0},
+                    {"timestamp": int(curr.timestamp()), "value": 1},
+                ],
+            },
+            {
+                "axis": "new_issues_count_by_release",
+                "groupBy": ["other"],
+                "meta": {
+                    "interval": 3600000,
+                    "isOther": False,
+                    "order": 4,
+                    "valueType": "integer",
+                    "valueUnit": None,
+                },
+                "values": [
+                    {"timestamp": int(prev.timestamp()), "value": 0},
+                    {"timestamp": int(curr.timestamp()), "value": 2},
+                ],
+            },
+        ]