feat(Hackathon): Platform Hub (#6692)

Co-authored-by: Talisson Costa <talisson.odcosta@gmail.com>

Author: khvn26

api/api/urls/v1.py

@@ -90,6 +90,11 @@
         ),
         name="schema-swagger-ui",
     ),
+    # Platform Hub dashboard
+    re_path(
+        r"^admin/dashboard/",
+        include("platform_hub.urls", namespace="platform-hub"),
+    ),
     # Test webhook url
     re_path(r"^webhooks/", include("webhooks.urls", namespace="webhooks")),
     path("", include("projects.code_references.urls", namespace="code_references")),

api/app/settings/common.py

@@ -130,6 +130,7 @@
     "webhooks",
     "metrics",
     "onboarding",
+    "platform_hub",
     # 2FA
     "custom_auth.mfa.trench",
     # health check plugins

api/app_analytics/influxdb_wrapper.py

@@ -459,6 +459,58 @@ def get_current_api_usage(
     return 0
 
 
+def get_platform_usage_trends(
+    date_start: datetime,
+    date_stop: datetime,
+    organisation_ids: list[int],
+) -> dict[str, dict[str, int]]:
+    """
+    Query InfluxDB for platform-wide usage trends grouped by day and resource.
+
+    Returns a dict of {date_str: {resource_name: count}}.
+    """
+    if not organisation_ids:
+        return {}
+
+    org_id_set = ", ".join(f'"{oid}"' for oid in organisation_ids)
+
+    bucket = get_range_bucket_mappings(date_start)
+    results = InfluxDBWrapper.influx_query_manager(
+        date_start=date_start,
+        date_stop=date_stop,
+        bucket=bucket,
+        filters=build_filter_string(
+            [
+                'r._measurement == "api_call"',
+                'r["_field"] == "request_count"',
+                f"contains(value: r.organisation_id, set: [{org_id_set}])",
+            ]
+        ),
+        drop_columns=(
+            "organisation",
+            "organisation_id",
+            "project",
+            "project_id",
+            "environment",
+            "environment_id",
+            "host",
+        ),
+        extra=(
+            '|> group(columns: ["resource"])'
+            ' |> aggregateWindow(every: 24h, fn: sum, timeSrc: "_start")'
+        ),
+    )
+
+    daily: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+    for table in results:
+        for record in table.records:
+            date_str = record.values["_time"].strftime("%Y-%m-%d")
+            resource_name = record.values.get("resource", "unknown")
+            daily[date_str][resource_name] += record.get_value() or 0
+
+    return daily
+
+
 def build_filter_string(filter_expressions: typing.List[str]) -> str:
     return "|> ".join(
         ["", *[f"filter(fn: (r) => {exp})" for exp in filter_expressions]]

api/conftest.py

@@ -1303,3 +1303,27 @@ def _is_feature_enabled(feature_name: str) -> bool:
 def clear_content_type_cache() -> typing.Generator[None, None, None]:
     yield
     ContentType.objects.clear_cache()
+
+
+@pytest.fixture
+def use_analytics_db(request: pytest.FixtureRequest, settings: SettingsWrapper) -> None:
+    """
+    Skip tests if no analytics database is configured,
+    and make sure the django_db fixture uses both default and analytics databases.
+    This is useful to avoid running tests that require a specific database setup.
+    """
+    if "analytics" not in settings.DATABASES:  # pragma: no cover
+        pytest.skip("No analytics database configured, skipping")
+        return
+    request.applymarker(pytest.mark.django_db(databases=["default", "analytics"]))
+    request.getfixturevalue("db")
+
+
+@pytest.fixture(autouse=True)
+def use_analytics_db_marked(request: pytest.FixtureRequest) -> None:
+    """
+    Automatically skip tests that are marked with 'use_analytics_db'.
+    This allows for selective skipping of tests based on the database configuration.
+    """
+    if request.node.get_closest_marker("use_analytics_db"):
+        request.getfixturevalue("use_analytics_db")

api/platform_hub/__init__.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class PlatformHubConfig(AppConfig):
+    name = "platform_hub"

api/platform_hub/apps.py

@@ -0,0 +1,98 @@
+from typing import Any
+
+# Each entry: (ModelClass, org_lookup_path, scope)
+# Using Any for model class to avoid mypy issues with Django model managers.
+IntegrationEntry = tuple[Any, str, str]
+
+
+def get_integration_registry() -> dict[str, IntegrationEntry]:
+    """Return the registry of integration models, lazily imported to avoid circular imports."""
+    from integrations.amplitude.models import AmplitudeConfiguration
+    from integrations.datadog.models import DataDogConfiguration
+    from integrations.dynatrace.models import DynatraceConfiguration
+    from integrations.github.models import GithubConfiguration
+    from integrations.grafana.models import (
+        GrafanaOrganisationConfiguration,
+        GrafanaProjectConfiguration,
+    )
+    from integrations.heap.models import HeapConfiguration
+    from integrations.mixpanel.models import MixpanelConfiguration
+    from integrations.new_relic.models import NewRelicConfiguration
+    from integrations.rudderstack.models import RudderstackConfiguration
+    from integrations.segment.models import SegmentConfiguration
+    from integrations.sentry.models import SentryChangeTrackingConfiguration
+    from integrations.slack.models import SlackConfiguration
+    from integrations.webhook.models import WebhookConfiguration
+
+    return {
+        "amplitude": (
+            AmplitudeConfiguration,
+            "environment__project__organisation_id",
+            "environment",
+        ),
+        "dynatrace": (
+            DynatraceConfiguration,
+            "environment__project__organisation_id",
+            "environment",
+        ),
+        "heap": (
+            HeapConfiguration,
+            "environment__project__organisation_id",
+            "environment",
+        ),
+        "mixpanel": (
+            MixpanelConfiguration,
+            "environment__project__organisation_id",
+            "environment",
+        ),
+        "rudderstack": (
+            RudderstackConfiguration,
+            "environment__project__organisation_id",
+            "environment",
+        ),
+        "segment": (
+            SegmentConfiguration,
+            "environment__project__organisation_id",
+            "environment",
+        ),
+        "sentry": (
+            SentryChangeTrackingConfiguration,
+            "environment__project__organisation_id",
+            "environment",
+        ),
+        "webhook": (
+            WebhookConfiguration,
+            "environment__project__organisation_id",
+            "environment",
+        ),
+        "datadog": (
+            DataDogConfiguration,
+            "project__organisation_id",
+            "project",
+        ),
+        "new-relic": (
+            NewRelicConfiguration,
+            "project__organisation_id",
+            "project",
+        ),
+        "slack": (
+            SlackConfiguration,
+            "project__organisation_id",
+            "project",
+        ),
+        "grafana-project": (
+            GrafanaProjectConfiguration,
+            "project__organisation_id",
+            "project",
+        ),
+        "github": (
+            GithubConfiguration,
+            "organisation_id",
+            "organisation",
+        ),
+        "grafana": (
+            GrafanaOrganisationConfiguration,
+            "organisation_id",
+            "organisation",
+        ),
+    }

api/platform_hub/constants.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Any
+
+from platform_hub.types import ReleasePipelineStageStatsData
+
+
+def map_release_pipeline_stage_to_stats_data(
+    stage: Any,
+) -> ReleasePipelineStageStatsData:
+    """Map a PipelineStage instance to a ReleasePipelineStageStatsData dict."""
+    features_in_stage: int = stage.get_in_stage_feature_versions_qs().count()
+    features_completed: int = stage.get_completed_feature_versions_qs().count()
+
+    return ReleasePipelineStageStatsData(
+        stage_name=stage.name,
+        environment_name=stage.environment.name,
+        order=stage.order,
+        features_in_stage=features_in_stage,
+        features_completed=features_completed,
+        action_description=_build_action_description(stage),
+        trigger_description=_build_trigger_description(stage),
+    )
+
+
+def _build_action_description(stage: Any) -> str:
+    """Build a human-readable description of the stage's actions."""
+    actions = stage.actions.all()
+    if not actions:
+        return ""
+    descriptions: list[str] = []
+    for action in actions:
+        descriptions.append(action.get_action_type_display())
+    return ", ".join(descriptions)
+
+
+def _build_trigger_description(stage: Any) -> str:
+    """Build a human-readable description of the stage's trigger."""
+    try:
+        trigger = stage.trigger
+    except stage.__class__.trigger.RelatedObjectDoesNotExist:
+        return ""
+
+    description: str = trigger.get_trigger_type_display()
+    if trigger.trigger_body and "wait_for" in trigger.trigger_body:
+        description += f" ({trigger.trigger_body['wait_for']})"
+    return description

api/platform_hub/mappers.py

@@ -0,0 +1,113 @@
+from rest_framework import serializers
+
+
+class DaysQuerySerializer(serializers.Serializer):  # type: ignore[type-arg]
+    days = serializers.ChoiceField(
+        choices=[30, 60, 90],
+        default=30,
+    )
+
+    def validate_days(self, value: str | int) -> int:
+        return int(value)
+
+
+class SummarySerializer(serializers.Serializer):  # type: ignore[type-arg]
+    total_organisations = serializers.IntegerField()
+    total_flags = serializers.IntegerField()
+    total_users = serializers.IntegerField()
+    total_api_calls_30d = serializers.IntegerField()
+    active_organisations = serializers.IntegerField()
+    total_projects = serializers.IntegerField()
+    total_environments = serializers.IntegerField()
+    total_integrations = serializers.IntegerField()
+    active_users = serializers.IntegerField()
+
+
+class EnvironmentMetricsSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    id = serializers.IntegerField()
+    name = serializers.CharField()
+    api_calls_30d = serializers.IntegerField()
+    flag_evaluations_30d = serializers.IntegerField()
+
+
+class ProjectMetricsSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    id = serializers.IntegerField()
+    name = serializers.CharField()
+    api_calls_30d = serializers.IntegerField()
+    flag_evaluations_30d = serializers.IntegerField()
+    flags = serializers.IntegerField()
+    environments = EnvironmentMetricsSerializer(many=True)
+
+
+class OrganisationMetricsSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    id = serializers.IntegerField()
+    name = serializers.CharField()
+    created_date = serializers.CharField()
+    total_flags = serializers.IntegerField()
+    active_flags = serializers.IntegerField()
+    stale_flags = serializers.IntegerField()
+    total_users = serializers.IntegerField()
+    active_users_30d = serializers.IntegerField()
+    admin_users = serializers.IntegerField()
+    api_calls_30d = serializers.IntegerField()
+    api_calls_60d = serializers.IntegerField()
+    api_calls_90d = serializers.IntegerField()
+    api_calls_allowed = serializers.IntegerField()
+    flag_evaluations_30d = serializers.IntegerField()
+    identity_requests_30d = serializers.IntegerField()
+    overage_30d = serializers.IntegerField()
+    overage_60d = serializers.IntegerField()
+    overage_90d = serializers.IntegerField()
+    project_count = serializers.IntegerField()
+    environment_count = serializers.IntegerField()
+    integration_count = serializers.IntegerField()
+    projects = ProjectMetricsSerializer(many=True)
+
+
+class UsageTrendSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    date = serializers.CharField()
+    api_calls = serializers.IntegerField()
+    flag_evaluations = serializers.IntegerField()
+    identity_requests = serializers.IntegerField()
+
+
+class StaleFlagsPerProjectSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    organisation_id = serializers.IntegerField()
+    organisation_name = serializers.CharField()
+    project_id = serializers.IntegerField()
+    project_name = serializers.CharField()
+    stale_flags = serializers.IntegerField()
+    total_flags = serializers.IntegerField()
+
+
+class IntegrationBreakdownSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    organisation_id = serializers.IntegerField()
+    organisation_name = serializers.CharField()
+    integration_type = serializers.CharField()
+    scope = serializers.CharField()
+    count = serializers.IntegerField()
+
+
+class ReleasePipelineStageStatsSerializer(
+    serializers.Serializer,  # type: ignore[type-arg]
+):
+    stage_name = serializers.CharField()
+    environment_name = serializers.CharField()
+    order = serializers.IntegerField()
+    features_in_stage = serializers.IntegerField()
+    features_completed = serializers.IntegerField()
+    action_description = serializers.CharField()
+    trigger_description = serializers.CharField()
+
+
+class ReleasePipelineOverviewSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    organisation_id = serializers.IntegerField()
+    organisation_name = serializers.CharField()
+    project_id = serializers.IntegerField()
+    project_name = serializers.CharField()
+    pipeline_id = serializers.IntegerField()
+    pipeline_name = serializers.CharField()
+    is_published = serializers.BooleanField()
+    total_features = serializers.IntegerField()
+    completed_features = serializers.IntegerField()
+    stages = ReleasePipelineStageStatsSerializer(many=True)