Merge branch 'master' into jb/admin/deprecateddropdown

Author: JonasBa

src/sentry/incidents/endpoints/serializers/workflow_engine_action.py

@@ -1,19 +1,65 @@
+from collections.abc import Mapping
+from typing import Any
+
+from django.contrib.auth.models import AnonymousUser
+from django.db.models import Subquery
+
 from sentry.api.serializers import Serializer
 from sentry.incidents.endpoints.serializers.alert_rule_trigger_action import (
     get_identifier_from_action,
     get_input_channel_id,
     human_desc,
 )
-from sentry.incidents.models.alert_rule import AlertRuleTriggerAction
-from sentry.notifications.models.notificationaction import ActionService
+from sentry.notifications.models.notificationaction import ActionService, ActionTarget
 from sentry.notifications.notification_action.group_type_notification_registry.handlers.metric_alert_registry_handler import (
     MetricAlertRegistryHandler,
 )
-from sentry.workflow_engine.models import Action, ActionAlertRuleTriggerAction
+from sentry.users.models.user import User
+from sentry.users.services.user.model import RpcUser
+from sentry.workflow_engine.models import (
+    Action,
+    ActionAlertRuleTriggerAction,
+    DataCondition,
+    DataConditionAlertRuleTrigger,
+    DataConditionGroupAction,
+    DetectorWorkflow,
+    WorkflowDataConditionGroup,
+)
+from sentry.workflow_engine.models.data_condition import Condition
 
 
 class WorkflowEngineActionSerializer(Serializer):
-    def serialize(self, obj: Action, attrs, user, **kwargs):
+    def get_alert_rule_trigger_id(self, action: Action) -> int | None:
+        """
+        Fetches the alert rule trigger id for the detector trigger related to the given action
+        """
+        action_filter_data_condition = DataCondition.objects.filter(
+            condition_group__in=Subquery(
+                DataConditionGroupAction.objects.filter(action=action).values("condition_group")
+            ),
+            type=Condition.ISSUE_PRIORITY_EQUALS,
+            condition_result=True,
+        )
+        detector_dcg = DetectorWorkflow.objects.filter(
+            workflow__in=Subquery(
+                WorkflowDataConditionGroup.objects.filter(
+                    condition_group__in=Subquery(
+                        action_filter_data_condition.values("condition_group")
+                    )
+                ).values("workflow")
+            )
+        ).values("detector__workflow_condition_group")
+        detector_trigger = DataCondition.objects.filter(
+            condition_result__in=Subquery(action_filter_data_condition.values("comparison")),
+            condition_group__in=detector_dcg,
+        )
+        return DataConditionAlertRuleTrigger.objects.values_list(
+            "alert_rule_trigger_id", flat=True
+        ).get(data_condition__in=detector_trigger)
+
+    def serialize(
+        self, obj: Action, attrs: Mapping[str, Any], user: User | RpcUser | AnonymousUser, **kwargs
+    ) -> dict[str, Any]:
         """
         Temporary serializer to take an Action and serialize it for the old metric alert rule endpoints
         """
@@ -34,19 +80,13 @@ def serialize(self, obj: Action, attrs, user, **kwargs):
             sentry_app_id = int(obj.config.get("target_identifier"))
             sentry_app_config = obj.data.get("settings")
 
-        trigger_action = AlertRuleTriggerAction.objects.get(id=aarta.alert_rule_trigger_action_id)
-
         result = {
             "id": str(aarta.alert_rule_trigger_action_id),
-            "alertRuleTriggerId": str(trigger_action.alert_rule_trigger.id),
+            "alertRuleTriggerId": str(self.get_alert_rule_trigger_id(aarta.action)),
             "type": obj.type,
-            "targetType": ACTION_TARGET_TYPE_TO_STRING[
-                AlertRuleTriggerAction.TargetType(target_type)
-            ],
+            "targetType": ACTION_TARGET_TYPE_TO_STRING[ActionTarget(target_type)],
             "targetIdentifier": get_identifier_from_action(
-                type_value,
-                str(target_identifier),
-                target_display,
+                type_value, str(target_identifier), target_display
             ),
             "inputChannelId": get_input_channel_id(type_value, target_identifier),
             "integrationId": obj.integration_id,

src/sentry/incidents/subscription_processor.py

@@ -436,7 +436,11 @@ def process_update(self, subscription_update: QuerySubscriptionUpdate) -> None:
                 logger.info(
                     "dual processing results for alert rule %s",
                     self.alert_rule.id,
-                    extra={"results": results},
+                    extra={
+                        "results": results,
+                        "num_results": len(results),
+                        "value": aggregation_value,
+                    },
                 )
 
         has_anomaly_detection = features.has(

src/sentry/integrations/slack/message_builder/issues.py

@@ -75,6 +75,7 @@
 
 MAX_BLOCK_TEXT_LENGTH = 256
 USER_FEEDBACK_MAX_BLOCK_TEXT_LENGTH = 1500
+MAX_SUMMARY_HEADLINE_LENGTH = 50
 
 
 def get_group_users_count(group: Group, rules: list[Rule] | None = None) -> int:
@@ -480,9 +481,9 @@ def get_title_block(
             text = text.lstrip(" ")
             if "\n" in text:
                 text = text.strip().split("\n")[0] + "..."
-            if len(text) > 100:
-                text = text[:100] + "..."
-            headline = f"{error_type}: `{text}`"
+            if len(text) > MAX_SUMMARY_HEADLINE_LENGTH:
+                text = text[:MAX_SUMMARY_HEADLINE_LENGTH] + "..."
+            headline = f"{error_type}: {text}" if text else error_type
 
         title = headline if headline else build_attachment_title(event_or_group)
 

src/sentry/rules/conditions/event_frequency.py

@@ -190,7 +190,7 @@ def passes(self, event: GroupEvent, state: EventState) -> bool:
         return current_value > value
 
     def passes_activity_frequency(
-        self, activity: ConditionActivity, buckets: dict[datetime, int]
+        self, activity: ConditionActivity, buckets: dict[datetime, int | float]
     ) -> bool:
         interval, value = self._get_options()
         if not (interval and value is not None):
@@ -221,15 +221,17 @@ def passes_activity_frequency(
     def get_preview_aggregate(self) -> tuple[str, str]:
         raise NotImplementedError
 
-    def query(self, event: GroupEvent, start: datetime, end: datetime, environment_id: int) -> int:
+    def query(
+        self, event: GroupEvent, start: datetime, end: datetime, environment_id: int
+    ) -> int | float:
         """
         Queries Snuba for a unique condition for a single group.
         """
         return self.query_hook(event, start, end, environment_id)
 
     def query_hook(
         self, event: GroupEvent, start: datetime, end: datetime, environment_id: int
-    ) -> int:
+    ) -> int | float:
         """
         Abstract method that specifies how to query Snuba for a single group
         depending on the condition. Must be implemented by subclasses.
@@ -238,15 +240,15 @@ def query_hook(
 
     def batch_query(
         self, group_ids: set[int], start: datetime, end: datetime, environment_id: int
-    ) -> dict[int, int]:
+    ) -> dict[int, int | float]:
         """
         Queries Snuba for a unique condition for multiple groups.
         """
         return self.batch_query_hook(group_ids, start, end, environment_id)
 
     def batch_query_hook(
         self, group_ids: set[int], start: datetime, end: datetime, environment_id: int
-    ) -> dict[int, int]:
+    ) -> dict[int, int | float]:
         """
         Abstract method that specifies how to query Snuba for multiple groups
         depending on the condition. Must be implemented by subclasses.
@@ -279,7 +281,7 @@ def get_rate(
         event: GroupEvent,
         environment_id: int,
         comparison_type: str,
-    ) -> int:
+    ) -> int | float:
         current_time = timezone.now()
         start, end = self.get_query_window(end=current_time, duration=duration)
         with self.disable_consistent_snuba_mode(duration):
@@ -302,7 +304,7 @@ def get_rate_bulk(
         environment_id: int,
         current_time: datetime,
         comparison_interval: timedelta | None,
-    ) -> dict[int, int]:
+    ) -> dict[int, int | float]:
         """
         Make a batch query for multiple groups. The return value is a dictionary
         of group_id to the result for that group.
@@ -434,8 +436,8 @@ def query_hook(
 
     def batch_query_hook(
         self, group_ids: set[int], start: datetime, end: datetime, environment_id: int
-    ) -> dict[int, int]:
-        batch_sums: dict[int, int] = defaultdict(int)
+    ) -> dict[int, int | float]:
+        batch_sums: dict[int, int | float] = defaultdict(int)
         groups = Group.objects.filter(id__in=group_ids).values(
             "id", "type", "project_id", "project__organization_id"
         )
@@ -497,8 +499,8 @@ def query_hook(
 
     def batch_query_hook(
         self, group_ids: set[int], start: datetime, end: datetime, environment_id: int
-    ) -> dict[int, int]:
-        batch_totals: dict[int, int] = defaultdict(int)
+    ) -> dict[int, int | float]:
+        batch_totals: dict[int, int | float] = defaultdict(int)
         groups = Group.objects.filter(id__in=group_ids).values(
             "id", "type", "project_id", "project__organization_id"
         )
@@ -583,7 +585,7 @@ def query_hook(
 
     def batch_query_hook(
         self, group_ids: set[int], start: datetime, end: datetime, environment_id: int
-    ) -> dict[int, int]:
+    ) -> dict[int, int | float]:
         logger = logging.getLogger(
             "sentry.rules.event_frequency.EventUniqueUserFrequencyConditionWithConditions"
         )
@@ -609,7 +611,7 @@ def batch_query_hook(
             raise NotImplementedError(
                 "EventUniqueUserFrequencyConditionWithConditions does not support filter_match == any"
             )
-        batch_totals: dict[int, int] = defaultdict(int)
+        batch_totals: dict[int, int | float] = defaultdict(int)
         groups = Group.objects.filter(id__in=group_ids).values(
             "id", "type", "project_id", "project__organization_id"
         )
@@ -723,7 +725,7 @@ def get_chunked_result(
 
     @staticmethod
     def convert_rule_condition_to_snuba_condition(
-        condition: dict[str, Any]
+        condition: dict[str, Any],
     ) -> tuple[str, str, str | list[str]] | None:
         if condition["id"] != "sentry.rules.filters.tagged_event.TaggedEventFilter":
             return None
@@ -863,7 +865,7 @@ def get_session_interval(self, session_count: int, interval: str) -> int | None:
 
     def query_hook(
         self, event: GroupEvent, start: datetime, end: datetime, environment_id: int
-    ) -> int:
+    ) -> float:
         project_id = event.project_id
         session_count_last_hour = self.get_session_count(project_id, environment_id, start, end)
         avg_sessions_in_interval = self.get_session_interval(
@@ -892,14 +894,14 @@ def query_hook(
                         "avg_sessions_in_interval": avg_sessions_in_interval,
                     },
                 )
-            percent: int = int(100 * round(issue_count / avg_sessions_in_interval, 4))
+            percent: float = 100 * round(issue_count / avg_sessions_in_interval, 4)
             return percent
 
         return 0
 
     def batch_query_hook(
         self, group_ids: set[int], start: datetime, end: datetime, environment_id: int
-    ) -> dict[int, int]:
+    ) -> dict[int, int | float]:
         groups = Group.objects.filter(id__in=group_ids).values(
             "id", "type", "project_id", "project__organization_id"
         )
@@ -933,34 +935,35 @@ def batch_query_hook(
             referrer_suffix="batch_alert_event_frequency_percent",
         )
 
-        batch_percents: dict[int, int] = {}
+        batch_percents: dict[int, int | float] = {}
         for group_id, count in error_issue_count.items():
-            percent: int = int(100 * round(count / avg_sessions_in_interval, 4))
+            percent: float = 100 * round(count / avg_sessions_in_interval, 4)
             batch_percents[group_id] = percent
 
         # We do not have sessions for non-error issue types
         for group in generic_issue_ids:
             batch_percents[group] = 0
-
         return batch_percents
 
     def passes_activity_frequency(
-        self, activity: ConditionActivity, buckets: dict[datetime, int]
+        self, activity: ConditionActivity, buckets: dict[datetime, int | float]
     ) -> bool:
         raise NotImplementedError
 
     def get_form_instance(self) -> EventFrequencyPercentForm:
         return EventFrequencyPercentForm(self.data)
 
 
-def bucket_count(start: datetime, end: datetime, buckets: dict[datetime, int]) -> int:
+def bucket_count(
+    start: datetime, end: datetime, buckets: dict[datetime, int | float]
+) -> int | float:
     rounded_end = round_to_five_minute(end)
     rounded_start = round_to_five_minute(start)
     count = buckets.get(rounded_end, 0) - buckets.get(rounded_start, 0)
     return count
 
 
-def percent_increase(result: int, comparison_result: int) -> int:
+def percent_increase(result: int | float, comparison_result: int | float) -> int:
     return (
         int(max(0, ((result - comparison_result) / comparison_result * 100)))
         if comparison_result > 0

src/sentry/rules/processing/delayed_processing.py

@@ -213,7 +213,7 @@ def bulk_fetch_events(event_ids: list[str], project_id: int) -> dict[str, Event]
 
 
 def parse_rulegroup_to_event_data(
-    rulegroup_to_event_data: dict[str, str]
+    rulegroup_to_event_data: dict[str, str],
 ) -> dict[tuple[int, int], dict[str, str]]:
     parsed_rulegroup_to_event_data = {}
     for rule_group, instance_data in rulegroup_to_event_data.items():
@@ -326,7 +326,7 @@ def get_group_to_groupevent(
 
 def get_condition_group_results(
     condition_groups: dict[UniqueConditionQuery, DataAndGroups], project: Project
-) -> dict[UniqueConditionQuery, dict[int, int]] | None:
+) -> dict[UniqueConditionQuery, dict[int, int | float]] | None:
     condition_group_results = {}
     current_time = datetime.now(tz=timezone.utc)
     project_id = project.id
@@ -377,7 +377,7 @@ def get_condition_group_results(
 
 
 def passes_comparison(
-    condition_group_results: dict[UniqueConditionQuery, dict[int, int]],
+    condition_group_results: dict[UniqueConditionQuery, dict[int, int | float]],
     condition_data: EventFrequencyConditionData,
     group_id: int,
     environment_id: int,
@@ -414,7 +414,7 @@ def passes_comparison(
 
 
 def get_rules_to_fire(
-    condition_group_results: dict[UniqueConditionQuery, dict[int, int]],
+    condition_group_results: dict[UniqueConditionQuery, dict[int, int | float]],
     rules_to_slow_conditions: DefaultDict[Rule, list[EventFrequencyConditionData]],
     rules_to_groups: DefaultDict[int, set[int]],
     project_id: int,

src/sentry/search/eap/columns.py

@@ -121,6 +121,8 @@ class VirtualColumnDefinition:
     ) = None
     filter_column: str | None = None
     default_value: str | None = None
+    # Processor is the function run in the post process step to transform a row into the final result
+    processor: Callable[[Any], Any] | None = None
 
 
 @dataclass(frozen=True, kw_only=True)

src/sentry/search/eap/resolver.py

@@ -718,7 +718,10 @@ def resolve_attribute(
         if column in self.definitions.contexts:
             column_context = self.definitions.contexts[column]
             column_definition = ResolvedAttribute(
-                public_alias=column, internal_name=column, search_type="string"
+                public_alias=column,
+                internal_name=column,
+                search_type="string",
+                processor=column_context.processor,
             )
         elif column in self.definitions.columns:
             column_context = None