Merge branch 'master' into jb/button/chonkify

Author: JonasBa

.github/CODEOWNERS

@@ -612,7 +612,7 @@ tests/sentry/api/endpoints/test_organization_dashboard_widget_details.py     @ge
 /static/app/components/events/autofix/                      @getsentry/machine-learning-ai
 /static/app/components/modals/autofixSetupModal.spec.tsx    @getsentry/machine-learning-ai
 /static/app/components/modals/autofixSetupModal.tsx         @getsentry/machine-learning-ai
-/src/sentry/seer/fetch_issues_given_patches.py              @getsentry/machine-learning-ai
+/src/sentry/seer/                                           @getsentry/machine-learning-ai
 ## End of ML & AI
 
 ## Processing

.github/workflows/scripts/getsentry-dispatch.js

@@ -7,10 +7,6 @@
  *              deleted/renamed in `getsentry`, this will fail
  */
 const DISPATCHES = [
-  {
-    workflow: 'js-build-and-lint.yml',
-    pathFilterName: 'frontend_all',
-  },
   {
     workflow: 'backend.yml',
     pathFilterName: 'backend_all',

src/sentry/api/endpoints/group_ai_summary.py

@@ -245,9 +245,10 @@ def post(self, request: Request, group: Group) -> Response:
                         group=group, event_id=event.event_id, user=request.user
                     )
 
-            if response.status_code != 202:
-                # If autofix trigger fails, we don't cache to let it error and we can run again, this is only temporary for when we're testing this internally.
-                return response
+                    if response.status_code != 202:
+                        # If autofix trigger fails, we don't cache to let it error and we can run again
+                        # This is only temporary for when we're testing this internally.
+                        return response
 
         summary_dict = issue_summary.dict()
         summary_dict["event_id"] = event.event_id

src/sentry/api/event_search.py

@@ -632,15 +632,13 @@ class SearchVisitor(NodeVisitor):
 
     def __init__(
         self,
-        config: SearchConfig | None = None,
+        config: SearchConfig,
         params: ParamsType | None = None,
         get_field_type: Callable[[str], str | None] | None = None,
         get_function_result_type: Callable[[str], str | None] | None = None,
     ) -> None:
         super().__init__()
 
-        if config is None:
-            config = SearchConfig()
         self.config = config
         self.params = params if params is not None else {}
 

src/sentry/api/helpers/group_index/index.py

@@ -20,6 +20,7 @@
 from sentry.models.environment import Environment
 from sentry.models.group import Group, looks_like_short_id
 from sentry.models.groupsearchview import GroupSearchView
+from sentry.models.groupsearchviewstarred import GroupSearchViewStarred
 from sentry.models.organization import Organization
 from sentry.models.project import Project
 from sentry.models.release import Release
@@ -104,11 +105,12 @@ def build_query_params_from_request(
             if selected_view_id:
                 default_view = GroupSearchView.objects.filter(id=int(selected_view_id)).first()
             else:
-                default_view = GroupSearchView.objects.filter(
+                first_starred_view = GroupSearchViewStarred.objects.filter(
                     organization=organization,
                     user_id=request.user.id,
                     position=0,
                 ).first()
+                default_view = first_starred_view.group_search_view if first_starred_view else None
 
             if default_view:
                 query_kwargs["sort_by"] = default_view.query_sort

src/sentry/api/serializers/models/commit.py

@@ -50,7 +50,10 @@ def get_attrs(self, item_list, user, **kwargs):
             )
         )
 
-        pull_request_by_commit = {pr.merge_commit_sha: serialize(pr) for pr in pull_requests}
+        pull_request_by_commit = {
+            pr.merge_commit_sha: serialized_pr
+            for (pr, serialized_pr) in zip(pull_requests, serialize(pull_requests))
+        }
 
         result = {}
         for item in item_list:

src/sentry/incidents/metric_alert_detector.py

@@ -51,6 +51,7 @@ def validate(self, attrs):
             raise serializers.ValidationError("Too many conditions")
         return attrs
 
+    # TODO - @saponifi3d - we can make this more generic and move it into the base Detector
     def update_data_conditions(self, instance: Detector, data_conditions: list[DataConditionType]):
         """
         Update the data condition if it already exists, create one if it does not
@@ -116,6 +117,7 @@ def update_data_source(self, instance: Detector, data_source: SnubaQueryDataSour
             event_types=data_source.get("event_types", [event_type for event_type in event_types]),
         )
 
+    # TODO - @saponifi3d - we can make this more generic and move it into the base Detector
     def update(self, instance: Detector, validated_data: dict[str, Any]):
         instance.name = validated_data.get("name", instance.name)
         instance.type = validated_data.get("detector_type", instance.group_type).slug

src/sentry/incidents/subscription_processor.py

@@ -411,18 +411,6 @@ def process_update(self, subscription_update: QuerySubscriptionUpdate) -> None:
             )
 
         aggregation_value = self.get_aggregation_value(subscription_update)
-        if features.has(
-            "organizations:failure-rate-metric-alert-logging",
-            self.subscription.project.organization,
-        ):
-            logger.info(
-                "Update value in subscription processor",
-                extra={
-                    "result": subscription_update,
-                    "aggregation_value": aggregation_value,
-                    "rule_id": self.alert_rule.id,
-                },
-            )
 
         has_anomaly_detection = features.has(
             "organizations:anomaly-detection-alerts", self.subscription.project.organization
@@ -444,18 +432,6 @@ def process_update(self, subscription_update: QuerySubscriptionUpdate) -> None:
                     last_update=self.last_update.timestamp(),
                     aggregation_value=aggregation_value,
                 )
-            # XXX (mifu67): log problematic rule, to be deleted later
-            if features.has(
-                "feature.organizations:failure-rate-metric-alert-logging",
-                self.subscription.project.organization,
-            ):
-                logger.info(
-                    "Received this response from Seer",
-                    extra={
-                        "potential_anomalies": potential_anomalies,
-                        "alert_rule_id": self.alert_rule.id,
-                    },
-                )
             if potential_anomalies is None:
                 logger.info(
                     "No potential anomalies found",

src/sentry/incidents/utils/metric_issue_poc.py

@@ -6,8 +6,9 @@
 from django.utils.translation import gettext as _
 
 from sentry import features
-from sentry.incidents.models.alert_rule import AlertRule, AlertRuleThresholdType
-from sentry.incidents.models.incident import Incident, IncidentStatus
+from sentry.constants import CRASH_RATE_ALERT_AGGREGATE_ALIAS
+from sentry.incidents.models.alert_rule import AlertRule, AlertRuleThresholdType, AlertRuleTrigger
+from sentry.incidents.models.incident import INCIDENT_STATUS, Incident, IncidentStatus
 from sentry.incidents.utils.format_duration import format_duration_idiomatic
 from sentry.integrations.metric_alerts import TEXT_COMPARISON_DELTA
 from sentry.issues.grouptype import MetricIssuePOC
@@ -43,16 +44,21 @@ def to_dict(self) -> dict[str, Any]:
     "count_unique(tags[sentry:user])": "Number of users affected",
     "percentage(sessions_crashed, sessions)": "Crash free session rate",
     "percentage(users_crashed, users)": "Crash free user rate",
+    "failure_rate()": "Failure rate",
+    "apdex()": "Apdex score",
 }
 
 
-def construct_title(alert_rule: AlertRule) -> str:
+def construct_title(alert_rule: AlertRule, status: int) -> str:
     # Parse the aggregate key from the alert rule
     agg_display_key = alert_rule.snuba_query.aggregate
     if is_mri_field(agg_display_key):
-        agg_text = format_mri_field(agg_display_key)
+        aggregate = format_mri_field(agg_display_key)
+    elif CRASH_RATE_ALERT_AGGREGATE_ALIAS in agg_display_key:
+        agg_display_key = agg_display_key.split(f"AS {CRASH_RATE_ALERT_AGGREGATE_ALIAS}")[0].strip()
+        aggregate = QUERY_AGGREGATION_DISPLAY.get(agg_display_key, agg_display_key)
     else:
-        agg_text = QUERY_AGGREGATION_DISPLAY.get(agg_display_key, alert_rule.snuba_query.aggregate)
+        aggregate = QUERY_AGGREGATION_DISPLAY.get(agg_display_key, alert_rule.snuba_query.aggregate)
 
     # Determine the higher or lower comparison
     higher_or_lower = ""
@@ -61,19 +67,35 @@ def construct_title(alert_rule: AlertRule) -> str:
     else:
         higher_or_lower = "less than" if alert_rule.comparison_delta else "below"
 
+    label = INCIDENT_STATUS[IncidentStatus(status)]
+
     # Format the time window for the threshold
-    time_window = alert_rule.snuba_query.time_window // 60
-    title = f"{agg_text} in the last {format_duration_idiomatic(time_window)} {higher_or_lower}"
+    time_window = format_duration_idiomatic(alert_rule.snuba_query.time_window // 60)
 
     # If the alert rule has a comparison delta, format the comparison string
+    comparison: str | int | float = "threshold"
     if alert_rule.comparison_delta:
         comparison_delta_minutes = alert_rule.comparison_delta // 60
-        comparison_string = TEXT_COMPARISON_DELTA.get(
-            comparison_delta_minutes, f"same time {comparison_delta_minutes} minutes ago"
+        comparison = TEXT_COMPARISON_DELTA.get(
+            comparison_delta_minutes, f"same time {comparison_delta_minutes} minutes ago "
         )
-        return _(f"{title} {comparison_string}")
-
-    return _(f"{title} threshold")
+    else:
+        # Otherwise, check if there is a trigger with a threshold
+        trigger = AlertRuleTrigger.objects.filter(id=alert_rule.id, label=label.lower()).first()
+        if trigger:
+            threshold = trigger.alert_threshold
+            comparison = int(threshold) if threshold % 1 == 0 else threshold
+
+    template = "{label}: {metric} in the last {time_window} {higher_or_lower} {comparison}"
+    return _(
+        template.format(
+            label=label.capitalize(),
+            metric=aggregate,
+            higher_or_lower=higher_or_lower,
+            comparison=comparison,
+            time_window=time_window,
+        )
+    )
 
 
 def _build_occurrence_from_incident(
@@ -88,7 +110,7 @@ def _build_occurrence_from_incident(
         else PriorityLevel.MEDIUM
     )
     fingerprint = [str(incident.alert_rule.id)]
-    title = construct_title(incident.alert_rule)
+    title = construct_title(incident.alert_rule, incident.status)
     return IssueOccurrence(
         id=uuid4().hex,
         project_id=project.id,

src/sentry/integrations/bitbucket/client.py

@@ -7,7 +7,6 @@
 
 from requests import PreparedRequest
 
-from sentry.integrations.base import IntegrationFeatureNotImplementedError
 from sentry.integrations.client import ApiClient
 from sentry.integrations.models.integration import Integration
 from sentry.integrations.services.integration.model import RpcIntegration
@@ -182,4 +181,13 @@ def check_file(self, repo: Repository, path: str, version: str | None) -> object
     def get_file(
         self, repo: Repository, path: str, ref: str | None, codeowners: bool = False
     ) -> str:
-        raise IntegrationFeatureNotImplementedError
+        response = self.get_cached(
+            path=BitbucketAPIPath.source.format(
+                repo=repo.name,
+                sha=ref,
+                path=path,
+            ),
+            allow_redirects=True,
+            raw_response=True,
+        )
+        return response.text

src/sentry/integrations/bitbucket/integration.py

@@ -78,6 +78,12 @@
         """,
         IntegrationFeatures.STACKTRACE_LINK,
     ),
+    FeatureDescription(
+        """
+        Import your Bitbucket [CODEOWNERS file](https://support.atlassian.com/bitbucket-cloud/docs/set-up-and-use-code-owners/) and use it alongside your ownership rules to assign Sentry issues.
+        """,
+        IntegrationFeatures.CODEOWNERS,
+    ),
 ]
 
 metadata = IntegrationMetadata(
@@ -94,6 +100,8 @@
 
 
 class BitbucketIntegration(RepositoryIntegration, BitbucketIssuesSpec):
+    codeowners_locations = [".bitbucket/CODEOWNERS"]
+
     @property
     def integration_name(self) -> str:
         return "bitbucket"
@@ -185,6 +193,7 @@ class BitbucketIntegrationProvider(IntegrationProvider):
             IntegrationFeatures.ISSUE_BASIC,
             IntegrationFeatures.COMMITS,
             IntegrationFeatures.STACKTRACE_LINK,
+            IntegrationFeatures.CODEOWNERS,
         ]
     )
 

src/sentry/integrations/services/integration/impl.py

@@ -41,10 +41,15 @@
 )
 from sentry.rules.actions.notify_event_service import find_alert_rule_action_ui_component
 from sentry.sentry_apps.api.serializers.app_platform_event import AppPlatformEvent
+from sentry.sentry_apps.metrics import (
+    SentryAppEventType,
+    SentryAppInteractionEvent,
+    SentryAppInteractionType,
+)
 from sentry.sentry_apps.models.sentry_app import SentryApp
 from sentry.sentry_apps.models.sentry_app_installation import SentryAppInstallation
 from sentry.shared_integrations.exceptions import ApiError
-from sentry.utils import json, metrics
+from sentry.utils import json
 from sentry.utils.sentry_apps import send_and_save_webhook_request
 
 if TYPE_CHECKING:
@@ -368,44 +373,40 @@ def send_incident_alert_notification(
         notification_uuid: str | None = None,
     ) -> bool:
         try:
-            sentry_app = SentryApp.objects.get(id=sentry_app_id)
-        except SentryApp.DoesNotExist:
-            logger.info(
-                "metric_alert_webhook.missing_sentryapp",
-                extra={
-                    "sentry_app_id": sentry_app_id,
-                    "organization_id": organization_id,
-                },
-            )
+            new_status_str = INCIDENT_STATUS[IncidentStatus(new_status)].lower()
+            event = SentryAppEventType(f"metric_alert.{new_status_str}")
+        except ValueError as e:
+            sentry_sdk.capture_exception(e)
             return False
 
-        metrics.incr("notifications.sent", instance=sentry_app.slug, skip_internal=False)
+        with SentryAppInteractionEvent(
+            operation_type=SentryAppInteractionType.PREPARE_WEBHOOK,
+            event_type=event,
+        ).capture() as lifecycle:
+            try:
+                sentry_app = SentryApp.objects.get(id=sentry_app_id)
+            except SentryApp.DoesNotExist as e:
+                sentry_sdk.capture_exception(e)
+                lifecycle.record_failure(e)
+                return False
 
-        try:
-            install = SentryAppInstallation.objects.get(
-                organization_id=organization_id,
-                sentry_app=sentry_app,
-                status=SentryAppInstallationStatus.INSTALLED,
-            )
-        except SentryAppInstallation.DoesNotExist:
-            logger.info(
-                "metric_alert_webhook.missing_installation",
-                extra={
-                    "action": action_id,
-                    "incident": incident_id,
-                    "organization_id": organization_id,
-                    "sentry_app_id": sentry_app.id,
-                },
-                exc_info=True,
-            )
-            return False
+            try:
+                install = SentryAppInstallation.objects.get(
+                    organization_id=organization_id,
+                    sentry_app=sentry_app,
+                    status=SentryAppInstallationStatus.INSTALLED,
+                )
+            except SentryAppInstallation.DoesNotExist as e:
+                sentry_sdk.capture_exception(e)
+                lifecycle.record_failure(e)
+                return False
 
-        app_platform_event = AppPlatformEvent(
-            resource="metric_alert",
-            action=INCIDENT_STATUS[IncidentStatus(new_status)].lower(),
-            install=install,
-            data=json.loads(incident_attachment_json),
-        )
+            app_platform_event = AppPlatformEvent(
+                resource="metric_alert",
+                action=new_status_str,
+                install=install,
+                data=json.loads(incident_attachment_json),
+            )
 
         # Can raise errors if client returns >= 400
         send_and_save_webhook_request(

src/sentry/models/commitfilechange.py

@@ -48,13 +48,16 @@ def is_valid_type(value: str) -> bool:
 
 
 def process_resource_change(instance, **kwargs):
+    from sentry.integrations.bitbucket.integration import BitbucketIntegration
     from sentry.integrations.github.integration import GitHubIntegration
     from sentry.integrations.gitlab.integration import GitlabIntegration
     from sentry.tasks.codeowners import code_owners_auto_sync
 
     def _spawn_task():
-        filepaths = set(GitHubIntegration.codeowners_locations) | set(
-            GitlabIntegration.codeowners_locations
+        filepaths = (
+            set(GitHubIntegration.codeowners_locations)
+            | set(GitlabIntegration.codeowners_locations)
+            | set(BitbucketIntegration.codeowners_locations)
         )
 
         # CODEOWNERS file added or modified, trigger auto-sync

src/sentry/models/project.py

@@ -108,6 +108,7 @@
     "javascript-solidstart",
     "javascript-svelte",
     "javascript-sveltekit",
+    "javascript-tanstackstart-react",
     "javascript-nuxt",
     "javascript-vue",
     "kotlin",