feat: Integrate with Sentry feature flag Change Tracking (#5531)

Author: emyller

api/audit/signals.py

@@ -1,17 +1,23 @@
 import logging
-import typing
+from typing import Any, Callable, Literal, Protocol, Type
 
 from django.conf import settings
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 
-from audit.models import AuditLog, RelatedObjectType  # type: ignore[attr-defined]
+from audit.models import AuditLog
+from audit.related_object_type import RelatedObjectType
 from audit.serializers import AuditLogListSerializer
+from audit.services import get_audited_instance_from_audit_log_record
+from features.models import FeatureState
+from features.signals import feature_state_change_went_live
 from integrations.common.models import IntegrationsModel
 from integrations.datadog.datadog import DataDogWrapper
 from integrations.dynatrace.dynatrace import DynatraceWrapper
 from integrations.grafana.grafana import GrafanaWrapper
 from integrations.new_relic.new_relic import NewRelicWrapper
+from integrations.sentry.change_tracking import SentryChangeTracking
+from integrations.sentry.models import SentryChangeTrackingConfiguration
 from integrations.slack.slack import SlackWrapper
 from organisations.models import OrganisationWebhook
 from webhooks.tasks import call_organisation_webhooks
@@ -20,7 +26,7 @@
 logger = logging.getLogger(__name__)
 
 
-AuditLogIntegrationAttrName = typing.Literal[
+AuditLogIntegrationAttrName = Literal[
     "data_dog_config",
     "dynatrace_config",
     "grafana_config",
@@ -29,6 +35,18 @@
 ]
 
 
+class _AuditLogSignalHandler(Protocol):
+    def __call__(
+        self,
+        sender: Type[AuditLog],
+        instance: AuditLog,
+        **kwargs: Any,
+    ) -> None: ...
+
+
+_DecoratedSignal = Callable[[_AuditLogSignalHandler], _AuditLogSignalHandler]
+
+
 def _get_integration_config(
     instance: AuditLog,
     integration_name: AuditLogIntegrationAttrName,
@@ -71,25 +89,41 @@ def call_webhooks(sender, instance, **kwargs):  # type: ignore[no-untyped-def]
         )
 
 
-def track_only_feature_related_events(signal_function):  # type: ignore[no-untyped-def]
-    def signal_wrapper(sender, instance, **kwargs):  # type: ignore[no-untyped-def]
-        # Only handle Feature related changes
-        if instance.related_object_type not in [
-            RelatedObjectType.FEATURE.name,
-            RelatedObjectType.FEATURE_STATE.name,
-            RelatedObjectType.SEGMENT.name,
-            RelatedObjectType.EF_VERSION.name,
-        ]:
-            return None
-        return signal_function(sender, instance, **kwargs)
+def track_only(types: list[RelatedObjectType]) -> _DecoratedSignal:
+    """
+    Restrict an AuditLog signal to a certain list of RelatedObjectType
+    """
 
-    return signal_wrapper
+    def decorator(signal_function: _AuditLogSignalHandler) -> _AuditLogSignalHandler:
+        def signal_wrapper(
+            sender: Type[AuditLog],
+            instance: AuditLog,
+            **kwargs: Any,
+        ) -> None:
+            type_names = (t.name for t in types)
+            if instance.related_object_type not in type_names:
+                return None
+            return signal_function(sender, instance, **kwargs)
 
+        return signal_wrapper
 
-def _track_event_async(instance, integration_client):  # type: ignore[no-untyped-def]
-    event_data = integration_client.generate_event_data(audit_log_record=instance)
+    return decorator
 
-    integration_client.track_event_async(event=event_data)
+
+def track_only_feature_related_events(signal_function):  # type: ignore[no-untyped-def]
+    allowed_types = [
+        RelatedObjectType.FEATURE,
+        RelatedObjectType.FEATURE_STATE,
+        RelatedObjectType.SEGMENT,
+        RelatedObjectType.EF_VERSION,
+    ]
+    return track_only(allowed_types)(signal_function)
+
+
+def _track_event_async(instance, integration_client):  # type: ignore[no-untyped-def]
+    if event_data := integration_client.generate_event_data(audit_log_record=instance):
+        integration_client.track_event_async(event=event_data)
+        return
 
 
 @receiver(post_save, sender=AuditLog)
@@ -166,3 +200,34 @@ def send_audit_log_event_to_slack(sender, instance, **kwargs):  # type: ignore[n
         api_token=slack_project_config.api_token, channel_id=env_config.channel_id
     )
     _track_event_async(instance, slack)  # type: ignore[no-untyped-call]
+
+
+@receiver(post_save, sender=AuditLog)
+@track_only([RelatedObjectType.FEATURE_STATE])
+def send_feature_flag_went_live_signal(sender, instance, **kwargs):  # type: ignore[no-untyped-def]
+    feature_state = get_audited_instance_from_audit_log_record(instance)
+    if not isinstance(feature_state, FeatureState):
+        return
+
+    if feature_state.is_scheduled:
+        return  # This is handled by audit.tasks.create_feature_state_went_live_audit_log
+
+    feature_state_change_went_live.send(instance)
+
+
+@receiver(feature_state_change_went_live)
+def send_audit_log_event_to_sentry(sender: AuditLog, **kwargs: Any) -> None:
+    try:
+        sentry_configuration = SentryChangeTrackingConfiguration.objects.get(
+            environment=sender.environment,
+            deleted_at__isnull=True,
+        )
+    except SentryChangeTrackingConfiguration.DoesNotExist:
+        return
+
+    sentry_change_tracking = SentryChangeTracking(
+        webhook_url=sentry_configuration.webhook_url,
+        secret=sentry_configuration.secret,
+    )
+
+    _track_event_async(sender, sentry_change_tracking)  # type: ignore[no-untyped-call]

api/audit/tasks.py

@@ -36,6 +36,7 @@ def _create_feature_state_audit_log_for_change_request(  # type: ignore[no-untyp
     feature_state_id: int, msg_template: str
 ):
     from features.models import FeatureState
+    from features.signals import feature_state_change_went_live
 
     feature_state = FeatureState.objects.filter(id=feature_state_id).first()
 
@@ -64,7 +65,7 @@ def _create_feature_state_audit_log_for_change_request(  # type: ignore[no-untyp
         feature_state.change_request.title,
     )
     # NOTE: This NEEDS to leverage btree indexes on AuditLog
-    _, log_created = AuditLog.objects.get_or_create(
+    audit_log, log_created = AuditLog.objects.get_or_create(
         created_date=feature_state.live_from,
         environment=feature_state.environment,
         is_system_event=True,
@@ -73,7 +74,9 @@ def _create_feature_state_audit_log_for_change_request(  # type: ignore[no-untyp
         related_object_id=feature_state.id,
         related_object_type=RelatedObjectType.FEATURE_STATE.name,
     )
-    if not log_created:
+    if log_created:
+        feature_state_change_went_live.send(audit_log)
+    else:
         logger.info(
             "FeatureState update audit log already exists. "
             "Likely the change request was rescheduled to an earlier date.",
@@ -96,16 +99,17 @@ def create_audit_log_from_historical_record(  # type: ignore[no-untyped-def]
     ):
         return
 
-    user_model = get_user_model()
-
     instance = history_instance.instance
     if instance.get_skip_create_audit_log():
         return
 
-    history_user = user_model.objects.filter(id=history_user_id).first()
+    if history_user_id is not None:
+        user_model = get_user_model()
+        history_user = user_model.objects.filter(id=history_user_id).first()
+    else:
+        history_user = instance.get_audit_log_author(history_instance)
 
-    override_author = instance.get_audit_log_author(history_instance)
-    if not (history_user or override_author or history_instance.master_api_key):
+    if not (history_user or history_instance.master_api_key):
         return
 
     environment, project = instance.get_environment_and_project()
@@ -130,7 +134,7 @@ def create_audit_log_from_historical_record(  # type: ignore[no-untyped-def]
         history_record_class_path=history_record_class_path,
         environment=environment,
         project=project,
-        author=override_author or history_user,
+        author=history_user,
         related_object_id=related_object_id,
         related_object_type=related_object_type.name,
         log=log_message,

api/environments/urls.py

@@ -19,6 +19,7 @@
 from integrations.mixpanel.views import MixpanelConfigurationViewSet
 from integrations.rudderstack.views import RudderstackConfigurationViewSet
 from integrations.segment.views import SegmentConfigurationViewSet
+from integrations.sentry.views import SentryChangeTrackingConfigurationViewSet
 from integrations.slack.views import (
     SlackEnvironmentViewSet,
     SlackGetChannelsViewSet,
@@ -99,6 +100,11 @@
     MixpanelConfigurationViewSet,
     basename="integrations-mixpanel",
 )
+environments_router.register(
+    r"integrations/sentry",
+    SentryChangeTrackingConfigurationViewSet,
+    basename="integrations-sentry",
+)
 environments_router.register(
     r"integrations/slack", SlackEnvironmentViewSet, basename="integrations-slack"
 )

api/features/signals.py

@@ -1,14 +1,16 @@
 import logging
 
 from django.db.models.signals import post_save
-from django.dispatch import receiver
+from django.dispatch import Signal, receiver
 
 # noinspection PyUnresolvedReferences
 from .models import FeatureState
 from .tasks import trigger_feature_state_change_webhooks
 
 logger = logging.getLogger(__name__)
 
+feature_state_change_went_live = Signal()
+
 
 @receiver(post_save, sender=FeatureState)
 def trigger_feature_state_change_webhooks_signal(instance, **kwargs):  # type: ignore[no-untyped-def]

api/integrations/sentry/change_tracking.py

@@ -0,0 +1,102 @@
+import json
+import logging
+from typing import Any
+
+import requests
+from django.core.serializers.json import DjangoJSONEncoder
+
+from audit.models import AuditLog
+from audit.services import get_audited_instance_from_audit_log_record
+from core.signing import sign_payload
+from features.models import FeatureState
+from integrations.common.wrapper import AbstractBaseEventIntegrationWrapper
+
+logger = logging.getLogger(__name__)
+
+
+class SentryChangeTracking(AbstractBaseEventIntegrationWrapper):
+    """
+    Change Tracking integration with Sentry
+
+    Spec: https://github.com/getsentry/sentry/blob/master/src/sentry/flags/docs/api.md#create-generic-flag-log-post
+
+    NOTE: This triggers when...
+    - ...creating the flag because there is a hook to create (save) the initial feature state.
+    - ...updating the flag because there is a signal to trigger this on model save.
+    - ...deleting the flag because deleting means saving the model instance with a deleted_at timestamp.
+    """
+
+    def __init__(self, webhook_url: str, secret: str) -> None:
+        self.webhook_url = webhook_url
+        self.secret = secret
+
+    @staticmethod
+    def generate_event_data(audit_log_record: AuditLog) -> dict[str, Any]:
+        feature_state = get_audited_instance_from_audit_log_record(audit_log_record)
+        if not isinstance(feature_state, FeatureState):  # pragma: no cover
+            logger.warning(
+                f"{type(feature_state)} is not supported by Sentry Change Tracking integration."
+            )
+            return {}
+
+        update_published_at = feature_state.deleted_at or (
+            max(feature_state.live_from, feature_state.updated_at)
+            if feature_state.live_from
+            else feature_state.updated_at
+        )
+
+        action = {
+            "+": "created",
+            "-": "deleted",
+            "~": "updated",
+        }[audit_log_record.history_record.history_type]  # type: ignore[union-attr]
+
+        inner_payload = {
+            "action": action,
+            "flag": feature_state.feature.name,
+            "created_at": update_published_at.isoformat(timespec="seconds"),
+            "created_by": {
+                "id": getattr(audit_log_record.author, "email", "app@flagsmith.com"),
+                "type": "email",
+            },
+        }
+
+        if action == "updated":
+            inner_payload["change_id"] = str(feature_state.pk)
+
+        return inner_payload
+
+    def _track_event(self, event: dict[str, Any]) -> None:
+        action = event["action"]
+        feature_name = event["flag"]
+        logger.debug("Sending '%s' (%s) to Sentry...", feature_name, action)
+
+        payload = {
+            "data": [event],
+            "meta": {"version": 1},
+        }
+        json_payload = json.dumps(payload, sort_keys=True, cls=DjangoJSONEncoder)
+
+        headers = {
+            "Content-Type": "application/json",
+            "X-Sentry-Signature": sign_payload(json_payload, self.secret),
+        }
+
+        response = requests.post(
+            url=self.webhook_url,
+            headers=headers,
+            data=json_payload,
+        )
+
+        try:
+            response.raise_for_status()
+        except requests.exceptions.RequestException as error:
+            # TODO: Should we retry, or ultimately notify the admin of a persisting issue?
+            logger.error(
+                "Error sending '%s' (%s) to Sentry: %s",
+                feature_name,
+                action,
+                repr(error),
+            )
+        else:
+            logger.debug("Sent '%s' (%s) to Sentry", feature_name, action)