feat: sentry stats

Use sentry stats api to detect event.
For now those event are just created and do not modify the smaple rate

Author: Kl0ven

.pre-commit-config.yaml

@@ -22,12 +22,11 @@ repos:
       - id: pylama
         args: # arguments to configure black
           - --max-line-length=119
-        # to remove when this is fixed https://github.com/klen/pylama/issues/224
-        additional_dependencies:
-          - pyflakes==2.4.0
+          # due to https://github.com/PyCQA/pycodestyle/issues/373
+          - -i E203
 
   - repo: https://github.com/pycqa/isort
-    rev: 5.10.1
+    rev: 5.12.0
     hooks:
       - id: isort
         args: ["-m=VERTICAL_HANGING_INDENT", "--combine-as", "--profile=black"]
@@ -65,7 +64,8 @@ repos:
     rev: "1.7.4"
     hooks:
       - id: bandit
-        files: "^orange/.*"
+        files: "^controller/.*"
+        exclude: "tests/.*"
 
   - repo: https://github.com/remastr/pre-commit-django-check-migrations
     rev: v0.1.0

README.md

@@ -32,6 +32,9 @@ python manage.py migrate
 # add user
 python manage.py createsuperuser
 
+# load all permission group
+python manage.py loadpermissions
+
 # run server
 # admin @ http://localhost:8000/admin/
 python manage.py runserver

controller/sentry/admin.py

@@ -10,18 +10,81 @@
 from django.core.cache import cache
 from django.db import models
 from django.utils import timezone
+from django.utils.html import format_html
 from django_better_admin_arrayfield.admin.mixins import DynamicArrayMixin
 from django_json_widget.widgets import JSONEditorWidget
 from django_object_actions import DjangoObjectActions, takes_instance_or_queryset
 
-from controller.sentry.choices import MetricType
+from controller.sentry.choices import EventType, MetricType
 from controller.sentry.forms import BumpForm, MetricForm
-from controller.sentry.models import App
+from controller.sentry.inlines import AppEventInline, ProjectEventInline
+from controller.sentry.mixins import PrettyTypeMixin, ProjectLinkMixin
+from controller.sentry.models import App, Event, Project
 from controller.sentry.utils import invalidate_cache
 
 
+@admin.register(Project)
+class ProjectAdmin(
+    AdminConfirmMixin,
+    ActionFormMixin,
+    DjangoObjectActions,
+    DynamicArrayMixin,
+    admin.ModelAdmin,
+):
+
+    list_display = [
+        "sentry_id",
+        "sentry_project_slug",
+    ]
+
+    search_fields = ["sentry_id", "sentry_project_slug"]
+    ordering = search_fields
+
+    formfield_overrides = {
+        models.JSONField: {"widget": JSONEditorWidget},
+    }
+
+    fieldsets = [
+        [
+            None,
+            {"fields": ("sentry_id", "sentry_project_slug", "detection_param")},
+        ]
+    ]
+
+    inlines = [ProjectEventInline]
+
+
+@admin.register(Event)
+class EventAdmin(
+    ProjectLinkMixin,
+    AdminConfirmMixin,
+    ActionFormMixin,
+    DjangoObjectActions,
+    DynamicArrayMixin,
+    PrettyTypeMixin,
+    admin.ModelAdmin,
+):
+
+    list_display = ["reference", "pretty_type", "timestamp", "get_project"]
+
+    search_fields = ["reference", "type", "project__sentry_project_slug"]
+    ordering = search_fields
+
+    formfield_overrides = {
+        models.JSONField: {"widget": JSONEditorWidget},
+    }
+
+    fieldsets = [
+        [
+            None,
+            {"fields": ("reference", "type", "project", "timestamp")},
+        ]
+    ]
+
+
 @admin.register(App)
 class AppAdmin(
+    ProjectLinkMixin,
     AdminConfirmMixin,
     ActionFormMixin,
     DjangoObjectActions,
@@ -32,7 +95,8 @@ class AppAdmin(
 
     list_display = [
         "reference",
-        "sentry_project_slug",
+        "get_event_status",
+        "get_project",
         "last_seen",
         "default_sample_rate",
         "active_sample_rate",
@@ -41,9 +105,7 @@ class AppAdmin(
         "celery_collect_metrics",
     ]
 
-    search_fields = [
-        "reference",
-    ]
+    search_fields = ["reference", "project__sentry_project_slug", "env", "command"]
     ordering = search_fields
 
     formfield_overrides = {
@@ -65,7 +127,7 @@ class AppAdmin(
             "Sentry",
             {
                 "classes": ("collapse",),
-                "fields": ("sentry_project_slug",),
+                "fields": ("project", "env", "command"),
             },
         ],
         [
@@ -95,6 +157,17 @@ class AppAdmin(
     changelist_actions = ["panic", "unpanic"]
     change_actions = ["bump_sample_rate", "enable_disable_metrics"]
 
+    inlines = [AppEventInline]
+
+    @admin.display(description="Spamming Sentry")
+    def get_event_status(self, obj):
+        text = '<b style="color:{};">{}</b>'
+        if obj.project and (event := obj.project.events.last()):
+            if event.type == EventType.DISCARD:
+                return format_html(text, "green", "No")
+            return format_html(text, "red", "Yes")
+        return format_html(text, "gray", "Pending")
+
     def get_changelist_actions(self, request):
         allowed_actions = []
         for action in self.changelist_actions:

controller/sentry/choices.py

@@ -5,3 +5,8 @@
 class MetricType(TextChoices):
     WSGI = "WSGI", _("WSGI")
     CELERY = "CELERY", _("CELERY")
+
+
+class EventType(TextChoices):
+    FIRING = "FIRING", _("firing")
+    DISCARD = "DISCARD", _("discard")

controller/sentry/detector.py

@@ -0,0 +1,82 @@
+from collections import OrderedDict
+from copy import copy
+from statistics import mean, stdev
+
+from controller.sentry.models import Project
+
+
+class SpikesDetector:
+    def __init__(self, lag=48, threshold=5, influence=0) -> None:
+        """
+        Z-score based algorithm
+        """
+
+        # The lag parameter determines how much your data will be smoothed and how adaptive the
+        # algorithm is to changes in the long-term average of the data. The more stationary your
+        # data is, the more lags you should include (this should improve the robustness of the algorithm).
+        # If your data contains time-varying trends, you should consider how quickly you want the algorithm
+        # to adapt to these trends. I.e., if you put lag at 10, it takes 10 'periods' before the algorithm's
+        # threshold is adjusted to any systematic changes in the long-term average. So choose the lag parameter
+        # based on the trending behavior of your data and how adaptive you want the algorithm to be.
+        self.lag = lag
+        # The threshold parameter is the number of standard deviations from the moving mean above which the
+        # algorithm will classify a new datapoint as being a signal. For example, if a new datapoint is 4.0
+        # standard deviations above the moving mean and the threshold parameter is set as 3.5,
+        # the algorithm will identify the datapoint as a signal. This parameter should be set based
+        # on how many signals you expect.
+        # For example, if your data is normally distributed, a threshold (or: z-score) of 3.5
+        # corresponds to a signaling probability of 0.00047 (from this table),
+        # which implies that you expect a signal once every 2128 datapoints (1/0.00047).
+        # The threshold therefore directly influences how sensitive the algorithm is
+        # and thereby also determines how often the algorithm signals.
+        self.threshold = threshold
+        # The influence parameter determines the influence of signals on the algorithm's detection threshold.
+        # If put at 0, signals have no influence on the threshold, such that future signals are detected based
+        # on a threshold that is calculated with a mean and standard deviation that is not influenced by past signals.
+        # If put at 0.5, signals have half the influence of normal data points. Another way to think about this
+        # is that if you put the influence at 0, you implicitly assume stationarity
+        # (i.e. no matter how many signals there are, you always expect the time series to return to the
+        # same average over the long term).
+        # If this is not the case, you should put the influence parameter somewhere between 0 and 1,
+        # depending on the extent to which signals can systematically influence the time-varying trend of the data.
+        # E.g., if signals lead to a structural break of the long-term average of the time series,
+        # the influence parameter should be put high (close to 1)
+        # so the threshold can react to structural breaks quickly.
+        self.influence = influence
+
+    @classmethod
+    def from_project(cls, project: Project):
+        return cls(**project.detection_param)
+
+    def compute_sentry(self, stats):
+        series = next(
+            (group["series"]["sum(quantity)"] for group in stats["groups"] if group["by"]["outcome"] == "accepted"),
+            None,
+        )
+        if series is None:
+            raise ValueError("No series with accepted outcome")
+
+        signal, _, _ = self.compute(series)
+
+        annotated_result = OrderedDict((date, signal) for date, signal in zip(stats["intervals"], signal))
+        return annotated_result
+
+    def compute(self, data):
+        signals = [0] * self.lag
+        avg_filter = [0] * self.lag
+        std_filter = [0] * self.lag
+        filtered_data = copy(data)
+        avg_filter[self.lag - 1] = mean(data[: self.lag])
+        std_filter[self.lag - 1] = stdev(data[: self.lag])
+
+        for i, item in enumerate(data[self.lag :], start=self.lag):
+            if abs(item - avg_filter[i - 1]) > self.threshold * std_filter[i - 1]:
+                signals.append(1 if item > avg_filter[i - 1] else 0)
+                filtered_data[i] = self.influence * item + (1 - self.influence) * filtered_data[i - 1]
+            else:
+                signals.append(0)
+                filtered_data[i] = data[i]
+            avg_filter.append(mean(filtered_data[(i - self.lag) : i]))
+            std_filter.append(stdev(filtered_data[(i - self.lag) : i]))
+
+        return signals, avg_filter, std_filter

controller/sentry/inlines.py

@@ -0,0 +1,33 @@
+from django.contrib import admin
+from nonrelated_inlines.admin import NonrelatedTabularInline
+
+from controller.sentry.mixins import PrettyTypeMixin
+from controller.sentry.models import Event
+
+
+class EventInlineMixin(PrettyTypeMixin):
+    model = Event
+    fields = ("reference", "pretty_type", "timestamp", "project")
+    readonly_fields = fields
+    can_delete = False
+    extra = 0
+    show_change_link = True
+
+    ordering = ("-timestamp",)
+
+    def has_add_permission(self, request, obj=None) -> bool:  # pylint: disable=unused-argument
+        return False
+
+
+class ProjectEventInline(EventInlineMixin, admin.TabularInline):
+    pass
+
+
+class AppEventInline(EventInlineMixin, NonrelatedTabularInline):
+    def get_form_queryset(self, obj):
+        if obj.project is None:
+            return Event.objects.none()
+        return obj.project.events.all()
+
+    def save_new_instance(self, parent, instance):  # pylint: disable=unused-argument
+        raise NotImplementedError

controller/sentry/management/__init__.py

@@ -0,0 +1,26 @@
+from itertools import chain
+
+from django.conf import settings
+from django.contrib.auth.models import Group, Permission
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    help = "Set default permissions."  # noqa: A003
+
+    def handle(self, *args, **options):
+        owner, _ = Group.objects.get_or_create(name="Owner")
+        admin, _ = Group.objects.get_or_create(name="Admin")
+        developer, _ = Group.objects.get_or_create(name=settings.DEVELOPER_GROUP)
+        viewer, _ = Group.objects.get_or_create(name="Viewer")
+
+        owner.permissions.set(Permission.objects.all())
+        admin.permissions.set(Permission.objects.filter(content_type__app_label="sentry"))
+
+        view_permission = Permission.objects.filter(codename__contains="view_", content_type__app_label="sentry")
+
+        developer.permissions.set(
+            chain(view_permission.all(), Permission.objects.filter(codename__in=settings.DEVELOPER_ACTIONS))
+        )
+
+        viewer.permissions.set(view_permission.all())

controller/sentry/management/commands/__init__.py

@@ -3,8 +3,6 @@
 import django_better_admin_arrayfield.models.fields
 from django.db import migrations, models
 
-import controller.sentry.models
-
 
 class Migration(migrations.Migration):
 
@@ -19,7 +17,6 @@ class Migration(migrations.Migration):
             field=django_better_admin_arrayfield.models.fields.ArrayField(
                 base_field=models.CharField(blank=True, max_length=50),
                 blank=True,
-                default=controller.sentry.models.get_default_wsgi_ignore_path,
                 size=None,
             ),
         ),