qontract-reconcile 0.10.0__py3-none-any.whl → 0.10.1.dev1203__py3-none-any.whl

reconcile/utils/glitchtip/client.py

@@ -1,104 +1,21 @@
-import threading
-from typing import (
-    Any,
-    Optional,
-)
-from urllib.parse import urljoin
-
-import requests
-
 from reconcile.utils.glitchtip.models import (
     Organization,
     Project,
+    ProjectAlert,
     ProjectKey,
     Team,
     User,
 )
+from reconcile.utils.rest_api_base import ApiBase
 
 
-def get_next_url(links: dict[str, dict[str, str]]) -> Optional[str]:
-    """Parse glitchtip's response header 'Link' attribute and return the next page url if exists.
-
-    See
-    * https://gitlab.com/glitchtip/glitchtip-backend/-/blob/master/glitchtip/pagination.py#L34
-    * https://requests.readthedocs.io/en/latest/api/?highlight=links#requests.Response.links
-    """
-    if links.get("next", {}).get("results", "false") == "true":
-        return links["next"]["url"]
-    return None
-
-
-class GlitchtipClient:
-    def __init__(
-        self, host: str, token: str, max_retries: int = 3, read_timeout: float = 30
-    ) -> None:
-        self.host = host
-        self.token = token
-        self.max_retries = max_retries
-        self.read_timeout = read_timeout
-        self._thread_local = threading.local()
-
-    @property
-    def _session(self) -> requests.Session:
-        try:
-            return self._thread_local.session
-        except AttributeError:
-            # todo timeout
-            self._thread_local.session = requests.Session()
-            self._thread_local.session.mount(
-                "https://", requests.adapters.HTTPAdapter(max_retries=self.max_retries)
-            )
-            self._thread_local.session.mount(
-                "http://", requests.adapters.HTTPAdapter(max_retries=self.max_retries)
-            )
-            self._thread_local.session.headers.update(
-                {
-                    "Authorization": f"Bearer {self.token}",
-                    "Content-Type": "application/json",
-                }
-            )
-            return self._thread_local.session
-
-    def _get(self, url: str) -> dict[str, Any]:
-        response = self._session.get(urljoin(self.host, url), timeout=self.read_timeout)
-        return response.json()
-
-    def _list(self, url: str, limit: int = 100) -> list[dict[str, Any]]:
-        response = self._session.get(
-            urljoin(self.host, url), params={"limit": limit}, timeout=self.read_timeout
-        )
-        response.raise_for_status()
-        results = response.json()
-        # handle pagination
-        while next_url := get_next_url(response.links):
-            response = self._session.get(next_url)
-            results += response.json()
-        return results
-
-    def _post(self, url: str, data: Optional[dict[Any, Any]] = None) -> dict[str, Any]:
-        response = self._session.post(
-            urljoin(self.host, url), json=data, timeout=self.read_timeout
-        )
-        response.raise_for_status()
-        if response.status_code == 204:
-            return {}
-        return response.json()
-
-    def _put(self, url: str, data: Optional[dict[Any, Any]] = None) -> dict[str, Any]:
-        response = self._session.put(
-            urljoin(self.host, url), json=data, timeout=self.read_timeout
-        )
-        response.raise_for_status()
-        if response.status_code == 204:
-            return {}
-        return response.json()
-
-    def _delete(self, url: str) -> None:
-        self._session.delete(urljoin(self.host, url), timeout=self.read_timeout)
-
+class GlitchtipClient(ApiBase):
     def organizations(self) -> list[Organization]:
         """List organizations."""
-        return [Organization(**r) for r in self._list("/api/0/organizations/")]
+        return [
+            Organization(**r)
+            for r in self._list("/api/0/organizations/", params={"limit": 100})
+        ]
 
     def create_organization(self, name: str) -> Organization:
         """Create an organization."""
@@ -112,7 +29,10 @@ class GlitchtipClient:
         """List teams."""
         return [
             Team(**r)
-            for r in self._list(f"/api/0/organizations/{organization_slug}/teams/")
+            for r in self._list(
+                f"/api/0/organizations/{organization_slug}/teams/",
+                params={"limit": 100},
+            )
         ]
 
     def create_team(self, organization_slug: str, slug: str) -> Team:
@@ -131,11 +51,14 @@ class GlitchtipClient:
         """List projects."""
         return [
             Project(**r)
-            for r in self._list(f"/api/0/organizations/{organization_slug}/projects/")
+            for r in self._list(
+                f"/api/0/organizations/{organization_slug}/projects/",
+                params={"limit": 100},
+            )
         ]
 
     def create_project(
-        self, organization_slug: str, team_slug: str, name: str, platform: Optional[str]
+        self, organization_slug: str, team_slug: str, name: str, platform: str | None
     ) -> Project:
         """Create a project."""
         return Project(
@@ -145,15 +68,38 @@ class GlitchtipClient:
             )
         )
 
-    def delete_project(self, organization_slug: str, team_slug: str, slug: str) -> None:
+    def update_project(
+        self,
+        organization_slug: str,
+        slug: str,
+        name: str,
+        platform: str | None,
+        event_throttle_rate: int,
+    ) -> Project:
+        """Update a project."""
+        return Project(
+            **self._put(
+                f"/api/0/projects/{organization_slug}/{slug}/",
+                data={
+                    "name": name,
+                    "platform": platform,
+                    "eventThrottleRate": event_throttle_rate,
+                },
+            )
+        )
+
+    def delete_project(self, organization_slug: str, slug: str) -> None:
         """Delete a project."""
         self._delete(
-            f"/api/0/teams/{organization_slug}/{team_slug}/projects/{slug}/",
+            f"/api/0/projects/{organization_slug}/{slug}/",
         )
 
     def project_key(self, organization_slug: str, project_slug: str) -> ProjectKey:
         """Retrieve project key (DSN)."""
-        keys = self._list(f"/api/0/projects/{organization_slug}/{project_slug}/keys/")
+        keys = self._list(
+            f"/api/0/projects/{organization_slug}/{project_slug}/keys/",
+            params={"limit": 100},
+        )
         if not keys:
             # only happens if org_slug/project_slug does not exist
             raise ValueError(f"No keys found for project {project_slug}")
@@ -162,6 +108,48 @@ class GlitchtipClient:
             dsn=keys[0]["dsn"]["public"], security_endpoint=keys[0]["dsn"]["security"]
         )
 
+    def project_alerts(
+        self, organization_slug: str, project_slug: str
+    ) -> list[ProjectAlert]:
+        """Retrieve project alerts."""
+        return [
+            ProjectAlert(**r)
+            for r in self._list(
+                f"/api/0/projects/{organization_slug}/{project_slug}/alerts/",
+                params={"limit": 100},
+            )
+        ]
+
+    def create_project_alert(
+        self, organization_slug: str, project_slug: str, alert: ProjectAlert
+    ) -> ProjectAlert:
+        """Add an alert to a project."""
+        return ProjectAlert(
+            **self._post(
+                f"/api/0/projects/{organization_slug}/{project_slug}/alerts/",
+                data=alert.dict(by_alias=True, exclude_unset=True, exclude_none=True),
+            )
+        )
+
+    def delete_project_alert(
+        self, organization_slug: str, project_slug: str, alert_pk: int
+    ) -> None:
+        """Delete an alert from a project."""
+        self._delete(
+            f"/api/0/projects/{organization_slug}/{project_slug}/alerts/{alert_pk}/",
+        )
+
+    def update_project_alert(
+        self, organization_slug: str, project_slug: str, alert: ProjectAlert
+    ) -> ProjectAlert:
+        """Update an alert."""
+        return ProjectAlert(
+            **self._put(
+                f"/api/0/projects/{organization_slug}/{project_slug}/alerts/{alert.pk}/",
+                data=alert.dict(by_alias=True, exclude_unset=True, exclude_none=True),
+            )
+        )
+
     def add_project_to_team(
         self, organization_slug: str, team_slug: str, slug: str
     ) -> Project:
@@ -182,7 +170,10 @@ class GlitchtipClient:
         """List organization users (aka members)."""
         return [
             User(**r)
-            for r in self._list(f"/api/0/organizations/{organization_slug}/members/")
+            for r in self._list(
+                f"/api/0/organizations/{organization_slug}/members/",
+                params={"limit": 100},
+            )
         ]
 
     def invite_user(self, organization_slug: str, email: str, role: str) -> User:
@@ -190,7 +181,12 @@ class GlitchtipClient:
         return User(
             **self._post(
                 f"/api/0/organizations/{organization_slug}/members/",
-                data={"email": email, "role": role, "teams": []},
+                data={
+                    "email": email,
+                    "send_invite": False,
+                    "orgRole": role,
+                    "teamRoles": [],
+                },
             )
         )
 
@@ -203,7 +199,7 @@ class GlitchtipClient:
         return User(
             **self._put(
                 f"/api/0/organizations/{organization_slug}/members/{pk}/",
-                data={"role": role},
+                data={"orgRole": role},
             )
         )
 
@@ -212,7 +208,8 @@ class GlitchtipClient:
         return [
             User(**r)
             for r in self._list(
-                f"/api/0/teams/{organization_slug}/{team_slug}/members/"
+                f"/api/0/teams/{organization_slug}/{team_slug}/members/",
+                params={"limit": 100},
             )
         ]
 

reconcile/utils/glitchtip/models.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 
 import re
 from collections.abc import MutableMapping
-from typing import (
-    Any,
-    Optional,
-)
+from enum import Enum
+from typing import Any
 
 from pydantic import (
     BaseModel,
     Field,
     root_validator,
+    validator,
 )
 
 
@@ -24,7 +23,7 @@ def slugify(value: str) -> str:
 
 
 class User(BaseModel):
-    pk: Optional[int] = Field(None, alias="id")
+    pk: int | None = Field(None, alias="id")
     email: str
     role: str
     pending: bool = False
@@ -42,7 +41,7 @@ class User(BaseModel):
 
 
 class Team(BaseModel):
-    pk: Optional[int] = Field(None, alias="id")
+    pk: int | None = Field(None, alias="id")
     name: str = ""
     slug: str = ""
     users: list[User] = []
@@ -81,12 +80,81 @@ class ProjectKey(BaseModel):
     security_endpoint: str
 
 
+class RecipientType(Enum):
+    EMAIL = "email"
+    WEBHOOK = "webhook"
+
+
+class ProjectAlertRecipient(BaseModel):
+    pk: int | None = Field(None, alias="id")
+    recipient_type: RecipientType = Field(..., alias="recipientType")
+    url: str = ""
+
+    class Config:
+        allow_population_by_field_name = True
+        use_enum_values = True
+
+    @validator("recipient_type")
+    def recipient_type_enforce_enum_type(  # pylint: disable=no-self-argument
+        cls, v: str | RecipientType
+    ) -> RecipientType:
+        if isinstance(v, RecipientType):
+            return v
+        return RecipientType[v.upper()]
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ProjectAlertRecipient):
+            raise NotImplementedError(
+                "Cannot compare to non ProjectAlertRecipient objects."
+            )
+
+        return self.recipient_type == other.recipient_type and self.url == other.url
+
+    def __hash__(self) -> int:
+        return hash((self.recipient_type, self.url))
+
+
+class ProjectAlert(BaseModel):
+    pk: int | None = Field(None, alias="id")
+    name: str
+    timespan_minutes: int = Field(..., alias="timespanMinutes")
+    quantity: int
+    recipients: list[ProjectAlertRecipient] = Field([], alias="alertRecipients")
+
+    class Config:
+        allow_population_by_field_name = True
+
+    @root_validator
+    def empty_name(  # pylint: disable=no-self-argument
+        cls, values: MutableMapping[str, Any]
+    ) -> MutableMapping[str, Any]:
+        # name is an empty string if the alert was created manually because it can't be set via UI
+        # use the pk instead.
+        values["name"] = values.get("name") or f'alert-{values.get("pk")}'
+        return values
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ProjectAlert):
+            raise NotImplementedError("Cannot compare to non ProjectAlert objects.")
+
+        return (
+            self.timespan_minutes == other.timespan_minutes
+            and self.quantity == other.quantity
+            and set(self.recipients) == set(other.recipients)
+        )
+
+
 class Project(BaseModel):
-    pk: Optional[int] = Field(None, alias="id")
+    pk: int | None = Field(None, alias="id")
     name: str
     slug: str = ""
-    platform: Optional[str]
+    platform: str | None
     teams: list[Team] = []
+    alerts: list[ProjectAlert] = []
+    event_throttle_rate: int = Field(0, alias="eventThrottleRate")
+
+    class Config:
+        allow_population_by_field_name = True
 
     @root_validator
     def slugify(  # pylint: disable=no-self-argument
@@ -101,14 +169,24 @@ class Project(BaseModel):
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Project):
             raise NotImplementedError("Cannot compare to non Project objects.")
-        return self.name == other.name
+        # use the slug attribute to compare projects
+        # it can't be changed by the Glitchtip users, so it's more reliable
+        # and can be used to detect changes in the project name
+        return self.slug == other.slug
+
+    def diff(self, other: Project) -> bool:
+        return (
+            self.name != other.name
+            or self.platform != other.platform
+            or self.event_throttle_rate != other.event_throttle_rate
+        )
 
     def __hash__(self) -> int:
-        return hash(self.name)
+        return hash(self.slug)
 
 
 class Organization(BaseModel):
-    pk: Optional[int] = Field(None, alias="id")
+    pk: int | None = Field(None, alias="id")
     name: str
     slug: str = ""
     projects: list[Project] = []