Push feature flag events to Sentry

Author: emyller

api/integrations/sentry/apps.py

@@ -20,3 +20,6 @@ def ready(self):  # type: ignore[no-untyped-def]
                 # django.contrib.auth) you may enable sending PII data.
                 send_default_pii=True,
             )
+
+        # noinspection PyUnresolvedReferences
+        from . import signals  # noqa

api/integrations/sentry/change_tracking.py

@@ -0,0 +1,100 @@
+import json
+import logging
+from typing import Any
+
+import requests
+from django.core.serializers.json import DjangoJSONEncoder
+
+from core.signing import sign_payload
+from features.models import FeatureState
+
+from .models import SentryChangeTrackingConfiguration
+
+logger = logging.getLogger(__name__)
+
+
+def post_change_tracking_update_to_sentry(
+    feature_state: FeatureState,
+    configuration: SentryChangeTrackingConfiguration,
+) -> None:
+    """
+    Send a Change Tracking update to Sentry
+
+    Spec: https://github.com/getsentry/sentry/blob/master/src/sentry/flags/docs/api.md#create-generic-flag-log-post
+
+    NOTE:
+    - This works when creating the flag because there is a hook to create (save) a feature state.
+    - This works when updating the flag because there is a signal to trigger this on model save.
+    - This works when deleting the flag because deleting means saving the model instance with a deleted_at timestamp.
+    """
+    feature_name = feature_state.feature.name
+    logger.debug("Sending '%s' update to Sentry...", feature_name)
+
+    # Sentry-specific fields
+    sentry_payload: dict[str, Any] = {
+        "created_at": (  # i.e. Sentry event's created_at
+            feature_state.deleted_at
+            or feature_state.live_from
+            or feature_state.updated_at
+        ).isoformat(timespec="seconds"),
+        "flag": feature_state.feature.name,
+    }
+    sentry_payload["created_by"] = {
+        "id": _guess_change_author_email(feature_state),
+        "type": "email",
+    }
+    sentry_payload["action"] = action = _guess_action(feature_state)
+    if action == "updated":
+        sentry_payload["change_id"] = str(feature_state.pk)
+
+    payload = {
+        "data": [sentry_payload],
+        "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, configuration.secret),
+    }
+
+    response = requests.post(
+        url=configuration.webhook_url,
+        headers=headers,
+        data=json_payload,
+    )
+
+    try:
+        response.raise_for_status()
+    except requests.exceptions.RequestException as error:
+        logger.error("Failed to send Sentry update: %s", repr(error))
+        # TODO: Should we retry, or ultimately notify the admin of a persisting issue?
+
+    logger.info("Sent '%s' (%s) to Sentry", feature_name, action)
+
+
+def _guess_action(feature_state: FeatureState) -> str:
+    """
+    Detect which kind of event occurred for a feature state
+    """
+    if feature_state.deleted_at:
+        return "deleted"
+
+    # NOTE: 0~1 items depending on whether this runs synchronously
+    is_new_feature = feature_state.history.order_by()[:2].count() <= 1
+    if is_new_feature:
+        return "created"
+
+    return "updated"
+
+
+def _guess_change_author_email(feature_state: FeatureState) -> str:
+    """
+    Best-effort to find the author of a feature state change
+
+    NOTE: Audit logs are created asynchronously to this function, meaning that
+    we cannot expect the most recent audit log to be what we're looking for.
+
+    TODO: Revisit this if the actor is a relevant piece of information.
+    """
+    return "[email protected]"  # :(

api/integrations/sentry/signals.py

@@ -0,0 +1,11 @@
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+
+from features.models import FeatureState
+
+from .tasks import send_sentry_change_tracking_webhook_update
+
+
+@receiver(post_save, sender=FeatureState)
+def trigger_feature_state_change_sentry_change_tracking(instance, **kwargs):  # type: ignore[no-untyped-def]
+    send_sentry_change_tracking_webhook_update.delay(args=(instance.pk,))

api/integrations/sentry/tasks.py

@@ -0,0 +1,25 @@
+import logging
+
+from task_processor.decorators import register_task_handler
+
+from environments.models import Environment
+
+from .change_tracking import post_change_tracking_update_to_sentry
+
+logger = logging.getLogger(__name__)
+
+
+@register_task_handler()
+def send_sentry_change_tracking_webhook_update(feature_state_id: int) -> None:
+    from features.models import FeatureState
+
+    feature_state = FeatureState.objects.get(pk=feature_state_id)
+
+    try:
+        sentry_configuration = (
+            feature_state.environment.sentry_change_tracking_configuration
+        )
+    except Environment.sentry_change_tracking_configuration.RelatedObjectDoesNotExist:
+        return
+
+    post_change_tracking_update_to_sentry(feature_state, sentry_configuration)

api/tests/integration/sentry/test_change_tracking_webhook_integration.py

@@ -0,0 +1,163 @@
+import json
+import re
+from datetime import UTC, datetime, timedelta
+from typing import Callable
+from unittest.mock import Mock
+
+import freezegun
+import pytest
+from pytest_mock import MockerFixture
+
+from features.models import Feature, FeatureState
+from integrations.sentry import change_tracking
+from integrations.sentry.models import SentryChangeTrackingConfiguration
+
+
+@pytest.fixture
+def sentry_configuration(environment: int) -> SentryChangeTrackingConfiguration:
+    configuration = SentryChangeTrackingConfiguration(
+        environment_id=environment,
+        webhook_url="https://sentry.example.com/webhook",
+        secret="hush hush!",
+    )
+    configuration.save()
+    return configuration
+
+
+@pytest.fixture
+def requests(mocker: MockerFixture) -> Mock:
+    return mocker.patch.object(change_tracking, "requests")
+
+
+def test_sentry_change_tracking__flag_created__sends_update_to_sentry(
+    mocker: MockerFixture,
+    project: int,
+    requests: Mock,
+    sentry_configuration: SentryChangeTrackingConfiguration,
+) -> None:
+    # Given
+    feature_obj = Feature(
+        name="yet_another_feature",
+        project_id=project,
+    )
+
+    # When
+    with freezegun.freeze_time("2199-01-01T00:00:00.500000+00:00"):
+        feature_obj.save()
+
+    # Then
+    requests.post.assert_called_once_with(
+        url=sentry_configuration.webhook_url,
+        headers={
+            "Content-Type": "application/json",
+            "X-Sentry-Signature": mocker.ANY,
+        },
+        data=json.dumps(
+            {
+                "data": [
+                    {
+                        "action": "created",
+                        "created_at": "2199-01-01T00:00:00+00:00",
+                        "created_by": {"id": "[email protected]", "type": "email"},
+                        "flag": feature_obj.name,
+                    },
+                ],
+                "meta": {"version": 1},
+            },
+            sort_keys=True,
+        ),
+    )
+    signature = requests.post.call_args[1]["headers"]["X-Sentry-Signature"]
+    assert re.match(r"^[0-9a-f]{64}$", signature)
+
+
+def test_sentry_change_tracking__flag_state_change__sends_update_to_sentry(
+    feature_name: str,
+    feature_state: int,
+    mocker: MockerFixture,
+    requests: Mock,
+    sentry_configuration: SentryChangeTrackingConfiguration,
+) -> None:
+    # Given
+    feature_state_obj = FeatureState.objects.get(pk=feature_state)
+
+    # When
+    with freezegun.freeze_time("2199-01-01T00:00:00.500000+00:00"):
+        now = datetime.now(UTC)
+        feature_state_obj.enabled = False
+        feature_state_obj.live_from = now + timedelta(hours=1)
+        feature_state_obj.save()
+
+    # Then
+    requests.post.assert_called_once_with(
+        url=sentry_configuration.webhook_url,
+        headers={
+            "Content-Type": "application/json",
+            "X-Sentry-Signature": mocker.ANY,
+        },
+        data=json.dumps(
+            {
+                "data": [
+                    {
+                        "action": "updated",
+                        "created_at": "2199-01-01T01:00:00+00:00",
+                        "created_by": {"id": "[email protected]", "type": "email"},
+                        "change_id": str(feature_state),
+                        "flag": feature_name,
+                    },
+                ],
+                "meta": {"version": 1},
+            },
+            sort_keys=True,
+        ),
+    )
+    signature = requests.post.call_args[1]["headers"]["X-Sentry-Signature"]
+    assert re.match(r"^[0-9a-f]{64}$", signature)
+
+
+@pytest.mark.parametrize(
+    "kaboom",
+    [
+        lambda feature_state: feature_state.delete(),
+        lambda feature_state: feature_state.feature.delete(),
+    ],
+)
+def test_sentry_change_tracking__flag_deleted__sends_update_to_sentry(
+    feature_name: str,
+    feature_state: int,
+    kaboom: Callable[[FeatureState], None],
+    mocker: MockerFixture,
+    requests: Mock,
+    sentry_configuration: SentryChangeTrackingConfiguration,
+) -> None:
+    # Given
+    feature_state_obj = FeatureState.objects.get(pk=feature_state)
+
+    # When
+    with freezegun.freeze_time("2199-01-01T01:00:00+00:00"):
+        kaboom(feature_state_obj)
+
+    # Then
+    requests.post.assert_called_once_with(
+        url=sentry_configuration.webhook_url,
+        headers={
+            "Content-Type": "application/json",
+            "X-Sentry-Signature": mocker.ANY,
+        },
+        data=json.dumps(
+            {
+                "data": [
+                    {
+                        "action": "deleted",
+                        "created_at": "2199-01-01T01:00:00+00:00",
+                        "created_by": {"id": "[email protected]", "type": "email"},
+                        "flag": feature_name,
+                    },
+                ],
+                "meta": {"version": 1},
+            },
+            sort_keys=True,
+        ),
+    )
+    signature = requests.post.call_args[1]["headers"]["X-Sentry-Signature"]
+    assert re.match(r"^[0-9a-f]{64}$", signature)