feat(integration): Add health-tracking integration feature

api/app/settings/common.py

@@ -164,6 +164,7 @@
     "integrations.gitlab",
     "integrations.grafana",
     "integrations.vcs",
+    "integrations.common",
     # Rate limiting admin endpoints
     "axes",
     "telemetry",

api/audit/signals.py

@@ -141,11 +141,7 @@ def send_audit_log_event_to_datadog(sender, instance, **kwargs):  # type: ignore
     if not data_dog_config:
         return
 
-    data_dog = DataDogWrapper(
-        base_url=data_dog_config.base_url,  # type: ignore[arg-type]
-        api_key=data_dog_config.api_key,
-        use_custom_source=data_dog_config.use_custom_source,
-    )
+    data_dog = DataDogWrapper(data_dog_config)
     _track_event_async(instance, data_dog)  # type: ignore[no-untyped-call]
 
 
@@ -156,11 +152,7 @@ def send_audit_log_event_to_new_relic(sender, instance, **kwargs):  # type: igno
     if not new_relic_config:
         return
 
-    new_relic = NewRelicWrapper(
-        base_url=new_relic_config.base_url,  # type: ignore[arg-type]
-        api_key=new_relic_config.api_key,
-        app_id=new_relic_config.app_id,
-    )
+    new_relic = NewRelicWrapper(new_relic_config)
     _track_event_async(instance, new_relic)  # type: ignore[no-untyped-call]
 
 
@@ -171,11 +163,7 @@ def send_audit_log_event_to_dynatrace(sender, instance, **kwargs):  # type: igno
     if not dynatrace_config:
         return
 
-    dynatrace = DynatraceWrapper(
-        base_url=dynatrace_config.base_url,  # type: ignore[arg-type]
-        api_key=dynatrace_config.api_key,
-        entity_selector=dynatrace_config.entity_selector,
-    )
+    dynatrace = DynatraceWrapper(dynatrace_config)
     _track_event_async(instance, dynatrace)  # type: ignore[no-untyped-call]
 
 
@@ -186,10 +174,7 @@ def send_audit_log_event_to_grafana(sender, instance, **kwargs):  # type: ignore
     if not grafana_config:
         return
 
-    grafana = GrafanaWrapper(
-        base_url=grafana_config.base_url,  # type: ignore[arg-type]
-        api_key=grafana_config.api_key,
-    )
+    grafana = GrafanaWrapper(grafana_config)
     _track_event_async(instance, grafana)  # type: ignore[no-untyped-call]
 
 
@@ -238,10 +223,7 @@ def send_audit_log_event_to_sentry(sender: FeatureState, **kwargs: Any) -> None:
     ).first()
     if not config:
         return
-    sentry = SentryChangeTracking(
-        webhook_url=config.webhook_url,
-        secret=config.secret,
-    )
+    sentry = SentryChangeTracking(config)
     if event_data := sentry.generate_event_data(sender):
         sentry.track_event_async(event=event_data)
 

api/integrations/README.md

@@ -0,0 +1,29 @@
+# Integrations
+
+## Integration Health Records Cleanup
+
+Integration health records are stored to track the status of external integration calls. These records can grow over time. A management command is provided to clean up old records.
+
+### Running the cleanup command
+
+To delete integration health records older than 30 days (default):
+
+```bash
+python manage.py cleanup_integration_health_records
+```
+
+To specify a custom retention period:
+
+```bash
+python manage.py cleanup_integration_health_records --days=60
+```
+
+### Scheduling automatic cleanup
+
+To prevent the `IntegrationHealthRecord` table from growing unbounded, schedule the cleanup command to run periodically using cron or your preferred task scheduler.
+
+Example cron entry (runs daily at 3 AM):
+
+```cron
+0 3 * * * cd /path/to/flagsmith && python manage.py cleanup_integration_health_records
+```

api/integrations/amplitude/amplitude.py

@@ -7,6 +7,7 @@
 from environments.identities.models import Identity
 from environments.identities.traits.models import Trait
 from features.models import FeatureState
+from integrations.common.services import record_integration_health
 from integrations.common.wrapper import AbstractBaseIdentityIntegrationWrapper
 
 from .models import AmplitudeConfiguration
@@ -18,13 +19,18 @@
 
 class AmplitudeWrapper(AbstractBaseIdentityIntegrationWrapper[AmplitudeUserData]):
     def __init__(self, config: AmplitudeConfiguration):
+        self.config = config
         self.api_key = config.api_key
         self.url = f"{config.base_url}/identify"
 
     def _identify_user(self, user_data: AmplitudeUserData) -> None:
         payload = {"api_key": self.api_key, "identification": json.dumps([user_data])}
 
-        response = requests.post(self.url, data=payload)
+        response = requests.post(self.url, data=payload, timeout=10)
+        try:
+            record_integration_health(self.config, response.status_code)
+        except Exception:
+            logger.warning("Failed to record Amplitude integration health")
         logger.debug(
             "Sent event to Amplitude. Response code was: %s" % response.status_code
         )

api/integrations/amplitude/serializers.py

@@ -7,4 +7,4 @@
 class AmplitudeConfigurationSerializer(BaseEnvironmentIntegrationModelSerializer):
     class Meta:
         model = AmplitudeConfiguration
-        fields = ("id", "api_key", "base_url")
+        fields = ("id", "api_key", "base_url", "latest_health")

api/integrations/common/apps.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+from django.apps import AppConfig
+
+
+class IntegrationCommonConfig(AppConfig):
+    name = "integrations.common"

api/integrations/common/management/commands/cleanup_integration_health_records.py

@@ -0,0 +1,28 @@
+from datetime import timedelta
+
+from django.core.management import BaseCommand, CommandParser
+from django.utils import timezone
+
+from integrations.common.models import IntegrationHealthRecord
+
+
+class Command(BaseCommand):
+    help = "Delete integration health records older than the specified number of days."
+
+    def add_arguments(self, parser: CommandParser) -> None:
+        parser.add_argument(
+            "--days",
+            type=int,
+            default=30,
+            help="Delete records older than this many days (default: 30).",
+        )
+
+    def handle(self, *args, **options):  # type: ignore[no-untyped-def]
+        days = options["days"]
+        cutoff = timezone.now() - timedelta(days=days)
+        deleted, _ = IntegrationHealthRecord.objects.filter(
+            created_at__lt=cutoff
+        ).delete()
+        self.stdout.write(
+            f"Deleted {deleted} integration health record(s) older than {days} days."
+        )

api/integrations/common/migrations/0001_initial.py

@@ -0,0 +1,43 @@
+# Generated by Django 5.2.15 on 2026-07-04 10:38
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("contenttypes", "0002_remove_content_type_name"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="IntegrationHealthRecord",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "created_at",
+                    models.DateTimeField(auto_now_add=True, verbose_name="Created At"),
+                ),
+                ("object_id", models.PositiveIntegerField()),
+                ("status_code", models.PositiveIntegerField()),
+                (
+                    "content_type",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="contenttypes.contenttype",
+                    ),
+                ),
+            ],
+        ),
+    ]

api/integrations/common/migrations/0002_add_health_record_index.py

@@ -0,0 +1,21 @@
+# Generated by Django 5.2.15 on 2026-07-09 01:26
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("common", "0001_initial"),
+        ("contenttypes", "0002_remove_content_type_name"),
+    ]
+
+    operations = [
+        migrations.AddIndex(
+            model_name="integrationhealthrecord",
+            index=models.Index(
+                fields=["content_type", "object_id", "-created_at"],
+                name="common_inte_content_bd807d_idx",
+            ),
+        ),
+    ]

api/integrations/common/models.py

@@ -1,5 +1,7 @@
 import logging
 
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
 from django.db import models
 from django_lifecycle import (  # type: ignore[import-untyped]
     AFTER_SAVE,
@@ -40,3 +42,16 @@ def write_environment_to_dynamodb(self):  # type: ignore[no-untyped-def]
     @hook(AFTER_UPDATE)
     def clear_environment_cache(self):  # type: ignore[no-untyped-def]
         self.environment.clear_environment_cache()
+
+
+class IntegrationHealthRecord(models.Model):
+    created_at = models.DateTimeField("Created At", auto_now_add=True)
+    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
+    object_id = models.PositiveIntegerField()
+    content_object = GenericForeignKey("content_type", "object_id")
+    status_code = models.PositiveIntegerField()
+
+    class Meta:
+        indexes = [
+            models.Index(fields=["content_type", "object_id", "-created_at"]),
+        ]

api/integrations/common/serializers.py

@@ -1,8 +1,11 @@
 import typing
 
 from django.db.models import Model
+from rest_framework.fields import SerializerMethodField
 from rest_framework.serializers import ModelSerializer
 
+from .services import get_latest_integration_health
+
 
 class _BaseIntegrationModelSerializer(ModelSerializer):  # type: ignore[type-arg]
     one_to_one_field_name = None
@@ -31,6 +34,10 @@ def _get_existing_integration_model_obj(
 
 class BaseEnvironmentIntegrationModelSerializer(_BaseIntegrationModelSerializer):
     one_to_one_field_name = "environment"  # type: ignore[assignment]
+    latest_health = SerializerMethodField()
+
+    def get_latest_health(self, obj: Model) -> dict[str, typing.Any] | None:
+        return get_latest_integration_health(obj)
 
 
 class BaseProjectIntegrationModelSerializer(_BaseIntegrationModelSerializer):

api/integrations/common/services.py

@@ -0,0 +1,45 @@
+import logging
+from typing import Any
+
+from django.contrib.contenttypes.models import ContentType
+from django.db import models, transaction
+
+from integrations.common.models import IntegrationHealthRecord
+
+logger = logging.getLogger(__name__)
+
+
+def record_integration_health(
+    integration_config: models.Model,
+    status_code: int,
+) -> None:
+    try:
+        with transaction.atomic():
+            IntegrationHealthRecord.objects.create(
+                content_object=integration_config,
+                status_code=status_code,
+            )
+    except Exception:
+        logger.exception("Failed to record integration health.")
+
+
+def get_latest_integration_health(
+    integration_config: models.Model,
+) -> dict[str, Any] | None:
+    latest_record = (
+        IntegrationHealthRecord.objects.filter(
+            content_type=ContentType.objects.get_for_model(integration_config),
+            object_id=integration_config.pk,
+        )
+        .order_by("-created_at")
+        .first()
+    )
+
+    if not latest_record:
+        return None
+
+    return {
+        "status_code": latest_record.status_code,
+        "is_healthy": 200 <= latest_record.status_code < 300,
+        "created_at": latest_record.created_at,
+    }

api/integrations/datadog/datadog.py

@@ -4,7 +4,9 @@
 import requests
 
 from audit.models import AuditLog
+from integrations.common.services import record_integration_health
 from integrations.common.wrapper import AbstractBaseEventIntegrationWrapper
+from integrations.datadog.models import DataDogConfiguration
 
 logger = logging.getLogger(__name__)
 
@@ -15,18 +17,15 @@
 class DataDogWrapper(AbstractBaseEventIntegrationWrapper):
     def __init__(
         self,
-        base_url: str,
-        api_key: str,
+        config: DataDogConfiguration,
         session: requests.Session = None,  # type: ignore[assignment]
-        use_custom_source: bool = False,
     ) -> None:
-        self.base_url = base_url
-        if self.base_url[-1] != "/":
-            self.base_url += "/"
+        self.config = config
+        self.base_url = (config.base_url or "").rstrip("/") + "/"
         self.events_url = f"{self.base_url}{EVENTS_API_URI}"
-        self.use_custom_source = use_custom_source
+        self.use_custom_source = config.use_custom_source
 
-        self.api_key = api_key
+        self.api_key = config.api_key
         self.session = session or requests.Session()
 
     @staticmethod
@@ -48,6 +47,11 @@ def _track_event(self, event: dict) -> None:  # type: ignore[type-arg]
         response = self.session.post(
             f"{self.events_url}?api_key={self.api_key}", data=json.dumps(event)
         )
+
+        try:
+            record_integration_health(self.config, response.status_code)
+        except Exception:
+            logger.warning("Failed to record DataDog integration health")
         logger.debug(
             "Sent event to DataDog. Response code was %s" % response.status_code
         )