monitor-queries command which uses the new jsonl query metric logfile

pyproject.toml

@@ -21,7 +21,7 @@ classifiers = [
  "Topic :: Database :: Front-Ends"
 ]
 
-dependencies = [ "psutil", "termcolor", "argcomplete", "pyyaml", "rdflib", "requests-sse", "tqdm>=4.60.0" ]
+dependencies = [ "psutil", "termcolor", "argcomplete", "pyyaml", "rdflib", "requests-sse", "tqdm>=4.60.0", "textual>=8.0", "rich" ]
 
 [project.optional-dependencies]
 dev = [ "ruff", "pre-commit" ]

src/qlever/commands/benchmark_queries.py

@@ -20,37 +20,12 @@
 from qlever.command import QleverCommand
 from qlever.commands.clear_cache import ClearCacheCommand
 from qlever.commands.ui import dict_to_yaml
-from qlever.containerize import Containerize
 from qlever.log import log, mute_log
-from qlever.util import run_command, run_curl_command
-
-
-def pretty_printed_query(
-    query: str, show_prefixes: bool, system: str = "docker"
-) -> str:
-    """
-    Pretty-print a SPARQL query using the sparql-formatter Docker image.
-    Optionally strips PREFIX declarations from the output.
-    Argument `system` can either be docker or podman.
-    """
-    if system not in Containerize.supported_systems():
-        system = "docker"
-    remove_prefixes_cmd = " | sed '/^PREFIX /Id'" if not show_prefixes else ""
-    pretty_print_query_cmd = (
-        f"echo {shlex.quote(query)}"
-        f" | {system} run -i --rm docker.io/sparqling/sparql-formatter"
-        f"{remove_prefixes_cmd} | grep -v '^$'"
-    )
-    try:
-        query_pretty_printed = run_command(
-            pretty_print_query_cmd, return_output=True
-        )
-        return query_pretty_printed.rstrip()
-    except Exception as e:
-        log.debug(
-            f"Failed to pretty-print query, returning original query: {e}"
-        )
-        return query.rstrip()
+from qlever.util import (
+    pretty_printed_query,
+    run_command,
+    run_curl_command,
+)
 
 
 def sparql_query_type(query: str) -> str:
@@ -1005,7 +980,8 @@ def execute(self, args) -> bool:
                     colored(
                         pretty_printed_query(
                             query, args.show_prefixes, args.system
-                        ),
+                        )
+                        or query,
                         "cyan",
                     )
                 )
@@ -1107,7 +1083,8 @@ def execute(self, args) -> bool:
                     description=description,
                     query=pretty_printed_query(
                         query, args.show_prefixes, args.system
-                    ),
+                    )
+                    or query,
                     client_time=time_seconds,
                     result=query_results,
                     result_size=result_length,
@@ -1166,7 +1143,8 @@ def execute(self, args) -> bool:
                         colored(
                             pretty_printed_query(
                                 query, args.show_prefixes, args.system
-                            ),
+                            )
+                            or query,
                             "cyan",
                         )
                     )

src/qlever/commands/monitor_queries.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from qlever.command import QleverCommand
+from qlever.log import log
+from qlever.monitor.app import MonitorQueriesApp
+
+# `LiveLogReader` ingests new log lines every 0.2s, so a faster screen
+# refresh would only re-render the ticking duration; 0.2s is the floor.
+REFRESH_MIN_S = 0.2
+REFRESH_MAX_S = 2.0
+
+
+class MonitorQueriesCommand(QleverCommand):
+    """
+    Class for executing the `monitor-queries-tui` command.
+    """
+
+    def __init__(self):
+        pass
+
+    def description(self) -> str:
+        return (
+            "Show the currently active and historically all the active queries "
+            "on the server (interactive TUI)"
+        )
+
+    def should_have_qleverfile(self) -> bool:
+        return False
+
+    def relevant_qleverfile_arguments(self) -> dict[str, list[str]]:
+        return {
+            "data": ["name"],
+            "server": ["host_name", "port", "timeout"],
+            "runtime": ["system"],
+        }
+
+    def additional_arguments(self, subparser) -> None:
+        subparser.add_argument(
+            "--sparql-endpoint",
+            type=str,
+            help="URL of the SPARQL endpoint (default = {host_name}:{port})",
+        )
+        subparser.add_argument(
+            "--metrics-log",
+            type=Path,
+            help=(
+                "QLever's `metrics-log.jsonl` log file "
+                "(default = {name}.metrics-log.jsonl)"
+            ),
+        )
+        subparser.add_argument(
+            "--slow-threshold",
+            type=int,
+            default=None,
+            help="Duration in seconds above which a query (active or"
+            " completed) is counted as slow in the metrics"
+            " (default = server timeout - 10s)",
+        )
+        subparser.add_argument(
+            "--refresh",
+            type=float,
+            default=REFRESH_MIN_S,
+            help="Live view screen refresh interval in seconds, between"
+            f" {REFRESH_MIN_S} and {REFRESH_MAX_S}"
+            f" (default = {REFRESH_MIN_S})",
+        )
+
+    def execute(self, args) -> bool:
+        if not args.metrics_log:
+            args.metrics_log = Path.cwd() / f"{args.name}.metrics-log.jsonl"
+        show_msg = (
+            f"Reading server logs from {args.metrics_log} to display the "
+            "currently active queries on the server"
+        )
+        self.show(show_msg, only_show=args.show)
+        if args.show:
+            return True
+
+        if not args.metrics_log.is_file():
+            log.error(f"Log file not found: {args.metrics_log}")
+            return False
+
+        timeout_s = 30
+        if args.slow_threshold is None:
+            try:
+                timeout_s = int(args.timeout.rstrip("s"))
+            except ValueError:
+                log.error(
+                    f"Could not parse server timeout {args.timeout!r};"
+                    " pass --slow-threshold explicitly"
+                )
+                return False
+            args.slow_threshold = max(1, timeout_s - 10)
+
+        if args.refresh < REFRESH_MIN_S or args.refresh > REFRESH_MAX_S:
+            log.error(
+                f"--refresh must be between {REFRESH_MIN_S} and"
+                f" {REFRESH_MAX_S} seconds"
+            )
+            return False
+
+        sparql_endpoint = (
+            args.sparql_endpoint
+            if args.sparql_endpoint
+            else f"{args.host_name}:{args.port}"
+        )
+
+        MonitorQueriesApp(
+            log_file=args.metrics_log,
+            sparql_endpoint=sparql_endpoint,
+            timeout=timeout_s,
+            slow_threshold=args.slow_threshold,
+            refresh_interval=args.refresh,
+            system=args.system,
+        ).run()
+        return True