Merge branch 'master' into bruno-garcia-patch-1

Author: bruno-garcia

migrations_lockfile.txt

@@ -13,7 +13,7 @@ hybridcloud: 0021_django_arrayfield_scope_list
 
 insights: 0001_add_starred_transactions_model
 
-monitors: 0004_record_date_in_progress_sql_only
+monitors: 0005_record_date_in_progress_state
 
 nodestore: 0002_nodestore_no_dictfield
 

src/sentry/api/endpoints/organization_sdk_deprecations.py

@@ -2,19 +2,18 @@
 from typing import DefaultDict, TypedDict
 
 import sentry_sdk
-from packaging.version import InvalidVersion, Version
+from packaging.version import InvalidVersion
 from packaging.version import parse as parse_version
 from rest_framework import serializers
 from rest_framework.request import Request
 from rest_framework.response import Response
 
-from sentry import options
 from sentry.api.api_owners import ApiOwner
 from sentry.api.api_publish_status import ApiPublishStatus
 from sentry.api.base import region_silo_endpoint
 from sentry.api.bases.organization import OrganizationEndpoint
 from sentry.models.project import Project
-from sentry.models.projectsdk import EventType, ProjectSDK
+from sentry.models.projectsdk import EventType, ProjectSDK, get_minimum_sdk_version
 
 
 class SDKDeprecationsSerializer(serializers.Serializer):
@@ -93,40 +92,18 @@ def get_event_types(raw_event_type: str) -> list[EventType]:
     raise ValueError(f"Unknown event type: {raw_event_type}")
 
 
-MINIMUM_SDK_VERSION_OPTIONS: dict[tuple[int, str], str] = {
-    (EventType.PROFILE_CHUNK.value, "sentry.cocoa"): "sdk-deprecation.profile-chunk.cocoa",
-    (EventType.PROFILE_CHUNK.value, "sentry.python"): "sdk-deprecation.profile-chunk.python",
-}
-
-
-def get_minimum_sdk_version(project_sdk: ProjectSDK) -> Version | None:
-    parts = project_sdk.sdk_name.split(".", 2)
-    if len(parts) < 2:
-        return None
-
-    sdk_name = ".".join(parts[:2])
-
-    sdk_version_option = MINIMUM_SDK_VERSION_OPTIONS.get((project_sdk.event_type, sdk_name))
-    if sdk_version_option is None:
-        return None
-
-    sdk_version = options.get(sdk_version_option)
-    if sdk_version:
-        try:
-            return parse_version(sdk_version)
-        except InvalidVersion as e:
-            sentry_sdk.capture_exception(e)
-    return None
-
-
 def get_deprecation_status(project_sdk: ProjectSDK) -> SDKDeprecation | None:
     try:
         sdk_version = parse_version(project_sdk.sdk_version)
     except InvalidVersion as e:
         sentry_sdk.capture_exception(e)
         return None
 
-    minimum_sdk_version = get_minimum_sdk_version(project_sdk)
+    minimum_sdk_version = get_minimum_sdk_version(
+        project_sdk.event_type,
+        project_sdk.sdk_name,
+        hard_limit=False,
+    )
 
     # no minimum sdk version was specified
     if minimum_sdk_version is None:

src/sentry/api/endpoints/project_rule_details.py

@@ -245,6 +245,7 @@ def put(self, request: Request, project, rule) -> Response:
                 "name": data["name"],
                 "environment": data.get("environment"),
                 "project": project,
+                "project_id": project.id,
                 "action_match": data["actionMatch"],
                 "filter_match": data.get("filterMatch"),
                 "conditions": conditions,

src/sentry/api/endpoints/project_rules.py

@@ -800,6 +800,7 @@ def post(self, request: Request, project) -> Response:
             "name": data["name"],
             "environment": data.get("environment"),
             "project": project,
+            "project_id": project.id,
             "action_match": data["actionMatch"],
             "filter_match": data.get("filterMatch"),
             "conditions": conditions,

src/sentry/celery.py

@@ -33,12 +33,13 @@ def holds_bad_pickle_object(value, memo=None):
             bad_object = holds_bad_pickle_object(item, memo)
             if bad_object is not None:
                 return bad_object
+        return
     elif isinstance(value, dict):
         for item in value.values():
             bad_object = holds_bad_pickle_object(item, memo)
             if bad_object is not None:
                 return bad_object
-
+        return
     if isinstance(value, models.Model):
         return (
             value,
@@ -56,7 +57,7 @@ def holds_bad_pickle_object(value, memo=None):
         return None
     elif value is None:
         return None
-    elif not isinstance(value, (dict, list, str, float, int, bool, tuple, frozenset)):
+    elif not isinstance(value, (str, float, int, bool)):
         return value, "do not pickle stdlib classes"
     return None
 
@@ -69,9 +70,9 @@ def good_use_of_pickle_or_bad_use_of_pickle(task, args, kwargs):
         if bad is not None:
             bad_object, reason = bad
             raise TypeError(
-                "Task %r was invoked with an object that we do not want "
+                "Task %s was invoked with an object that we do not want "
                 "to pass via pickle (%r, reason is %s) in argument %s"
-                % (task, bad_object, reason, name)
+                % (task.name, bad_object, reason, name)
             )
 
 

src/sentry/features/temporary.py

@@ -273,6 +273,8 @@ def register_temporary_features(manager: FeatureManager):
     manager.add("organizations:profiling-beta", OrganizationFeature, FeatureHandlerStrategy.INTERNAL, api_expose=True)
     # Enables monitoring for latest profiling sdk used
     manager.add("organizations:profiling-sdks", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=True)
+    # Enables dropping of deprecated profiling sdks used
+    manager.add("organizations:profiling-deprecate-sdks", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=True)
     # Enables production profiling in sentry browser application
     manager.add("organizations:profiling-browser", OrganizationFeature, FeatureHandlerStrategy.INTERNAL, api_expose=False)
     # Enables separate differential flamegraph page

src/sentry/grouping/api.py

@@ -16,7 +16,7 @@
     DefaultGroupingComponent,
     SystemGroupingComponent,
 )
-from sentry.grouping.enhancer import LATEST_VERSION, Enhancements, get_enhancements_version
+from sentry.grouping.enhancer import Enhancements, get_enhancements_version
 from sentry.grouping.enhancer.exceptions import InvalidEnhancerConfig
 from sentry.grouping.strategies.base import DEFAULT_GROUPING_ENHANCEMENTS_BASE, GroupingContext
 from sentry.grouping.strategies.configurations import CONFIGURATIONS
@@ -93,14 +93,15 @@ def _get_enhancements(self, project: Project) -> str:
 
         config_id = self._get_config_id(project)
         enhancements_base = CONFIGURATIONS[config_id].enhancements_base
+        enhancements_version = get_enhancements_version(project, config_id)
 
         # Instead of parsing and dumping out config here, we can make a
         # shortcut
         from sentry.utils.cache import cache
         from sentry.utils.hashlib import md5_text
 
         cache_prefix = self.cache_prefix
-        cache_prefix += f"{LATEST_VERSION}:"
+        cache_prefix += f"{enhancements_version}:"
         cache_key = (
             cache_prefix
             + md5_text(
@@ -124,7 +125,7 @@ def _get_enhancements(self, project: Project) -> str:
             enhancements = Enhancements.from_rules_text(
                 enhancements_string,
                 bases=[enhancements_base] if enhancements_base else [],
-                version=get_enhancements_version(project, config_id),
+                version=enhancements_version,
                 referrer="project_rules",
             ).base64_string
         except InvalidEnhancerConfig:

src/sentry/grouping/strategies/base.py

@@ -11,7 +11,8 @@
     FrameGroupingComponent,
     StacktraceGroupingComponent,
 )
-from sentry.grouping.enhancer import Enhancements
+from sentry.grouping.enhancer import ENHANCEMENT_BASES, Enhancements
+from sentry.grouping.enhancer.exceptions import InvalidEnhancerConfig
 from sentry.interfaces.base import Interface
 from sentry.interfaces.exception import SingleException
 from sentry.interfaces.stacktrace import Frame, Stacktrace
@@ -305,9 +306,18 @@ def __init__(self, enhancements: str | None = None, **extra: Any):
         if enhancements is None:
             enhancements_instance = Enhancements.from_rules_text("", referrer="strategy_config")
         else:
-            enhancements_instance = Enhancements.from_base64_string(
-                enhancements, referrer="strategy_config"
-            )
+            # If the enhancements string has been loaded from an existing event, it may be from an
+            # obsolete enhancements version, in which case we just use the default enhancements for
+            # this grouping config
+            try:
+                enhancements_instance = Enhancements.from_base64_string(
+                    enhancements, referrer="strategy_config"
+                )
+            except InvalidEnhancerConfig:
+                enhancements_instance = ENHANCEMENT_BASES[
+                    self.enhancements_base or DEFAULT_GROUPING_ENHANCEMENTS_BASE
+                ]
+
         self.enhancements = enhancements_instance
 
     def __repr__(self) -> str:

src/sentry/incidents/logic.py

@@ -415,7 +415,7 @@ def get_metric_issue_aggregates(
                 "incidents.get_incident_aggregates.snql.query.error",
                 tags={
                     "dataset": params.snuba_query.dataset,
-                    "entity": EntityKey.EAPSpans.value,
+                    "entity": EntityKey.EAPItemsSpan.value,
                 },
             )
             raise

src/sentry/incidents/subscription_processor.py

@@ -312,14 +312,6 @@ def get_comparison_aggregation_value(
 
         if not comparison_aggregate:
             metrics.incr("incidents.alert_rules.skipping_update_comparison_value_invalid")
-            logger.info(
-                "No comparison aggregate",
-                extra={
-                    "alert_rule_id": self.alert_rule.id,
-                    "subscription_id": subscription_update.get("subscription_id"),
-                    "organization_id": self.alert_rule.organization_id,
-                },
-            )
             return None
 
         return (aggregation_value / comparison_aggregate) * 100

src/sentry/integrations/slack/tasks/find_channel_id_for_rule.py

@@ -32,20 +32,23 @@
     ),
 )
 def find_channel_id_for_rule(
-    project: Project,
+    project: Project | None,
     actions: Sequence[dict[str, Any]],
     uuid: str,
     rule_id: int | None = None,
     user_id: int | None = None,
+    project_id: int | None = None,
     **kwargs: Any,
 ) -> None:
     redis_rule_status = RedisRuleStatus(uuid)
 
-    try:
-        project = Project.objects.get(id=project.id)
-    except Project.DoesNotExist:
-        redis_rule_status.set_value("failed")
-        return
+    if not project and project_id:
+        try:
+            project = Project.objects.get_from_cache(id=project_id)
+        except Project.DoesNotExist:
+            redis_rule_status.set_value("failed")
+            return
+    assert project, "find_channel_id_for_rule requires a project or project_id"
 
     organization = project.organization
     integration_id: int | None = None

src/sentry/models/projectsdk.py

@@ -4,10 +4,12 @@
 from collections.abc import Sequence
 from enum import Enum
 
+import sentry_sdk
 from django.db import models
 from packaging.version import InvalidVersion, Version
 from packaging.version import parse as parse_version
 
+from sentry import options
 from sentry.backup.scopes import RelocationScope
 from sentry.db.models import BoundedIntegerField, FlexibleForeignKey, region_silo_model, sane_repr
 from sentry.db.models.base import DefaultFieldsModel
@@ -170,3 +172,33 @@ def normalize_sdk_name(sdk_name: str) -> str | None:
         return sdk_name
 
     return None
+
+
+MINIMUM_SDK_VERSION_OPTIONS: dict[tuple[int, str], str] = {
+    (EventType.PROFILE_CHUNK.value, "sentry.cocoa"): "sdk-deprecation.profile-chunk.cocoa",
+    (EventType.PROFILE_CHUNK.value, "sentry.python"): "sdk-deprecation.profile-chunk.python",
+}
+
+
+def get_minimum_sdk_version(event_type: int, sdk_name: str, hard_limit: bool) -> Version | None:
+    parts = sdk_name.split(".", 2)
+    if len(parts) < 2:
+        return None
+
+    normalized_sdk_name = ".".join(parts[:2])
+
+    sdk_version_option = MINIMUM_SDK_VERSION_OPTIONS.get((event_type, normalized_sdk_name))
+    if sdk_version_option is None:
+        return None
+
+    if hard_limit:
+        sdk_version = options.get(f"{sdk_version_option}.hard")
+    else:
+        sdk_version = options.get(sdk_version_option)
+
+    if sdk_version:
+        try:
+            return parse_version(sdk_version)
+        except InvalidVersion as e:
+            sentry_sdk.capture_exception(e)
+    return None

src/sentry/monitors/consumers/monitor_consumer.py

@@ -828,13 +828,17 @@ def _process_checkin(item: CheckinItem, txn: Transaction | Span) -> None:
                 # to UTC
                 clock_time = item.ts.replace(tzinfo=UTC)
 
+                # Record the reported in_progress time when the check is in progress
+                date_in_progress = start_time if status == CheckInStatus.IN_PROGRESS else None
+
                 check_in, created = MonitorCheckIn.objects.get_or_create(
                     defaults={
                         "duration": duration,
                         "status": status,
                         "date_added": start_time,
                         "date_updated": start_time,
                         "date_clock": clock_time,
+                        "date_in_progress": date_in_progress,
                         "expected_time": expected_time,
                         "timeout_at": timeout_at,
                         "monitor_config": monitor_config,

src/sentry/monitors/migrations/0005_record_date_in_progress_state.py

@@ -0,0 +1,39 @@
+# Generated by Django 5.2.1 on 2025-05-15 16:51
+
+from django.db import migrations, models
+from django.db.migrations import SeparateDatabaseAndState
+
+from sentry.new_migrations.migrations import CheckedMigration
+
+
+class Migration(CheckedMigration):
+    # This flag is used to mark that a migration shouldn't be automatically run in production.
+    # This should only be used for operations where it's safe to run the migration after your
+    # code has deployed. So this should not be used for most operations that alter the schema
+    # of a table.
+    # Here are some things that make sense to mark as post deployment:
+    # - Large data migrations. Typically we want these to be run manually so that they can be
+    #   monitored and not block the deploy for a long period of time while they run.
+    # - Adding indexes to large tables. Since this can take a long time, we'd generally prefer to
+    #   run this outside deployments so that we don't block them. Note that while adding an index
+    #   is a schema change, it's completely safe to run the operation after the code has deployed.
+    # Once deployed, run these manually via: https://develop.sentry.dev/database-migrations/#migration-deployment
+
+    is_post_deployment = False
+
+    dependencies = [
+        ("monitors", "0004_record_date_in_progress_sql_only"),
+    ]
+
+    operations = [
+        SeparateDatabaseAndState(
+            database_operations=[],
+            state_operations=[
+                migrations.AddField(
+                    model_name="monitorcheckin",
+                    name="date_in_progress",
+                    field=models.DateTimeField(null=True),
+                )
+            ],
+        )
+    ]

src/sentry/monitors/models.py

@@ -495,6 +495,12 @@ class MonitorCheckIn(Model):
     as detecting misses)
     """
 
+    date_in_progress = models.DateTimeField(null=True)
+    """
+    Records the time when the first in_progress check-in was received by relay.
+    If no in_progress check-in was ever sent this will remain null.
+    """
+
     expected_time = models.DateTimeField(null=True)
     """
     Holds the exact time we expected to receive this check-in

src/sentry/monitors/serializers.py

@@ -278,6 +278,7 @@ class MonitorCheckInSerializerResponse(MonitorCheckInSerializerResponseOptional)
     dateCreated: datetime
     dateAdded: datetime
     dateUpdated: datetime
+    dateInProgress: datetime | None
     dateClock: datetime
     expectedTime: datetime
     monitorConfig: MonitorConfigSerializerResponse
@@ -348,6 +349,7 @@ def serialize(self, obj, attrs, user, **kwargs) -> MonitorCheckInSerializerRespo
             "dateAdded": obj.date_added,
             "dateUpdated": obj.date_updated,
             "dateClock": obj.date_clock,
+            "dateInProgress": obj.date_in_progress,
             "expectedTime": obj.expected_time,
             "monitorConfig": cast(MonitorConfigSerializerResponse, config),
         }