GSoC: Distributed error reporting

kolibri/__init__.py

@@ -28,6 +28,7 @@
     "kolibri.plugins.demo_server",
     "kolibri.plugins.device",
     "kolibri.plugins.epub_viewer",
+    "kolibri.plugins.error_reports",
     "kolibri.plugins.html5_viewer",
     "kolibri.plugins.facility",
     "kolibri.plugins.learn",

kolibri/core/analytics/utils.py

@@ -32,6 +32,7 @@
 from kolibri.core.device.utils import allow_guest_access
 from kolibri.core.device.utils import get_device_setting
 from kolibri.core.discovery.utils.network.client import NetworkClient
+from kolibri.core.error_reports.tasks import ping_error_reports
 from kolibri.core.exams.models import Exam
 from kolibri.core.lessons.models import Lesson
 from kolibri.core.logger.models import AttemptLog
@@ -471,3 +472,5 @@ def ping_once(started, server=DEFAULT_SERVER_URL):
     if "id" in data:
         stat_data = perform_statistics(server, data["id"])
         create_and_update_notifications(stat_data, nutrition_endpoints.STATISTICS)
+        ping_error_reports.enqueue(args=(server, data["id"]))
+        return data["id"]

kolibri/core/error_reports/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class KolibriErrorConfig(AppConfig):
+    name = "kolibri.core.error_reports"
+    label = "error_reports"
+    verbose_name = "Kolibri Error Reports"

kolibri/core/error_reports/constants.py

@@ -0,0 +1,9 @@
+FRONTEND = "frontend"
+BACKEND = "backend"
+TASK = "task"
+
+POSSIBLE_ERRORS = [
+    (FRONTEND, "Frontend"),
+    (BACKEND, "Backend"),
+    (TASK, "Task"),
+]

kolibri/core/error_reports/middleware.py

@@ -0,0 +1,113 @@
+import json
+import logging
+import time
+import traceback
+from sys import version_info
+
+
+if version_info < (3, 10):
+    from importlib_metadata import distributions
+else:
+    from importlib.metadata import distributions
+
+from django.core.exceptions import MiddlewareNotUsed
+from django.core.exceptions import ValidationError
+from django.db import IntegrityError
+
+from .constants import BACKEND
+from .models import ErrorReport
+
+from kolibri.plugins.error_reports.kolibri_plugin import ErrorReportsPlugin
+from kolibri.core.error_reports.utils.scrubber import scrub_data
+from kolibri.plugins.registry import registered_plugins
+
+
+def get_request_info(request):
+    context = {
+        "url": request.build_absolute_uri(),
+        "method": request.method,
+        "headers": dict(request.headers),
+        "query_params": dict(request.GET),
+        "body": None,
+    }
+
+    if request.headers.get("Content-Type", "").lower() == "application/json":
+        try:
+            # a json req body can have sensitive data, other types can have
+            context["body"] = json.loads(request.body.decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError):
+            pass
+
+    scrub_data(context)
+    return context
+
+
+def get_server_info(request):
+    return {"host": request.get_host(), "port": request.get_port()}
+
+
+def get_packages():
+    packages = [f"{dist.metadata['Name']}=={dist.version}" for dist in distributions()]
+    return packages
+
+
+def get_python_version():
+    return ".".join(str(v) for v in version_info[:3])
+
+
+def get_request_time_to_error(request):
+    return time.time() - request.start_time
+
+
+class ErrorReportingMiddleware:
+    """
+    Middleware to log exceptions to the database.
+    """
+
+    def __init__(self, get_response):
+        if ErrorReportsPlugin not in registered_plugins:
+            raise MiddlewareNotUsed("ErrorReportsPlugin is not enabled.")
+        self.get_response = get_response
+        self.logger = logging.getLogger(__name__)
+
+    def __call__(self, request):
+        response = self.get_response(request)
+        return response
+
+    def process_exception(self, request, exception):
+        error_message = str(exception)
+        traceback_info = traceback.format_exc()
+        context = {
+            "request_info": get_request_info(request),
+            "server": get_server_info(request),
+            "packages": get_packages(),
+            "python_version": get_python_version(),
+            "avg_request_time_to_error": get_request_time_to_error(request),
+        }
+        self.logger.error("Unexpected Error: %s", error_message)
+        try:
+            self.logger.error("Saving error report to the database.")
+            ErrorReport.insert_or_update_error(
+                BACKEND,
+                error_message,
+                traceback_info,
+                context,
+            )
+        except (IntegrityError, ValidationError) as e:
+            self.logger.error(
+                "Error occurred while saving error report to the database: %s", str(e)
+            )
+
+
+class PreRequestMiddleware:
+    def __init__(self, get_response):
+        if ErrorReportsPlugin not in registered_plugins:
+            raise MiddlewareNotUsed("ErrorReportsPlugin is not enabled.")
+        self.get_response = get_response
+
+    def __call__(self, request):
+        response = self.get_response(request)
+        return response
+
+    def process_view(self, request, view_func, view_args, view_kwargs):
+        request.start_time = time.time()

kolibri/core/error_reports/migrations/0001_initial.py

@@ -0,0 +1,54 @@
+# Generated by Django 3.2.25 on 2024-09-26 01:14
+import django.utils.timezone
+from django.db import migrations
+from django.db import models
+
+import kolibri.core.fields
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="ErrorReport",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "category",
+                    models.CharField(
+                        choices=[
+                            ("frontend", "Frontend"),
+                            ("backend", "Backend"),
+                            ("task", "Task"),
+                        ],
+                        max_length=10,
+                    ),
+                ),
+                ("error_message", models.CharField(max_length=255)),
+                ("traceback", models.TextField()),
+                (
+                    "first_occurred",
+                    models.DateTimeField(default=django.utils.timezone.now),
+                ),
+                (
+                    "last_occurred",
+                    models.DateTimeField(default=django.utils.timezone.now),
+                ),
+                ("reported", models.BooleanField(default=False)),
+                ("events", models.IntegerField(default=1)),
+                ("context", kolibri.core.fields.JSONField(blank=True, null=True)),
+            ],
+        ),
+    ]

kolibri/core/error_reports/models.py

@@ -0,0 +1,112 @@
+import logging
+
+from django.conf import settings
+from django.db import models
+from django.utils import timezone
+
+from .constants import POSSIBLE_ERRORS
+from .schemas import SCHEMA_MAP
+from kolibri.core.fields import JSONField
+from kolibri.core.utils.validators import JSON_Schema_Validator
+from kolibri.deployment.default.sqlite_db_names import ERROR_REPORTS
+
+
+logger = logging.getLogger(__name__)
+
+
+class ErrorReportsRouter(object):
+    """
+    Determine how to route database calls for the ErrorReports app.
+    """
+
+    def db_for_read(self, model, **hints):
+        if model._meta.app_label == "error_reports":
+            return ERROR_REPORTS
+        return None
+
+    def db_for_write(self, model, **hints):
+        if model._meta.app_label == "error_reports":
+            return ERROR_REPORTS
+        return None
+
+    def allow_relation(self, obj1, obj2, **hints):
+        if (
+            obj1._meta.app_label == "error_reports"
+            and obj2._meta.app_label == "error_reports"
+        ):
+            return True
+        elif "error_reports" not in [obj1._meta.app_label, obj2._meta.app_label]:
+            return None
+
+        return False
+
+    def allow_migrate(self, db, app_label, model_name=None, **hints):
+        if app_label == "error_reports":
+            return db == ERROR_REPORTS
+        elif db == ERROR_REPORTS:
+            return False
+
+        return None
+
+
+class ErrorReport(models.Model):
+    category = models.CharField(max_length=10, choices=POSSIBLE_ERRORS)
+    error_message = models.CharField(max_length=255)
+    traceback = models.TextField()
+    first_occurred = models.DateTimeField(default=timezone.now)
+    last_occurred = models.DateTimeField(default=timezone.now)
+    reported = models.BooleanField(default=False)
+    events = models.IntegerField(default=1)
+    context = JSONField(
+        null=True,
+        blank=True,
+    )
+
+    def __str__(self):
+        return f"{self.error_message} ({self.category})"
+
+    def clean(self):
+        schema = SCHEMA_MAP.get(self.category, None)
+        if schema is None:
+            raise ValueError("Category not found in SCHEMA_MAP")
+        JSON_Schema_Validator(schema)(self.context)
+
+    def save(self, *args, **kwargs):
+        self.full_clean()
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def insert_or_update_error(cls, category, error_message, traceback, context):
+        if getattr(settings, "DEVELOPER_MODE", False) or getattr(
+            settings, "TESTING", False
+        ):
+            logger.info("ErrorReport: Database not updated, as DEVELOPER_MODE is True.")
+            return
+        error_report, created = cls.objects.get_or_create(
+            category=category,
+            error_message=error_message,
+            traceback=traceback,
+            defaults={"context": context},
+        )
+        if not created:
+            error_report.events += 1
+            error_report.last_occurred = timezone.now()
+            if error_report.context.get("avg_request_time_to_error", None):
+                context["avg_request_time_to_error"] = (
+                    error_report.context["avg_request_time_to_error"]
+                    * (error_report.events - 1)
+                    + context["avg_request_time_to_error"]
+                ) / error_report.events
+                error_report.context = context
+
+        error_report.save()
+        logger.info("ErrorReport: Database updated.")
+        return error_report
+
+    @classmethod
+    def get_unreported_errors(cls):
+        return cls.objects.filter(reported=False)
+
+    @classmethod
+    def delete_error(cls):
+        pass