🔀 merge master

Author: michellewzhang

migrations_lockfile.txt

@@ -23,4 +23,4 @@ tempest: 0001_create_tempest_credentials_model
 
 uptime: 0025_uptime_migrate_constraint
 
-workflow_engine: 0029_ds_query_id_to_pending
+workflow_engine: 0030_allow_blank_workflow_owner_fks

pyproject.toml

@@ -135,7 +135,6 @@ module = [
     "sentry.api.invite_helper",
     "sentry.api.paginator",
     "sentry.api.permissions",
-    "sentry.api.serializers.models.event",
     "sentry.auth.helper",
     "sentry.auth.provider",
     "sentry.db.mixin",
@@ -216,7 +215,6 @@ module = [
     "sentry.shared_integrations.client.proxy",
     "sentry.snuba.errors",
     "sentry.snuba.issue_platform",
-    "sentry.snuba.metrics.datasource",
     "sentry.snuba.metrics.query_builder",
     "sentry.snuba.spans_metrics",
     "sentry.tasks.auth",

src/sentry/api/bases/organization_events.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import itertools
 from collections.abc import Callable, Sequence
 from datetime import timedelta
 from typing import Any
@@ -352,7 +353,6 @@ def handle_results_with_meta(
             if "confidence" in results:
                 meta["accuracy"] = {
                     "confidence": results["confidence"],
-                    # TODO: add sampleCount and rampleRate here
                 }
                 # Confidence being a top level key is going to be deprecated in favour of confidence being in the meta
                 return {"data": data, "meta": meta, "confidence": results["confidence"]}
@@ -505,22 +505,25 @@ def get_event_stats_data(
                                 results, key, query_columns
                             )
                     else:
+                        column = resolve_axis_column(
+                            query_columns[0], 0, transform_alias_to_input_format
+                        )
                         results[key] = serializer.serialize(
                             event_result,
-                            column=resolve_axis_column(
-                                query_columns[0], 0, transform_alias_to_input_format
-                            ),
+                            column=column,
                             allow_partial_buckets=allow_partial_buckets,
                             zerofill_results=zerofill_results,
                         )
-                        results[key]["meta"] = self.handle_results_with_meta(
+                        meta = self.handle_results_with_meta(
                             request,
                             organization,
                             snuba_params.project_ids,
                             event_result.data,
                             True,
                             dataset=dataset,
                         )["meta"]
+                        self.update_meta_with_accuracy(meta, event_result, column)
+                        results[key]["meta"] = meta
 
                 serialized_result = results
             elif is_multiple_axis:
@@ -543,23 +546,25 @@ def get_event_stats_data(
                 extra_columns = None
                 if comparison_delta:
                     extra_columns = ["comparisonCount"]
+                column = resolve_axis_column(query_columns[0], 0, transform_alias_to_input_format)
                 serialized_result = serializer.serialize(
                     result,
-                    column=resolve_axis_column(
-                        query_columns[0], 0, transform_alias_to_input_format
-                    ),
+                    column=column,
                     allow_partial_buckets=allow_partial_buckets,
                     zerofill_results=zerofill_results,
                     extra_columns=extra_columns,
+                    confidence_column=column,
                 )
-                serialized_result["meta"] = self.handle_results_with_meta(
+                meta = self.handle_results_with_meta(
                     request,
                     organization,
                     snuba_params.project_ids,
                     result.data,
                     True,
                     dataset=dataset,
                 )["meta"]
+                self.update_meta_with_accuracy(meta, result, column)
+                serialized_result["meta"] = meta
 
             return serialized_result
 
@@ -613,16 +618,44 @@ def serialize_multiple_axis(
             )
             if is_equation(query_column):
                 equations += 1
-            # TODO: confidence is being split up in the serializer right now, need to move that here once its deprecated
-            if "confidence" in result[columns[index]]:
-                meta["accuracy"] = {"confidence": result[columns[index]]["confidence"]}
+            self.update_meta_with_accuracy(meta, event_result, query_column)
             result[columns[index]]["meta"] = meta
         # Set order if multi-axis + top events
         if "order" in event_result.data:
             result["order"] = event_result.data["order"]
 
         return result
 
+    def update_meta_with_accuracy(self, meta, event_result, query_column) -> None:
+        if "processed_timeseries" in event_result.data:
+            processed_timeseries = event_result.data["processed_timeseries"]
+            meta["accuracy"] = {
+                "confidence": self.serialize_accuracy_data(
+                    processed_timeseries.confidence, query_column
+                ),
+                "sampleCount": self.serialize_accuracy_data(
+                    processed_timeseries.sample_count, query_column
+                ),
+                "samplingRate": self.serialize_accuracy_data(
+                    processed_timeseries.sampling_rate, query_column, null_zero=True
+                ),
+            }
+
+    def serialize_accuracy_data(
+        self,
+        data: Any,
+        column: str,
+        null_zero: bool = False,
+    ):
+        serialized_values = []
+        for timestamp, group in itertools.groupby(data, key=lambda r: r["time"]):
+            for row in group:
+                row_value = row.get(column, None)
+                if row_value == 0 and null_zero:
+                    row_value = None
+                serialized_values.append({"timestamp": timestamp, "value": row_value})
+        return serialized_values
+
 
 class KeyTransactionBase(OrganizationEventsV2EndpointBase):
     def has_feature(self, organization: Organization, request: Request) -> bool:

src/sentry/api/endpoints/auth_index.py

@@ -22,6 +22,7 @@
 from sentry.auth.services.auth.impl import promote_request_rpc_user
 from sentry.auth.superuser import SUPERUSER_ORG_ID
 from sentry.organizations.services.organization import organization_service
+from sentry.types.ratelimit import RateLimit, RateLimitCategory
 from sentry.users.api.serializers.user import DetailedSelfUserSerializer
 from sentry.users.models.authenticator import Authenticator
 from sentry.utils import auth, json, metrics
@@ -126,6 +127,14 @@ class AuthIndexEndpoint(BaseAuthIndexEndpoint):
     authentication methods from JS endpoints by relying on internal sessions
     and simple HTTP authentication.
     """
+    enforce_rate_limit = True
+    rate_limits = {
+        "PUT": {
+            RateLimitCategory.USER: RateLimit(
+                limit=5, window=60 * 60
+            ),  # 5 PUT requests per hour per user
+        }
+    }
 
     def _validate_superuser(
         self, validator: AuthVerifyValidator, request: Request, verify_authenticator: bool

src/sentry/api/endpoints/group_external_issues.py

@@ -20,7 +20,7 @@
 from sentry.api.api_publish_status import ApiPublishStatus
 from sentry.api.base import region_silo_endpoint
 from sentry.api.bases import NoProjects, OrganizationEventsV2EndpointBase
-from sentry.api.serializers.models.event import get_tags_with_meta
+from sentry.api.serializers.models.event import EventTag, get_tags_with_meta
 from sentry.api.utils import handle_query_errors, update_snuba_params_with_timestamp
 from sentry.eventstore.models import Event, GroupEvent
 from sentry.issues.issue_occurrence import IssueOccurrence
@@ -169,7 +169,7 @@ class TracePerformanceIssue(TypedDict):
         "sdk_name": Optional[str],
         "span_id": str,
         "start_timestamp": str | int,
-        "tags": list[tuple[str, str]],
+        "tags": list[EventTag],
         "timestamp": str | int,
         "transaction": str,
         "transaction.duration": int,