extended stats command (#275)

Author: ngc92

src/discord-cluster-manager/cogs/admin_cog.py

@@ -762,7 +762,8 @@ async def update_competition(
             logger.exception("Error updating problem set", exc_info=e)
 
     @with_error_handling
-    async def show_bot_stats(self, interaction: discord.Interaction):
+    @discord.app_commands.describe(last_day_only="Only show stats for the last day")
+    async def show_bot_stats(self, interaction: discord.Interaction, last_day_only: bool):
         is_admin = await self.admin_check(interaction)
         if not is_admin:
             await send_discord_message(
@@ -773,7 +774,7 @@ async def show_bot_stats(self, interaction: discord.Interaction):
             return
 
         with self.bot.leaderboard_db as db:
-            stats = db.generate_stats()
+            stats = db.generate_stats(last_day_only)
             msg = """```"""
             for k, v in stats.items():
                 msg += f"\n{k} = {v}"

src/discord-cluster-manager/leaderboard_db.py

@@ -530,104 +530,102 @@ def get_leaderboard_submissions(
             for submission in self.cursor.fetchall()
         ]
 
-    def generate_stats(self):
+    def generate_stats(self, last_day: bool):
         try:
-            return self._generate_stats()
+            return self._generate_stats(last_day)
         except Exception as e:
             logging.exception("error generating stats", exc_info=e)
             raise
 
-    def _generate_stats(self):
-        # code-level stats
-        self.cursor.execute(
-            """
-            SELECT COUNT(*) FROM leaderboard.code_files;
-            """
-        )
-        num_unique_codes = self.cursor.fetchone()[0]
-
-        # submission-level stats
-        self.cursor.execute(
-            """
-            SELECT
-                COUNT(*),
-                COUNT(*) FILTER (WHERE NOT done),
-                COUNT(DISTINCT user_id),
-                COUNT(*) FILTER (WHERE submission_time > %s)
-            FROM leaderboard.submission;
-            """,
-            (datetime.datetime.now() - datetime.timedelta(days=1),),
-        )
-        num_sub, num_sub_wait, num_users, num_last_day = self.cursor.fetchone()
-
-        # run-level stats
-        self.cursor.execute(
-            """
-            SELECT
-                COUNT(*),
-                COUNT(*) FILTER (WHERE passed),
-                COUNT(score),
-                COUNT(*) FILTER (WHERE secret)
-            FROM leaderboard.runs;
-            """
-        )
-        num_run, num_run_pass, num_scored, num_secret = self.cursor.fetchone()
-
+    def _generate_runner_stats(self, last_day: bool = False):
+        select_expr = "WHERE NOW() - s.submission_time <= interval '24 hours'" if last_day else ""
         # per-runner stats
         self.cursor.execute(
-            """
+            f"""
             SELECT
                 runner,
                 COUNT(*),
                 COUNT(*) FILTER (WHERE passed),
                 COUNT(score),
-                COUNT(*) FILTER (WHERE secret)
-            FROM leaderboard.runs
+                COUNT(*) FILTER (WHERE secret),
+                MAX(runs.start_time - s.submission_time),
+                AVG(runs.start_time - s.submission_time),
+                SUM(runs.end_time - runs.start_time)
+            FROM leaderboard.runs JOIN leaderboard.submission s ON submission_id = s.id
+            {select_expr}
             GROUP BY runner;
             """
         )
 
-        result = {
-            "num_unique_codes": num_unique_codes,
-            "num_submissions": num_sub,
-            "sub_waiting": num_sub_wait,
-            "num_users": num_users,
-            "sub_last_day": num_last_day,
-            "num_runs": num_run,
-            "runs_passed": num_run_pass,
-            "runs_scored": num_scored,
-            "runs_secret": num_secret,
-        }
-
+        result = {}
         for row in self.cursor.fetchall():
             result[f"num_run.{row[0]}"] = row[1]
             result[f"runs_passed.{row[0]}"] = row[2]
             result[f"runs_scored.{row[0]}"] = row[3]
             result[f"runs_secret.{row[0]}"] = row[4]
+            result[f"max_delay.{row[0]}"] = row[5]
+            result[f"avg_delay.{row[0]}"] = row[6]
+            result[f"total_runtime.{row[0]}"] = row[7]
+
+        return result
 
-        # calculate heavy hitters
+    def _generate_submission_stats(self, last_day: bool = False):
+        select_expr = "WHERE NOW() - submission_time <= interval '24 hours'" if last_day else ""
         self.cursor.execute(
-            """
-            WITH run_durations AS (
-                SELECT
-                    s.user_id AS user_id,
-                    r.end_time - r.start_time AS duration
-                FROM leaderboard.runs r
-                JOIN leaderboard.submission s ON r.submission_id = s.id
-                WHERE NOW() - s.submission_time <= interval '24 hours'
-            )
+            f"""
             SELECT
-                user_id,
-                SUM(duration) AS total
-            FROM run_durations
-            GROUP BY user_id
-            ORDER BY total DESC
-            LIMIT 10;
+                COUNT(*),
+                COUNT(*) FILTER (WHERE NOT done),
+                COUNT(DISTINCT user_id)
+            FROM leaderboard.submission
+            {select_expr}
+            ;
             """
         )
+        num_sub, num_sub_wait, num_users = self.cursor.fetchone()
+        return {
+            "num_submissions": num_sub,
+            "sub_waiting": num_sub_wait,
+            "num_users": num_users,
+        }
 
-        for row in self.cursor.fetchall():
-            result[f"total.{row[0]}"] = row[1]
+    def _generate_stats(self, last_day: bool = False):
+        result = self._generate_submission_stats(last_day)
+        result.update(self._generate_runner_stats(last_day))
+
+        # code-level stats
+        if not last_day:
+            self.cursor.execute(
+                """
+                SELECT COUNT(*) FROM leaderboard.code_files;
+                """
+            )
+            result["num_unique_codes"] = self.cursor.fetchone()[0]
+
+        else:
+            # calculate heavy hitters
+            self.cursor.execute(
+                """
+                WITH run_durations AS (
+                    SELECT
+                        s.user_id AS user_id,
+                        r.end_time - r.start_time AS duration
+                    FROM leaderboard.runs r
+                    JOIN leaderboard.submission s ON r.submission_id = s.id
+                    WHERE NOW() - s.submission_time <= interval '24 hours'
+                )
+                SELECT
+                    user_id,
+                    SUM(duration) AS total
+                FROM run_durations
+                GROUP BY user_id
+                ORDER BY total DESC
+                LIMIT 10;
+                """
+            )
+
+            for row in self.cursor.fetchall():
+                result[f"total.{row[0]}"] = row[1]
 
         return result
 

src/discord-cluster-manager/report.py

@@ -51,6 +51,7 @@ class Text:
     """
     Text represents markdown-formatted text to be added to the report.
     """
+
     text: str
 
 
@@ -64,6 +65,7 @@ class Log:
     message, it can be broken up automatically (and reasonably) into multiple
     smaller messages.
     """
+
     header: str
     content: str