Merge branch 'master' into brendan/get-orgs-with-usage

Author: brendanhsentry

src/sentry/billing/platform/services/category_mapping.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from sentry_protos.billing.v1.data_category_pb2 import DataCategory as ProtoDataCategory
+
+from sentry.constants import DataCategory
+from sentry.utils import metrics
+
+SENTRY_TO_PROTO_CATEGORY: dict[int, int] = {
+    int(DataCategory.ERROR): ProtoDataCategory.DATA_CATEGORY_ERROR,
+    int(DataCategory.TRANSACTION): ProtoDataCategory.DATA_CATEGORY_TRANSACTION,
+    int(DataCategory.ATTACHMENT): ProtoDataCategory.DATA_CATEGORY_ATTACHMENT,
+    int(DataCategory.PROFILE): ProtoDataCategory.DATA_CATEGORY_PROFILE,
+    int(DataCategory.REPLAY): ProtoDataCategory.DATA_CATEGORY_REPLAY,
+    int(DataCategory.MONITOR): ProtoDataCategory.DATA_CATEGORY_MONITOR,
+    int(DataCategory.SPAN): ProtoDataCategory.DATA_CATEGORY_SPAN,
+    int(DataCategory.USER_REPORT_V2): ProtoDataCategory.DATA_CATEGORY_USER_REPORT_V2,
+    int(DataCategory.PROFILE_DURATION): ProtoDataCategory.DATA_CATEGORY_PROFILE_DURATION,
+    int(DataCategory.LOG_BYTE): ProtoDataCategory.DATA_CATEGORY_LOG_BYTE,
+    int(DataCategory.PROFILE_DURATION_UI): ProtoDataCategory.DATA_CATEGORY_PROFILE_DURATION_UI,
+    int(DataCategory.SEER_AUTOFIX): ProtoDataCategory.DATA_CATEGORY_SEER_AUTOFIX,
+    int(DataCategory.SEER_SCANNER): ProtoDataCategory.DATA_CATEGORY_SEER_SCANNER,
+    int(DataCategory.SIZE_ANALYSIS): ProtoDataCategory.DATA_CATEGORY_SIZE_ANALYSIS,
+    int(DataCategory.INSTALLABLE_BUILD): ProtoDataCategory.DATA_CATEGORY_INSTALLABLE_BUILD,
+    int(DataCategory.TRACE_METRIC): ProtoDataCategory.DATA_CATEGORY_TRACE_METRIC,
+    int(DataCategory.DEFAULT): ProtoDataCategory.DATA_CATEGORY_DEFAULT,
+    int(DataCategory.SECURITY): ProtoDataCategory.DATA_CATEGORY_SECURITY,
+    int(DataCategory.PROFILE_CHUNK): ProtoDataCategory.DATA_CATEGORY_PROFILE_CHUNK,
+    int(DataCategory.PROFILE_CHUNK_UI): ProtoDataCategory.DATA_CATEGORY_PROFILE_CHUNK_UI,
+}
+
+
+PROTO_TO_SENTRY_CATEGORY: dict[int, int] = {v: k for k, v in SENTRY_TO_PROTO_CATEGORY.items()}
+
+
+def proto_to_sentry_category(proto_category: int) -> int:
+    """Convert a proto DataCategory to its Sentry equivalent.
+
+    For categories with a known mapping, returns the sentry int value.
+    For unmapped categories, passes through the original int value and
+    emits a metric so we can track how often this happens.
+    """
+    result = PROTO_TO_SENTRY_CATEGORY.get(proto_category)
+    if result is None:
+        metrics.incr(
+            "billing.proto_category_mapping.unmapped_reverse",
+            tags={"proto_category": str(proto_category)},
+        )
+        return proto_category
+    return result
+
+
+def sentry_to_proto_category(category: int | DataCategory) -> ProtoDataCategory.ValueType:
+    """Convert a Sentry DataCategory to its proto equivalent.
+
+    For categories with a known mapping, returns the proto enum value.
+    For unmapped categories, passes through the original int value and
+    emits a metric so we can track how often this happens.
+    """
+    cat_int = int(category)
+    result = SENTRY_TO_PROTO_CATEGORY.get(cat_int)
+    if result is None:
+        metrics.incr(
+            "billing.proto_category_mapping.unmapped",
+            tags={"sentry_category": str(cat_int)},
+        )
+        return ProtoDataCategory.ValueType(cat_int)
+    return ProtoDataCategory.ValueType(result)

src/sentry/billing/platform/services/usage/_category_mapping.py

@@ -34,7 +34,7 @@
 )
 from snuba_sdk.orderby import Direction
 
-from sentry.billing.platform.services.usage._category_mapping import proto_to_relay_category
+from sentry.billing.platform.services.category_mapping import proto_to_sentry_category
 from sentry.snuba.referrer import Referrer
 from sentry.utils import metrics
 from sentry.utils.outcomes import Outcome
@@ -94,7 +94,7 @@ def query_outcomes_usage(request: GetUsageRequest) -> GetUsageResponse:
     end = _timestamp_to_datetime(request.end) + timedelta(days=1)
     # Proto categories use different int values from Relay/ClickHouse
     # (e.g., proto ATTACHMENT=3 vs Relay ATTACHMENT=4). Convert before querying.
-    categories = [proto_to_relay_category(c) for c in request.categories]
+    categories = [proto_to_sentry_category(c) for c in request.categories]
 
     snuba_request = _build_query(org_id, start, end, categories, total_outcomes=_BILLABLE_OUTCOMES)
     result = raw_snql_query(snuba_request, referrer=_REFERRER)

src/sentry/billing/platform/services/usage/_outcomes_query.py

@@ -462,15 +462,22 @@ def send_alert(
 
         incident_serialized_response = serialize(incident, serializer=IncidentSerializer())
 
-        send_incident_alert_notification(
+        success = send_incident_alert_notification(
             notification_context=notification_context,
             alert_context=alert_context,
             metric_issue_context=metric_issue_context,
             incident_serialized_response=incident_serialized_response,
             organization=incident.organization,
-            project_id=project.id,
             notification_uuid=notification_uuid,
         )
+        if success:
+            self.record_alert_sent_analytics(
+                organization_id=incident.organization.id,
+                project_id=project.id,
+                alert_id=incident.alert_rule.id,
+                external_id=action.sentry_app_id,
+                notification_uuid=notification_uuid,
+            )
 
 
 def format_duration(minutes):

src/sentry/incidents/action_handlers.py

@@ -45,6 +45,7 @@
     serialize_integration_external_project,
     serialize_organization_integration,
 )
+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,
@@ -53,11 +54,7 @@
 )
 from sentry.sentry_apps.models.sentry_app import SentryApp
 from sentry.sentry_apps.models.sentry_app_installation import SentryAppInstallation
-from sentry.sentry_apps.utils.webhooks import (
-    MetricAlertActionType,
-    SentryAppResourceType,
-    find_alert_rule_action_ui_component,
-)
+from sentry.sentry_apps.utils.webhooks import MetricAlertActionType, SentryAppResourceType
 from sentry.shared_integrations.exceptions import ApiError
 from sentry.utils import json
 from sentry.utils.sentry_apps import send_and_save_webhook_request

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

@@ -54,6 +54,5 @@ def send_alert(
             metric_issue_context=metric_issue_context,
             incident_serialized_response=incident_serialized_response,
             organization=organization,
-            project_id=project.id,
             notification_uuid=notification_uuid,
         )

src/sentry/notifications/notification_action/metric_alert_registry/handlers/sentry_app_metric_alert_handler.py

@@ -124,13 +124,16 @@ def issue_notification_data_factory(invocation: ActionInvocation) -> IssueNotifi
         detector=detector,
         event_data=event_data,
     )
-    rule_instance.data["tags"] = action.data.get("tags", "")
-    rule_instance.data["notes"] = action.data.get("notes", "")
+    tags = action.data.get("tags", None)
+    tag_list = [tag.strip() for tag in tags.split(",")] if tags else None
+    notes = action.data.get("notes", None)
     rule = SerializableRuleProxy.from_rule(rule_instance)
 
     event_id = getattr(event_data.event, "event_id", None) if event_data.event else None
 
     return IssueNotificationData(
+        tags=tag_list,
+        notes=notes,
         event_id=event_id,
         group_id=event_data.group.id,
         notification_uuid=invocation.notification_uuid,

src/sentry/notifications/notification_action/utils.py

@@ -21,6 +21,7 @@
     NotificationBodyFormattingBlockType,
     NotificationBodyTextBlock,
     NotificationBodyTextBlockType,
+    NotificationCategory,
     NotificationData,
     NotificationProviderKey,
     NotificationRenderedTemplate,
@@ -136,6 +137,16 @@ def is_available(cls, *, organization: RpcOrganizationSummary | None = None) ->
         # TODO(ecosystem): Check for the integration, maybe a feature as well
         return False
 
+    @classmethod
+    def get_renderer(
+        cls, *, data: NotificationData, category: NotificationCategory
+    ) -> type[NotificationRenderer[DiscordRenderable]]:
+        from sentry.notifications.platform.discord.renderers.issue import IssueDiscordRenderer
+
+        if category == NotificationCategory.ISSUE:
+            return IssueDiscordRenderer
+        return cls.default_renderer
+
     @classmethod
     def send(
         cls,

src/sentry/notifications/platform/discord/provider.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from sentry import eventstore
+from sentry.integrations.discord.message_builder.issues import DiscordIssuesMessageBuilder
+from sentry.models.group import Group
+from sentry.notifications.platform.discord.provider import DiscordRenderable
+from sentry.notifications.platform.renderer import NotificationRenderer
+from sentry.notifications.platform.service import NotificationRenderError
+from sentry.notifications.platform.templates.issue import IssueNotificationData
+from sentry.notifications.platform.types import (
+    NotificationData,
+    NotificationProviderKey,
+    NotificationRenderedTemplate,
+)
+from sentry.services.eventstore.models import Event
+
+
+class IssueDiscordRenderer(NotificationRenderer[DiscordRenderable]):
+    provider_key = NotificationProviderKey.DISCORD
+
+    @classmethod
+    def render[DataT: NotificationData](
+        cls, *, data: DataT, rendered_template: NotificationRenderedTemplate
+    ) -> DiscordRenderable:
+        if not isinstance(data, IssueNotificationData):
+            raise ValueError(f"IssueDiscordRenderer does not support {data.__class__.__name__}")
+
+        # Retrieving Group and Event data is an anti-pattern, do not do this
+        # in permanent renderers.
+        try:
+            group = Group.objects.get_from_cache(id=data.group_id)
+        except Group.DoesNotExist:
+            raise NotificationRenderError(f"Group {data.group_id} not found")
+
+        group_event = None
+        if data.event_id:
+            try:
+                event = eventstore.backend.get_event_by_id(
+                    project_id=group.project.id, event_id=data.event_id, group_id=data.group_id
+                )
+                if isinstance(event, Event):
+                    # Discord only supports GroupEvents, and we can't guarantee
+                    # the type passed by eventstore, so we convert base Events
+                    # to GroupEvents.
+                    group_event = event.for_group(group)
+                else:
+                    group_event = event
+            except Exception:
+                raise NotificationRenderError(f"Failed to retrieve event {data.event_id}")
+
+        rules = [data.rule.to_rule()] if data.rule else []
+
+        return DiscordIssuesMessageBuilder(
+            group=group,
+            event=group_event,
+            tags=set(data.tags) if data.tags else None,
+            rules=rules,
+            link_to_event=True,
+        ).build(notification_uuid=data.notification_uuid)