Merge branch 'master' into replay-carousal

Author: jerryzhou196

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

@@ -25,7 +25,7 @@
 from sentry.db.models.query import create_or_update
 from sentry.hybridcloud.rpc import coerce_id_from
 from sentry.integrations.tasks.kick_off_status_syncs import kick_off_status_syncs
-from sentry.issues.grouptype import GroupCategory, get_group_type_by_type_id
+from sentry.issues.grouptype import GroupCategory
 from sentry.issues.ignored import handle_archived_until_escalating, handle_ignored
 from sentry.issues.merge import MergedGroup, handle_merge
 from sentry.issues.priority import update_priority
@@ -206,12 +206,9 @@ def update_groups(
     status = result.get("status")
     res_type = None
     if "priority" in result:
-        if any(
-            not get_group_type_by_type_id(group.type).enable_user_priority_changes
-            for group in groups
-        ):
+        if any(not group.issue_type.enable_user_status_and_priority_changes for group in groups):
             return Response(
-                {"detail": "Cannot manually set priority of a metric issue."},
+                {"detail": "Cannot manually set priority of one or more issues."},
                 status=HTTPStatus.BAD_REQUEST,
             )
 
@@ -222,6 +219,12 @@ def update_groups(
             project_lookup=project_lookup,
         )
     if status in ("resolved", "resolvedInNextRelease"):
+        if any(not group.issue_type.enable_user_status_and_priority_changes for group in groups):
+            return Response(
+                {"detail": "Cannot manually resolve one or more issues."},
+                status=HTTPStatus.BAD_REQUEST,
+            )
+
         try:
             result, res_type = handle_resolve_in_release(
                 status,

src/sentry/incidents/grouptype.py

@@ -333,7 +333,7 @@ class MetricIssue(GroupType):
     enable_escalation_detection = False
     enable_status_change_workflow_notifications = False
     enable_workflow_notifications = False
-    enable_user_priority_changes = False
+    enable_user_status_and_priority_changes = False
     detector_settings = DetectorSettings(
         handler=MetricIssueDetectorHandler,
         validator=MetricIssueDetectorValidator,

src/sentry/issues/grouptype.py

@@ -219,7 +219,7 @@ class GroupType:
     enable_workflow_notifications = True
 
     # Controls whether users are able to manually update the group's priority.
-    enable_user_priority_changes = True
+    enable_user_status_and_priority_changes = True
 
     # Controls whether Seer automation is always triggered for this group type.
     always_trigger_seer_automation = False

src/sentry/middleware/integrations/parsers/github.py

@@ -100,6 +100,13 @@ def get_response(self) -> HttpResponseBase:
             if codecov_regions:
                 self.try_forward_to_codecov(event=event)
 
+        logger.info(
+            "overwatch.debug.forward_if_applicable.begin",
+            extra={
+                "headers_keys": list(self.request.headers.keys()),
+                "integration_id": integration.id,
+            },
+        )
         # The overwatch forwarder implements its own region-based checks
         OverwatchGithubWebhookForwarder(integration=integration).forward_if_applicable(
             event=event, headers=self.request.headers

src/sentry/overwatch_webhooks/webhook_forwarder.py

@@ -53,8 +53,23 @@ def _get_org_summaries_by_region_for_integration(
         org_integrations = OrganizationIntegration.objects.filter(
             integration=integration, status=ObjectStatus.ACTIVE
         )
+        logger.info(
+            "overwatch.debug.org_integrations.fetched",
+            extra={
+                "integration_id": integration.id,
+                "org_integration_ids": [oi.organization_id for oi in org_integrations],
+                "count": len(org_integrations),
+            },
+        )
         organization_ids = [org_integration.organization_id for org_integration in org_integrations]
         org_mappings = OrganizationMapping.objects.filter(organization_id__in=organization_ids)
+        logger.info(
+            "overwatch.debug.org_mappings.fetched",
+            extra={
+                "org_mapping_ids": [om.organization_id for om in org_mappings],
+                "count": len(org_mappings),
+            },
+        )
         org_mappings_by_id = {
             org_mapping.organization_id: org_mapping for org_mapping in org_mappings
         }
@@ -71,37 +86,87 @@ def _get_org_summaries_by_region_for_integration(
                     organization_mapping=org_mapping,
                 )
             )
+            logger.info(
+                "overwatch.debug.organizations.grouped_by_region",
+                extra={
+                    "region_name": region_name,
+                    "org_id": org_integration.organization_id,
+                },
+            )
+
+        logger.info(
+            "overwatch.debug.org_contexts_by_region.final",
+            extra={
+                "regions": list(org_contexts_by_region.keys()),
+                "counts_per_region": {k: len(v) for k, v in org_contexts_by_region.items()},
+            },
+        )
 
         return org_contexts_by_region
 
     def forward_if_applicable(self, event: Mapping[str, Any], headers: Mapping[str, str]):
+        region_name = None
         try:
             enabled_regions = options.get("overwatch.enabled-regions")
+            logger.info(
+                "overwatch.debug.enabled_regions", extra={"enabled_regions": enabled_regions}
+            )
             if not enabled_regions:
                 # feature isn't enabled, no work to do
+                logger.info("overwatch.debug.excluded.feature_not_enabled", extra={})
                 return
 
             orgs_by_region = self._get_org_summaries_by_region_for_integration(
                 integration=self.integration
             )
+            logger.info(
+                "overwatch.debug.orgs_by_region",
+                extra={
+                    "regions": list(orgs_by_region.keys()),
+                    "counts_per_region": {k: len(v) for k, v in orgs_by_region.items()},
+                },
+            )
 
             if not orgs_by_region or not self.should_forward_to_overwatch(headers):
+                logger.info(
+                    "overwatch.debug.skipped_forwarding",
+                    extra={
+                        "orgs_by_region_empty": not orgs_by_region,
+                        "event_in_forward_list": self.should_forward_to_overwatch(headers),
+                    },
+                )
                 return
 
             # We can conditionally opt into forwarding on a per-region basis,
             # similar to codecov's current implementation.
             for region_name, org_summaries in orgs_by_region.items():
+                logger.info(
+                    "overwatch.debug.check_region",
+                    extra={
+                        "region_name": region_name,
+                        "enabled": region_name in enabled_regions,
+                        "org_summaries_count": len(org_summaries),
+                    },
+                )
                 if region_name not in enabled_regions:
                     continue
 
                 raw_app_id = headers.get(
                     GITHUB_INSTALLATION_TARGET_ID_HEADER,
                 ) or headers.get(DJANGO_HTTP_GITHUB_INSTALLATION_TARGET_ID_HEADER)
+                logger.info(
+                    "overwatch.debug.raw_app_id",
+                    extra={"region_name": region_name, "raw_app_id": raw_app_id},
+                )
                 app_id: int | None = None
                 if raw_app_id is not None:
                     try:
                         app_id = int(raw_app_id)
                     except (TypeError, ValueError):
+                        logger.info(
+                            "overwatch.debug.app_id_parse_error",
+                            extra={"region_name": region_name, "raw_app_id": raw_app_id},
+                        )
                         app_id = None
 
                 webhook_detail = WebhookDetails(
@@ -112,17 +177,25 @@ def forward_if_applicable(self, event: Mapping[str, Any], headers: Mapping[str,
                     region=region_name,
                     app_id=app_id,
                 )
+                logger.info(
+                    "overwatch.debug.webhook_detail.created",
+                    extra={"region_name": region_name, "app_id": app_id},
+                )
 
                 publisher = OverwatchWebhookPublisher(
                     integration_provider=self.integration.provider,
                     region=get_region_by_name(region_name),
                 )
+                logger.info("overwatch.debug.enqueue_webhook", extra={"region_name": region_name})
                 publisher.enqueue_webhook(webhook_detail)
                 metrics.incr(
                     "overwatch.forward-webhooks.success",
                     sample_rate=1.0,
                     tags={"forward_region": region_name},
                 )
+                logger.info(
+                    "overwatch.debug.metrics_incr.success", extra={"region_name": region_name}
+                )
         except Exception:
             metrics.incr(
                 "overwatch.forward-webhooks.forward-error",

src/sentry/workflow_engine/endpoints/organization_detector_details.py

@@ -35,7 +35,6 @@
 )
 from sentry.workflow_engine.endpoints.validators.utils import get_unknown_detector_type_error
 from sentry.workflow_engine.models import Detector
-from sentry.workflow_engine.types import DetectorLifeCycleHooks
 
 
 def get_detector_validator(
@@ -205,8 +204,6 @@ def delete(self, request: Request, organization: Organization, detector: Detecto
         )
         validator.delete()
 
-        DetectorLifeCycleHooks.on_pending_delete(detector)
-
         if detector.type == MetricIssue.slug:
             schedule_update_project_config(detector)
 

src/sentry/workflow_engine/endpoints/validators/base/detector.py

@@ -30,7 +30,7 @@
 )
 from sentry.workflow_engine.models.data_condition import DataCondition
 from sentry.workflow_engine.models.detector import enforce_config_schema
-from sentry.workflow_engine.types import DataConditionType, DetectorLifeCycleHooks
+from sentry.workflow_engine.types import DataConditionType
 
 
 @dataclass(frozen=True)
@@ -143,7 +143,6 @@ def update(self, instance: Detector, validated_data: dict[str, Any]):
             data=instance.get_audit_log_data(),
         )
 
-        DetectorLifeCycleHooks.on_after_update(instance)
         return instance
 
     def delete(self) -> None:
@@ -230,6 +229,4 @@ def create(self, validated_data):
                 data=detector.get_audit_log_data(),
             )
 
-            DetectorLifeCycleHooks.on_after_create(detector)
-
         return detector

src/sentry/workflow_engine/types.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import Callable
 from dataclasses import dataclass, field
 from enum import IntEnum, StrEnum
 from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypedDict, TypeVar
@@ -184,54 +183,8 @@ class SnubaQueryDataSourceType(TypedDict):
     event_types: list[SnubaQueryEventType]
 
 
-type DetectorLifeCycleHook = Callable[[Detector], None]
-
-
-@dataclass(frozen=True)
-class DetectorLifeCycleHooks:
-    """
-    The DetectorLifeCycleHooks allow for hooks to be added into different areas of the API.
-    These hooks are only invoked through the API, for changes that might be happening outside of the API,
-    it's recommended to use a signal to capture the model updates.
-
-    Args:
-        after_create:
-            This method is used as a callback after a detector is created. The first argument is the detector that was created.
-
-        before_delete:
-            This method is used in the deletion API for a detector, the callback will be invoked with the id for the detector
-            that is deleted.
-
-        after_update:
-           This method is used to access when a detector is updated in the API.
-    """
-
-    after_create: DetectorLifeCycleHook | None = None
-    pending_delete: DetectorLifeCycleHook | None = None
-    after_update: DetectorLifeCycleHook | None = None
-
-    @staticmethod
-    def on_after_create(detector: Detector):
-        hooks = detector.settings.hooks
-        if hooks and hooks.after_create:
-            hooks.after_create(detector)
-
-    @staticmethod
-    def on_after_update(detector: Detector):
-        hooks = detector.settings.hooks
-        if hooks and hooks.after_update:
-            hooks.after_update(detector)
-
-    @staticmethod
-    def on_pending_delete(detector: Detector):
-        hooks = detector.settings.hooks
-        if hooks and hooks.pending_delete:
-            hooks.pending_delete(detector)
-
-
 @dataclass(frozen=True)
 class DetectorSettings:
-    hooks: DetectorLifeCycleHooks | None = None
     handler: type[DetectorHandler] | None = None
     validator: type[BaseDetectorTypeValidator] | None = None
     config_schema: dict[str, Any] = field(default_factory=dict)

src/sentry/workflow_engine/typings/grouptype.py

@@ -17,4 +17,4 @@ class IssueStreamGroupType(GroupType):
     enable_escalation_detection = False
     enable_status_change_workflow_notifications = False
     enable_workflow_notifications = False
-    enable_user_priority_changes = False
+    enable_user_status_and_priority_changes = False

static/app/__mocks__/api.tsx

@@ -275,8 +275,7 @@ class Client implements ApiNamespace.Client {
             abort: () => {},
             then: () => {},
             error: () => {},
-          },
-          new XMLHttpRequest()
+          }
         );
 
         this.handleRequestError(