Merge branch 'master' into isabella/checkout-w-seer

Author: isabellaenriquez

.github/actions/setup-sentry/action.yml

@@ -50,12 +50,7 @@ runs:
 
         ### pytest configuration ###
         echo "PY_COLORS=1" >> "$GITHUB_ENV"
-        # XXX(epurkihser): We've raised fail-slow from 60s to 120s since
-        # 2025-05, our migration dependency tree has grown too large and it
-        # takes these tests longer than 60 seconds to run. Once we've flattened
-        # our migrations we can bring this back down (asottile is working on
-        # this)
-        echo "PYTEST_ADDOPTS=--reruns=5 --durations=10 --fail-slow=120s" >> $GITHUB_ENV
+        echo "PYTEST_ADDOPTS=--reruns=5 --durations=10 --fail-slow=60s" >> $GITHUB_ENV
         echo "COVERAGE_CORE=sysmon" >> "$GITHUB_ENV"
 
         ### pytest-sentry configuration ###

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/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/grouping/enhancer/__init__.py

@@ -525,6 +525,71 @@ def apply_category_and_updated_in_app_to_frames(
                 ),
             )
 
+    def assemble_stacktrace_component_legacy(
+        self,
+        variant_name: str,
+        frame_components: list[FrameGroupingComponent],
+        frames: list[dict[str, Any]],
+        platform: str | None,
+        exception_data: dict[str, Any] | None = None,
+    ) -> StacktraceGroupingComponent:
+        """
+        This assembles a `stacktrace` grouping component out of the given
+        `frame` components and source frames.
+
+        This also handles cases where the entire stacktrace should be discarded.
+        """
+
+        match_frames: list[Any] = [create_match_frame(frame, platform) for frame in frames]
+        rust_frames = [RustFrame(contributes=c.contributes) for c in frame_components]
+        rust_exception_data = make_rust_exception_data(exception_data)
+
+        # Modify the rust frames by applying +group/-group rules and getting hints for both those
+        # changes and the `in_app` changes applied by earlier in the ingestion process by
+        # `apply_category_and_updated_in_app_to_frames`. Also, get `hint` and `contributes` values
+        # for the overall stacktrace (returned in `rust_results`).
+        rust_stacktrace_results = self.rust_enhancements.assemble_stacktrace_component(
+            match_frames, rust_exception_data, rust_frames
+        )
+
+        # Tally the number of each type of frame in the stacktrace. Later on, this will allow us to
+        # both collect metrics and use the information in decisions about whether to send the event
+        # to Seer
+        frame_counts: Counter[str] = Counter()
+
+        # Update frame components with results from rust
+        for frame, frame_component, rust_frame in zip(frames, frame_components, rust_frames):
+            rust_contributes = bool(rust_frame.contributes)  # bool-ing this for mypy's sake
+            rust_hint = rust_frame.hint
+            rust_hint_type = (
+                None
+                if rust_hint is None
+                else "in-app" if rust_hint.startswith("marked") else "contributes"
+            )
+
+            hint = get_hint_for_frame(variant_name, frame, frame_component, rust_frame)
+
+            if not (variant_name == "system" and rust_hint_type == "in-app"):
+                hint = rust_hint
+
+            frame_component.update(contributes=rust_contributes, hint=hint)
+
+            # Add this frame to our tally
+            key = f"{"in_app" if frame_component.in_app else "system"}_{"contributing" if frame_component.contributes else "non_contributing"}_frames"
+            frame_counts[key] += 1
+
+        stacktrace_contributes = rust_stacktrace_results.contributes
+        stacktrace_hint = rust_stacktrace_results.hint
+
+        stacktrace_component = StacktraceGroupingComponent(
+            values=frame_components,
+            hint=stacktrace_hint,
+            contributes=stacktrace_contributes,
+            frame_counts=frame_counts,
+        )
+
+        return stacktrace_component
+
     def assemble_stacktrace_component(
         self,
         variant_name: str,
@@ -611,21 +676,12 @@ def assemble_stacktrace_component(
             in_app_rust_frames,
             contributes_rust_frames,
         ):
-            frame_type = "in-app" if frame_component.in_app else "system"
-            rust_contributes = bool(rust_frame.contributes)  # bool-ing this for mypy's sake
-            rust_hint = rust_frame.hint
-            rust_hint_type = (
-                None
-                if rust_hint is None
-                else "in-app" if rust_hint.startswith("marked") else "contributes"
-            )
-
             # System frames should never contribute in the app variant, so if that's what we have,
             # force `contribtues=False`, regardless of the rust results
-            if variant_name == "app" and frame_type == "system":
+            if variant_name == "app" and not frame_component.in_app:
                 contributes = False
             else:
-                contributes = rust_contributes
+                contributes = rust_frame.contributes
 
             hint = get_hint_for_frame(variant_name, frame, frame_component, rust_frame)
             if self.run_split_enhancements:
@@ -640,15 +696,6 @@ def assemble_stacktrace_component(
                     variant_name, frame, frame_component, contributes_rust_frame, "contributes"
                 )
 
-            # TODO: Remove this workaround once we remove the legacy config. It's done this way (as
-            # a second pass at setting the values that undoes what the first pass did, rather than
-            # being incorporated into the first pass) so that we won't have to change any of the
-            # main logic when we remove it.
-            if self.bases and self.bases[0].startswith("legacy"):
-                contributes = rust_contributes
-                if not (variant_name == "system" and rust_hint_type == "in-app"):
-                    hint = rust_hint
-
             frame_component.update(contributes=contributes, hint=hint)
 
             # Add this frame to our tally
@@ -690,13 +737,7 @@ def assemble_stacktrace_component(
         # stacktrace to be wrong, too (if in the process of ignoring rust we turn a stacktrace with
         # at least one contributing frame into one without any). So we need to special-case here as
         # well.
-        #
-        # TODO: Remove the first condition once we get rid of the legacy config
-        if (
-            not (self.bases and self.bases[0].startswith("legacy"))
-            and variant_name == "app"
-            and frame_counts["in_app_contributing_frames"] == 0
-        ):
+        if variant_name == "app" and frame_counts["in_app_contributing_frames"] == 0:
             stacktrace_contributes = False
             stacktrace_hint = None
         else:

src/sentry/grouping/strategies/legacy.py

@@ -452,7 +452,7 @@ def stacktrace_legacy(
         frames_for_filtering.append(frame.get_raw_data())
         prev_frame = frame
 
-    stacktrace_component = context.config.enhancements.assemble_stacktrace_component(
+    stacktrace_component = context.config.enhancements.assemble_stacktrace_component_legacy(
         variant_name, frame_components, frames_for_filtering, event.platform
     )
     stacktrace_component.update(contributes=contributes, hint=hint)

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

@@ -408,33 +408,34 @@ def process_update(self, subscription_update: QuerySubscriptionUpdate) -> None:
                 },
             )
 
-        if features.has(
-            "organizations:workflow-engine-metric-alert-processing",
-            self.subscription.project.organization,
-        ):
-            packet = MetricDetectorUpdate(
-                entity=subscription_update.get("entity", ""),
-                subscription_id=subscription_update["subscription_id"],
-                values={"value": aggregation_value},
-                timestamp=self.last_update,
-            )
-            data_packet = DataPacket[MetricDetectorUpdate](
-                source_id=str(self.subscription.id), packet=packet
-            )
-            results = process_data_packets([data_packet], DATA_SOURCE_SNUBA_QUERY_SUBSCRIPTION)
+        if aggregation_value is not None:
             if features.has(
-                "organizations:workflow-engine-metric-alert-dual-processing-logs",
-                self.alert_rule.organization,
+                "organizations:workflow-engine-metric-alert-processing",
+                self.subscription.project.organization,
             ):
-                logger.info(
-                    "dual processing results for alert rule",
-                    extra={
-                        "results": results,
-                        "num_results": len(results),
-                        "value": aggregation_value,
-                        "rule_id": self.alert_rule.id,
-                    },
+                packet = MetricDetectorUpdate(
+                    entity=subscription_update.get("entity", ""),
+                    subscription_id=subscription_update["subscription_id"],
+                    values={"value": aggregation_value},
+                    timestamp=self.last_update,
+                )
+                data_packet = DataPacket[MetricDetectorUpdate](
+                    source_id=str(self.subscription.id), packet=packet
                 )
+                results = process_data_packets([data_packet], DATA_SOURCE_SNUBA_QUERY_SUBSCRIPTION)
+                if features.has(
+                    "organizations:workflow-engine-metric-alert-dual-processing-logs",
+                    self.alert_rule.organization,
+                ):
+                    logger.info(
+                        "dual processing results for alert rule",
+                        extra={
+                            "results": results,
+                            "num_results": len(results),
+                            "value": aggregation_value,
+                            "rule_id": self.alert_rule.id,
+                        },
+                    )
 
         has_anomaly_detection = features.has(
             "organizations:anomaly-detection-alerts", self.subscription.project.organization

src/sentry/integrations/jira/utils/create_issue_schema_transformers.py

@@ -98,8 +98,10 @@ def transform_fields(
     type_transformers = get_type_transformer_mappings(user_id_field)
     custom_field_transformers = get_custom_field_transformer_mappings()
 
+    lowercased_data = {k.lower(): v for k, v in data.items()}
+
     for field in jira_fields:
-        field_data = data.get(field.key)
+        field_data = lowercased_data.get(field.key.lower())
 
         # Skip any values that indicate no value should be provided.
         # We have some older alert templates with "" values, which will raise

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),
         }

src/sentry/options/defaults.py

@@ -3107,6 +3107,12 @@
 )
 
 # Taskbroker flags
+register(
+    "taskworker.try_compress.profile_metrics",
+    default=0.0,
+    type=Float,
+    flags=FLAG_AUTOMATOR_MODIFIABLE,
+)
 
 register(
     "taskworker.route.overrides",