alerting: make rules super duper configurable

Author: ewdurbin

cabotage/client/templates/user/organization_settings.html

@@ -240,10 +240,14 @@ def _hashed_url_for(endpoint, **values):
     from cabotage.server.user.github_oauth import init_github_oauth
     from cabotage.server.integrations.slack_oauth import init_slack_oauth
     from cabotage.server.integrations.discord_oauth import init_discord_oauth
+    from cabotage.server.integrations.notification_routing import (
+        init_notification_routing,
+    )
 
     init_github_oauth(app)
     init_slack_oauth(app)
     init_discord_oauth(app)
+    init_notification_routing(app)
     vault_db_creds.init_app(app)
     db.init_app(app)
     principal.init_app(app)

cabotage/server/__init__.py

@@ -0,0 +1,205 @@
+import logging
+
+from flask import Blueprint, abort, jsonify, request
+from flask_security import login_required
+from sqlalchemy import cast
+from sqlalchemy.dialects.postgresql import ARRAY, TEXT
+
+from cabotage.server import db
+from cabotage.server.acl import AdministerOrganizationPermission
+from cabotage.server.models.auth import Organization
+from cabotage.server.models.notifications import (
+    NOTIFICATION_CATEGORIES,
+    NotificationRoute,
+)
+
+log = logging.getLogger(__name__)
+
+notification_routing_bp = Blueprint(
+    "notification_routing", __name__, url_prefix="/integrations/notifications"
+)
+
+
+def _get_org_or_403(org_slug):
+    organization = Organization.query.filter_by(slug=org_slug).first_or_404()
+    if not AdministerOrganizationPermission(organization.id).can():
+        abort(403)
+    return organization
+
+
+@notification_routing_bp.route("/<org_slug>/categories")
+@login_required
+def list_categories(org_slug):
+    _get_org_or_403(org_slug)
+    return jsonify({"categories": NOTIFICATION_CATEGORIES})
+
+
+@notification_routing_bp.route("/<org_slug>/routes")
+@login_required
+def list_routes(org_slug):
+    """Get all routes, optionally filtered by category.
+
+    Query params: category (optional)
+    """
+    organization = _get_org_or_403(org_slug)
+
+    query = NotificationRoute.query.filter_by(organization_id=organization.id)
+
+    category = request.args.get("category")
+    if category:
+        if category not in NOTIFICATION_CATEGORIES:
+            return jsonify({"error": "Invalid category"}), 400
+        type_keys = [
+            f"{category}.{t}" for t in NOTIFICATION_CATEGORIES[category]["types"]
+        ]
+        query = query.filter(
+            NotificationRoute.notification_types.op("?|")(cast(type_keys, ARRAY(TEXT)))
+        )
+
+    routes = query.all()
+    return jsonify(
+        {
+            "routes": [_route_to_dict(r) for r in routes],
+        }
+    )
+
+
+@notification_routing_bp.route("/<org_slug>/routes", methods=["POST"])
+@login_required
+def save_route(org_slug):
+    """Create or update a single route.
+
+    JSON body: {
+        notification_types: ["pipeline.deploy", "pipeline.release"],
+        project_ids: ["uuid", ...],    // empty = any
+        environment_ids: ["uuid", ...],
+        application_ids: ["uuid", ...],
+        integration: "slack",
+        channel_id: "C001",
+        channel_name: "#deploys",
+        enabled: true
+    }
+    """
+    organization = _get_org_or_403(org_slug)
+    data = request.get_json()
+    if not data:
+        abort(400)
+
+    ntypes = data.get("notification_types") or []
+    if not ntypes:
+        return jsonify({"error": "notification_types is required"}), 400
+
+    # Validate all types
+    all_valid = set()
+    for cat_key, cat_info in NOTIFICATION_CATEGORIES.items():
+        for t in cat_info["types"]:
+            all_valid.add(f"{cat_key}.{t}")
+    for ntype in ntypes:
+        if ntype not in all_valid:
+            return jsonify({"error": f"Invalid notification type: {ntype}"}), 400
+
+    integration = data.get("integration")
+    if not integration or integration not in ("slack", "discord"):
+        return jsonify({"error": "integration must be 'slack' or 'discord'"}), 400
+
+    channel_id = data.get("channel_id")
+    if not channel_id:
+        return jsonify({"error": "channel_id is required"}), 400
+
+    project_ids = data.get("project_ids") or []
+    environment_ids = data.get("environment_ids") or []
+    application_ids = data.get("application_ids") or []
+
+    route_id = data.get("id")
+    if route_id:
+        route = NotificationRoute.query.filter_by(
+            id=route_id, organization_id=organization.id
+        ).first_or_404()
+        route.notification_types = ntypes
+        route.project_ids = project_ids
+        route.environment_ids = environment_ids
+        route.application_ids = application_ids
+        route.integration = integration
+        route.channel_id = channel_id
+        route.channel_name = data.get("channel_name")
+        route.enabled = data.get("enabled", True)
+    else:
+        route = NotificationRoute(
+            organization_id=organization.id,
+            notification_types=ntypes,
+            project_ids=project_ids,
+            environment_ids=environment_ids,
+            application_ids=application_ids,
+            integration=integration,
+            channel_id=channel_id,
+            channel_name=data.get("channel_name"),
+            enabled=data.get("enabled", True),
+        )
+        db.session.add(route)
+
+    db.session.commit()
+    return jsonify(_route_to_dict(route)), 201
+
+
+@notification_routing_bp.route("/<org_slug>/routes/<route_id>", methods=["DELETE"])
+@login_required
+def delete_route(org_slug, route_id):
+    organization = _get_org_or_403(org_slug)
+    route = NotificationRoute.query.filter_by(
+        id=route_id, organization_id=organization.id
+    ).first_or_404()
+    db.session.delete(route)
+    db.session.commit()
+    return jsonify({"status": "ok"})
+
+
+@notification_routing_bp.route("/<org_slug>/scopes")
+@login_required
+def list_scopes(org_slug):
+    organization = _get_org_or_403(org_slug)
+
+    from cabotage.server.models.projects import Project
+
+    projects = (
+        Project.query.filter_by(organization_id=organization.id)
+        .filter(Project.deleted_at.is_(None))
+        .all()
+    )
+
+    result = []
+    for project in projects:
+        result.append(
+            {
+                "id": str(project.id),
+                "name": project.name,
+                "slug": project.slug,
+                "environments": [
+                    {"id": str(e.id), "name": e.name, "slug": e.slug}
+                    for e in project.active_environments
+                ],
+                "applications": [
+                    {"id": str(a.id), "name": a.name, "slug": a.slug}
+                    for a in project.active_applications
+                ],
+            }
+        )
+
+    return jsonify({"projects": result})
+
+
+def _route_to_dict(route):
+    return {
+        "id": str(route.id),
+        "notification_types": route.notification_types or [],
+        "project_ids": route.project_ids or [],
+        "environment_ids": route.environment_ids or [],
+        "application_ids": route.application_ids or [],
+        "integration": route.integration,
+        "channel_id": route.channel_id,
+        "channel_name": route.channel_name,
+        "enabled": route.enabled,
+    }
+
+
+def init_notification_routing(app):
+    app.register_blueprint(notification_routing_bp)

cabotage/server/integrations/notification_routing.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import datetime
+import uuid
+from typing import Any, TypedDict
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, String, text
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.orm import Mapped, mapped_column, relationship, backref
+
+from cabotage.server import Model
+
+
+class NotificationCategory(TypedDict):
+    label: str
+    types: dict[str, str]
+    scoped: bool
+
+
+NOTIFICATION_CATEGORIES: dict[str, NotificationCategory] = {
+    "organization": {
+        "label": "Organization",
+        "types": {
+            "usage": "Usage",
+        },
+        "scoped": False,
+    },
+    "usage": {
+        "label": "Usage",
+        "types": {
+            "cpu": "CPU",
+            "memory": "RAM",
+            "bandwidth": "Bandwidth",
+        },
+        "scoped": True,
+    },
+    "pipeline": {
+        "label": "Pipeline",
+        "types": {
+            "image_build": "Image Build",
+            "release": "Release",
+            "deploy": "Deploy",
+        },
+        "scoped": True,
+    },
+    "health": {
+        "label": "Service Health",
+        "types": {
+            "oom": "OOM Killed",
+            "crash_restart": "Crashes & Restarts",
+        },
+        "scoped": True,
+    },
+    "http": {
+        "label": "HTTP",
+        "types": {
+            "5xx": "5xx Errors",
+            "latency": "Latency",
+        },
+        "scoped": True,
+    },
+}
+
+
+class NotificationRoute(Model):
+    __tablename__ = "notification_routes"
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        postgresql.UUID(as_uuid=True),
+        server_default=text("gen_random_uuid()"),
+        primary_key=True,
+    )
+    organization_id: Mapped[uuid.UUID] = mapped_column(
+        postgresql.UUID(as_uuid=True),
+        ForeignKey("organizations.id"),
+        index=True,
+    )
+    notification_types: Mapped[Any] = mapped_column(
+        postgresql.JSONB(), server_default=text("'[]'::jsonb")
+    )
+    project_ids: Mapped[Any] = mapped_column(
+        postgresql.JSONB(), server_default=text("'[]'::jsonb")
+    )
+    environment_ids: Mapped[Any] = mapped_column(
+        postgresql.JSONB(), server_default=text("'[]'::jsonb")
+    )
+    application_ids: Mapped[Any] = mapped_column(
+        postgresql.JSONB(), server_default=text("'[]'::jsonb")
+    )
+    integration: Mapped[str] = mapped_column(String(32))
+    channel_id: Mapped[str] = mapped_column(String(64))
+    channel_name: Mapped[str | None] = mapped_column(String(255))
+    enabled: Mapped[bool] = mapped_column(Boolean, default=True)
+    created_at: Mapped[datetime.datetime] = mapped_column(
+        DateTime, default=datetime.datetime.now
+    )
+    updated_at: Mapped[datetime.datetime] = mapped_column(
+        DateTime,
+        default=datetime.datetime.now,
+        onupdate=datetime.datetime.now,
+    )
+
+    organization = relationship(
+        "Organization",
+        backref=backref("notification_routes", lazy="dynamic"),
+    )
+
+    def __repr__(self):
+        return f"<NotificationRoute {self.id} types={self.notification_types} integration={self.integration}>"

cabotage/server/models/notifications.py

@@ -826,6 +826,8 @@ def organization_settings(org_slug):
         ],
     )
 
+    from cabotage.server.models.notifications import NOTIFICATION_CATEGORIES
+
     return render_template(
         "user/organization_settings.html",
         organization=organization,
@@ -837,6 +839,7 @@ def organization_settings(org_slug):
         oidc_issuer_url=oidc.issuer_url(),
         slack_integration=organization.slack_integration,
         discord_integration=organization.discord_integration,
+        notification_categories=NOTIFICATION_CATEGORIES,
     )