Add support to multiple notification channels, including NewRelic

Author: joaodaher

flamingo/models/deployment.py

@@ -4,7 +4,6 @@
 
 from gcp_pilot.datastore import Document, EmbeddedDocument
 
-from services.notifiers import ChatNotifier
 
 if TYPE_CHECKING:
     from models.app import App  # pylint: disable=ungrouped-imports
@@ -65,11 +64,10 @@ def merge(cls, app_id: str, build_id: str) -> 'Deployment':
 
     async def notify(self) -> None:
         app = self.app
-        channel = app.environment.channel
-        if not channel:
-            return None
-
-        await ChatNotifier.notify(
-            app=app,
-            deployment=self,
-        )
+
+        for channel in app.environment.notification_channels:
+            engine = channel.build_engine()
+            await engine.notify(
+                app=app,
+                deployment=self,
+            )

flamingo/models/environment.py

@@ -17,7 +17,7 @@ class Environment(Document):
     name: str
     network: Network = None
     project: Project = field(default_factory=Project.default)
-    channel: NotificationChannel = None
+    notification_channels: List[NotificationChannel] = field(default_factory=list)
     vars: List[EnvVar] = field(default_factory=list)
 
     def __post_init__(self):

flamingo/models/notification_channel.py

@@ -1,10 +1,38 @@
-from dataclasses import dataclass, field
-from typing import List
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, Union, Any
 
 from gcp_pilot.datastore import EmbeddedDocument
+from sanic_rest.exceptions import ValidationError
+
+from services.notifiers import ChatNotifier, NewRelicNotifier
+
+
+class NotificationEngine(Enum):
+    GOOGLE_CHAT = 'google-chat'
+    NEW_RELIC = 'new-relic'
+
+    @classmethod
+    def get_engine_class(cls, name):
+        if name == cls.GOOGLE_CHAT.value:
+            return ChatNotifier
+        if name == cls.NEW_RELIC.value:
+            return NewRelicNotifier
+        raise NotImplementedError(f"Unsupported notification engine {name}")
 
 
 @dataclass
 class NotificationChannel(EmbeddedDocument):
-    webhook_url: str
-    show_commit_for: List[str] = field(default_factory=lambda: ['SUCCESS'])
+    engine: str
+    config: Dict[str, Any]
+
+    def __post_init__(self):
+        # light validation
+        try:
+            self.build_engine()
+        except TypeError as e:
+            raise ValidationError(str(e)) from e
+
+    def build_engine(self) -> Union[ChatNotifier, NewRelicNotifier]:
+        klass = NotificationEngine.get_engine_class(name=self.engine)
+        return klass(**self.config)

flamingo/services/new_relic.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Dict
+
+import requests
+
+
+NEW_RELIC_API_URL = 'https://api.newrelic.com/v2'
+
+
+@dataclass
+class NewRelicAPI:
+    api_key: str
+
+    def get_app(self, name: str):
+        resource = 'applications'
+        params = {'filter[name]': name}
+
+        try:
+            return self._list(resource=resource, params=params)[0]
+        except IndexError:
+            return None
+
+    def notify_deployment(
+            self,
+            app_name: str,
+            revision: str,
+            user: str = '',
+            changelog: str = '',
+            description: str = '',
+            timestamp: datetime = None,
+    ):
+        app_id = self.get_app(name=app_name)['id']
+        resource = f'applications/{app_id}/deployments'
+        deployment = dict(revision=revision)
+
+        if changelog:
+            deployment['changelog'] = changelog
+        if description:
+            deployment['description'] = description
+        if timestamp:
+            deployment['timestamp'] = timestamp.isoformat()
+        if user:
+            deployment['user'] = user
+
+        payload = {
+            "deployment": deployment
+        }
+
+        return self._post(
+            resource=resource,
+            payload=payload,
+        )
+
+    def _list(self, resource: str, params: Dict = None) -> Dict:
+        response = requests.get(
+            url=f'{NEW_RELIC_API_URL}/{resource}.json',
+            params=params or {},
+            headers={'X-Api-Key': self.api_key}
+        )
+        response.raise_for_status()
+        return response.json()[resource]
+
+    def _post(self, resource: str, payload: Dict = None) -> Dict:
+        response = requests.post(
+            url=f'{NEW_RELIC_API_URL}/{resource}.json',
+            json=payload,
+            headers={'X-Api-Key': self.api_key}
+        )
+        response.raise_for_status()
+        return response.json()

flamingo/services/notifiers.py

@@ -1,30 +1,29 @@
 
 
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Dict
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Dict, List
 
 from gcp_pilot.chats import ChatsHook, Card, Section
 
 import settings
+from services.new_relic import NewRelicAPI
 
 if TYPE_CHECKING:
     from models.app import App
     from models.deployment import Deployment
-    from models.notification_channel import NotificationChannel
 
 
 @dataclass
 class ChatNotifier:
-    @classmethod
-    async def notify(cls, deployment: 'Deployment', app: 'App') -> Dict:
-        channel = app.environment.channel
+    webhook_url: str
+    show_commit_for: List[str] = field(default_factory=lambda: ['SUCCESS'])
 
-        chat = ChatsHook(hook_url=channel.webhook_url)
-        card = cls._build_message_card(deployment=deployment, app=app, channel=channel)
+    async def notify(self, deployment: 'Deployment', app: 'App') -> Dict:
+        chat = ChatsHook(hook_url=self.webhook_url)
+        card = self._build_message_card(deployment=deployment, app=app)
         return chat.send_card(card=card, thread_key=f'flamingo_{deployment.build_id}')
 
-    @classmethod
-    def _build_message_card(cls, deployment: 'Deployment', app: 'App', channel: 'NotificationChannel') -> Card:
+    def _build_message_card(self, deployment: 'Deployment', app: 'App') -> Card:
         current_event = deployment.events[-1]
         try:
             previous_event = deployment.events[-2]
@@ -36,7 +35,7 @@ def _build_message_card(cls, deployment: 'Deployment', app: 'App', channel: 'Not
         card = Card()
         card.add_header(
             title=f'{app.name}',
-            subtitle=f'{cls._get_action(status=status)} <b>{app.environment_name.upper()}</b>'
+            subtitle=f'{self._get_action(status=status)} <b>{app.environment_name.upper()}</b>'
         )
 
         section = Section()
@@ -57,7 +56,7 @@ def _build_message_card(cls, deployment: 'Deployment', app: 'App', channel: 'Not
                 content=str(duration),
             )
 
-        if previous_event and status in channel.show_commit_for:
+        if previous_event and status in self.show_commit_for:
             commits = app.repository.get_commit_diff(
                 current_revision=current_event.source.revision,
                 previous_revision=previous_event.source.revision,
@@ -98,3 +97,16 @@ def _get_icon(cls, status: str) -> str:
         # https://cloud.google.com/cloud-build/docs/api/reference/rest/v1/projects.builds#status
         icon_name = f'deploy_{status.lower()}.png'
         return f'https://storage.googleapis.com/{settings.FLAMINGO_GCS_BUCKET}/media/{icon_name}'
+
+
+@dataclass
+class NewRelicNotifier:
+    api_key: str
+
+    async def notify(self, deployment: 'Deployment', app: 'App') -> Dict:
+        api = NewRelicAPI(api_key=self.api_key)
+        api.notify_deployment(
+            app_name=app.identifier,
+            revision=deployment.build_id,
+            # user=''  # TODO get user
+        )