WIP [ci skip]

Author: Hyask

src/errors/cassie.py

@@ -415,9 +415,9 @@ def get_metadata_for_bucket(bucketid: str, release: str = None):
     try:
         if not release:
             # Get all columns up to "~" (non-inclusive)
-            rows = BucketMetadata.objects.filter(key=bucketid, column1__lt="~").all()
+            rows = BucketMetadata.objects.filter(key=bucketid.encode(), column1__lt="~").all()
         else:
-            rows = BucketMetadata.objects.filter(key=bucketid).all()
+            rows = BucketMetadata.objects.filter(key=bucketid.encode()).all()
 
         ret = {}
         for row in rows:
@@ -426,6 +426,9 @@ def get_metadata_for_bucket(bucketid: str, release: str = None):
         if release and ret:
             try:
                 ret["FirstSeen"] = ret["~%s:FirstSeen" % release]
+            except KeyError:
+                pass
+            try:
                 ret["LastSeen"] = ret["~%s:LastSeen" % release]
             except KeyError:
                 pass
@@ -444,37 +447,7 @@ def chunks(l, n):
 def get_metadata_for_buckets(bucketids, release=None):
     ret = dict()
     for bucketid in bucketids:
-        bucket_key = bucketid.encode() if isinstance(bucketid, str) else bucketid
-        try:
-            if not release:
-                rows = BucketMetadata.objects.filter(key=bucket_key, column1__lt="~").all()
-            else:
-                rows = BucketMetadata.objects.filter(key=bucket_key).all()
-
-            bucket_data = {}
-            for row in rows:
-                bucket_data[row.column1] = row.value
-
-            if bucket_data:
-                ret[bucketid] = bucket_data
-        except DoesNotExist:
-            pass
-
-    if release:
-        for bucket_id in ret:
-            bucket = ret[bucket_id]
-            try:
-                bucket["FirstSeen"] = bucket["~%s:FirstSeen" % release]
-                bucket["LastSeen"] = bucket["~%s:LastSeen" % release]
-            except KeyError:
-                # Rather than confuse developers with half release-specific
-                # data. Of course this will only apply for the current row, so
-                # it's possible subsequent rows will show release-specific
-                # data.
-                if "FirstSeen" in bucket:
-                    del bucket["FirstSeen"]
-                if "LastSeen" in bucket:
-                    del bucket["LastSeen"]
+        ret[bucketid] = get_metadata_for_bucket(bucketid, release)
     return ret
 
 
@@ -645,65 +618,75 @@ def get_package_crash_rate(
 
     # the generic counter only includes Crashes for packages from official
     # Ubuntu sources and from systems not under auto testing
-    old_vers_column = "%s:%s:%s" % (release, src_package, old_version)
-    new_vers_column = "%s:%s:%s" % (release, src_package, new_version)
+    old_vers_column = "oopses:Crash:%s:%s:%s" % (release, src_package, old_version)
+    new_vers_column = "oopses:Crash:%s:%s:%s" % (release, src_package, new_version)
     results = {}
 
     try:
-        # The first thing done is the reversing of the order that's why it
-        # is column_start (get items <= date in reverse order)
         old_rows = (
             Counters.objects.filter(key=old_vers_column.encode(), column1__lte=date)
+            .order_by("-column1")
             .limit(15)
             .all()
         )
-        old_rows_sorted = sorted(old_rows, key=lambda x: x.column1, reverse=True)
-        old_vers_data = {row.column1: row.value for row in old_rows_sorted}
+        old_vers_data = {row.column1: row.value for row in old_rows}
     except DoesNotExist:
         old_vers_data = None
 
     try:
         # this may be unnecessarily long since updates phase in ~3 days
-        new_rows = Counters.objects.filter(key=new_vers_column.encode()).limit(15).all()
-        new_rows_sorted = sorted(new_rows, key=lambda x: x.column1, reverse=True)
-        new_vers_data = {row.column1: row.value for row in new_rows_sorted}
+        new_rows = (
+            Counters.objects.filter(key=new_vers_column.encode())
+            .order_by("-column1")
+            .limit(15)
+            .all()
+        )
+        print(new_rows)
+        new_vers_data = {row.column1: row.value for row in new_rows}
+        print(new_vers_data)
     except DoesNotExist:
+        print("New data does not exist")
         results["increase"] = False
         return results
 
     if not new_vers_data:
+        print("No new data")
         results["increase"] = False
         return results
 
     if exclude_proposed:
         try:
             proposed_old_rows = (
                 CountersForProposed.objects.filter(key=old_vers_column.encode(), column1__lte=date)
+                .order_by("-column1")
                 .limit(15)
                 .all()
             )
-            proposed_old_rows_sorted = sorted(
-                proposed_old_rows, key=lambda x: x.column1, reverse=True
-            )
-            proposed_old_vers_data = {row.column1: row.value for row in proposed_old_rows_sorted}
+            proposed_old_vers_data = {row.column1: row.value for row in proposed_old_rows}
         except DoesNotExist:
             proposed_old_vers_data = None
         try:
             proposed_new_rows = (
-                CountersForProposed.objects.filter(key=new_vers_column.encode()).limit(15).all()
-            )
-            proposed_new_rows_sorted = sorted(
-                proposed_new_rows, key=lambda x: x.column1, reverse=True
+                CountersForProposed.objects.filter(key=new_vers_column.encode())
+                .order_by("-column1")
+                .limit(15)
+                .all()
             )
-            proposed_new_vers_data = {row.column1: row.value for row in proposed_new_rows_sorted}
+            proposed_new_vers_data = {row.column1: row.value for row in proposed_new_rows}
         except DoesNotExist:
             proposed_new_vers_data = None
 
+        print(f"{proposed_old_vers_data=}")
+        print(f"{proposed_new_vers_data=}")
+    print(f"{old_vers_data=}")
+    print(f"{new_vers_data=}")
     today = datetime.datetime.utcnow().strftime("%Y%m%d")
+    print(today)
     try:
         today_crashes = new_vers_data[today]
     except KeyError:
         # no crashes today so not an increase
+        print("No data for today")
         results["increase"] = False
         return results
 
@@ -716,6 +699,7 @@ def get_package_crash_rate(
         today_crashes = today_crashes - today_proposed_crashes
         if today_crashes == 0:
             # no crashes today so not an increase
+            print("No data for today outside -proposed")
             results["increase"] = False
             return results
 
@@ -733,8 +717,11 @@ def get_package_crash_rate(
         return results
 
     first_date = date
+    print(f"{first_date=}")
     oldest_date = list(old_vers_data.keys())[-1]
+    print(f"{oldest_date=}")
     dates = [x for x in _date_range_iterator(oldest_date, first_date)]
+    print(f"{dates=}")
     previous_vers_crashes = []
     previous_days = len(dates[:-1])
     for day in dates[:-1]:
@@ -756,12 +743,15 @@ def get_package_crash_rate(
     results["increase"] = False
     # 2 crashes may be a fluke
     if today_crashes < 3:
+        print("Less than 3 crashes today")
         return results
 
     now = datetime.datetime.utcnow()
     hour = float(now.hour)
     minute = float(now.minute)
     mean_crashes = numpy.average(previous_vers_crashes)
+    print(f"{mean_crashes=}")
+    print(f"{previous_vers_crashes=}")
     standard_crashes = (mean_crashes + numpy.std(previous_vers_crashes)).round()
     # if an update isn't fully phased then the previous package version will
     # generally have more crashes than the phasing one so multiple the quanity
@@ -786,6 +776,10 @@ def get_package_crash_rate(
         results["web_link"] = absolute_uri + web_link
         results["previous_period_in_days"] = previous_days
         results["previous_average"] = standard_crashes
+    print("Difference less than 1")
+    print(f"{difference=}")
+    print(f"{today_crashes=}")
+    print(f"{standard_crashes=}")
     return results
 
 

src/errortracker/cassandra_schema.py

@@ -114,8 +114,18 @@ class SystemOOPSHashes(ErrorTrackerTable):
 
 class BucketMetadata(ErrorTrackerTable):
     __table_name__ = "BucketMetadata"
+    # the bucket ID
+    #   - /bin/zsh:11:makezleparams:execzlefunc:redrawhook:zlecore:zleread
     key = columns.Blob(db_field="key", primary_key=True)
+    # Which metadata
+    #   - FirstSeen (package version)
+    #   - LastSeen (package version)
+    #   - FirstSeenRelease (Ubuntu series)
+    #   - ~Ubuntu 25.04:LastSeen (package version)
     column1 = columns.Text(db_field="column1", primary_key=True)
+    # The corresponding value for the metadata
+    #   - 5.9-6ubuntu2 (package version)
+    #   - Ubuntu 18.04 (Ubuntu series)
     value = columns.Text(db_field="value")
 
     @classmethod

src/errortracker/oopses.py

@@ -100,7 +100,11 @@ def _insert(
     :param ttl: boolean for setting the time to live for the column
     :return: The day which the oops was filed under.
     """
-    day_key = time.strftime("%Y%m%d", time.gmtime())
+    try:
+        # Try to get the actual day of that crash, otherwise fallback to today
+        day_key = time.strftime("%Y%m%d", time.strptime(insert_dict["Date"], "%c"))
+    except Exception:
+        day_key = time.strftime("%Y%m%d", time.gmtime())
     now_uuid = uuid.uuid1()
 
     if ttl:

src/tests/conftest.py

@@ -6,8 +6,10 @@
 
 """Test helpers for working with cassandra."""
 
+import locale
 import shutil
 import tempfile
+from datetime import datetime, timedelta
 from pathlib import Path
 from unittest.mock import patch
 
@@ -45,3 +47,63 @@ def retracer(temporary_db):
             architecture=architecture,
         )
     shutil.rmtree(temp)
+
+
+@pytest.fixture(scope="module")
+def datetime_now():
+    return datetime.now()
+
+
+@pytest.fixture(scope="function")
+def cassandra_data(datetime_now, temporary_db):
+    import bson
+    import logging
+
+    from daisy.submit import submit
+
+    # disable daisy logger temporarily
+    daisy_logger = logging.getLogger("daisy")
+    daisy_logger_level = daisy_logger.level
+    daisy_logger.setLevel(51)  # CRITICAL is 50, so let's go higher
+
+    # Make sure the datetime will get formatted "correctly" in that cursed time format: Mon May  5 14:46:10 2025
+    locale.setlocale(locale.LC_ALL, "C.UTF-8")
+
+    def count():
+        counter = 0
+        while True:
+            yield str(counter)
+            counter += 1
+
+    def new_oops(days_ago, data, systemid="imatestsystem"):
+        crash_date = datetime_now - timedelta(days=days_ago)
+        oops_date = crash_date.strftime("%c")
+        data.update({"Date": oops_date})
+        bson_data = bson.encode(data)
+        request = type(
+            "Request",
+            (object,),
+            dict(data=bson_data, headers={"X-Whoopsie-Version": "0.2.81ubuntu~fakefortesting"}),
+        )
+        submit(request, systemid)
+
+    # Get a wide screen, because here we'll want to have compact data, meaning long lines 🙃
+    # fmt: off
+
+    # increase-rate package version 1
+    for i in [30, 20, 10, 5, 2]:
+        new_oops(i, {"DistroRelease": "Ubuntu 24.04", "Package": "increase-rate 1", "ProblemType": "Crash", "Architecture": "amd64", "ExecutablePath": "/usr/bin/increase-rate", "StacktraceAddressSignature": "/usr/bin/increase-rate:42:/usr/bin/increase-rate+28"})
+
+    # increase-rate package version 2
+    for i in [2, 2, 1, 1, 1, 0, 0, 0, 0]:
+        new_oops(i,  {"DistroRelease": "Ubuntu 24.04", "Package": "increase-rate 2", "ProblemType": "Crash", "Architecture": "amd64", "ExecutablePath": "/usr/bin/increase-rate", "StacktraceAddressSignature": "/usr/bin/increase-rate:42:/usr/bin/increase-rate+fa0"})
+
+    # increase-rate package version 2 in proposed, even more crashes!
+    for i in [1, 0]:
+        new_oops(i,  {"DistroRelease": "Ubuntu 24.04", "Package": "increase-rate 2", "ProblemType": "Crash", "Architecture": "amd64", "ExecutablePath": "/usr/bin/increase-rate", "StacktraceAddressSignature": "/usr/bin/increase-rate:42:/usr/bin/increase-rate+fa0", "Tags": "package-from-proposed"})
+    # fmt: on
+
+    # re-enable daisy logger
+    daisy_logger.setLevel(daisy_logger_level)
+
+    yield

src/tests/test_cassie.py

@@ -0,0 +1,52 @@
+from datetime import timedelta
+
+import numpy
+from pytest import approx
+
+from errors import cassie
+
+
+class TestPrune:
+    def test_get_package_crash_rate_increase_rate(self, datetime_now, cassandra_data):
+        now = datetime_now
+
+        crash_rate = cassie.get_package_crash_rate(
+            "Ubuntu 24.04",
+            "increase-rate",
+            "1",
+            "2",
+            "70",
+            (now - timedelta(days=0)).strftime("%Y%m%d"),
+            "https://errors.internal/",
+        )
+        assert crash_rate == approx(
+            {
+                "increase": True,
+                "difference": numpy.float64(4.3),
+                "web_link": "https://errors.internal/?release=Ubuntu%2024.04&package=increase-rate&version=2",
+                "previous_period_in_days": 30,
+                "previous_average": numpy.float64(0.7),
+            },
+            rel=1e-1,  # We don't want much precision, Cassandra is already messing up the values
+        )
+
+        crash_rate = cassie.get_package_crash_rate(
+            "Ubuntu 24.04",
+            "increase-rate",
+            "1",
+            "2",
+            "70",
+            (now - timedelta(days=0)).strftime("%Y%m%d"),
+            "https://errors.internal/",
+            True,
+        )
+        assert crash_rate == approx(
+            {
+                "increase": True,
+                "difference": numpy.float64(3.4),
+                "web_link": "https://errors.internal/?release=Ubuntu%2024.04&package=increase-rate&version=2",
+                "previous_period_in_days": 30,
+                "previous_average": numpy.float64(0.7),
+            },
+            rel=1e-1,  # We don't want much precision, Cassandra is already messing up the values
+        )