kaqing 2.0.171__py3-none-any.whl → 2.0.203__py3-none-any.whl

adam/app_session.py

@@ -1,16 +1,14 @@
 import json
 import threading
 import time
-import traceback
 import requests
 from urllib.parse import urlparse
 
 from adam.log import Log
-from adam.repl_state import ReplState
 from adam.sso.idp import Idp
 from adam.sso.idp_login import IdpLogin
 from adam.config import Config
-from adam.utils import debug, json_to_csv, lines_to_tabular, log, log2
+from adam.utils import debug, debug_trace, json_to_csv, tabulize, log2, log_exc
 from adam.apps import Apps
 
 class AppLogin:
@@ -63,12 +61,9 @@ class AppSession:
                     if r.status_code >= 200 and r.status_code < 300 or r.status_code == 400:
                         try:
                             js = r.json()
-                            try:
+                            with log_exc(js):
                                 header, lines = json_to_csv(js, delimiter='\t')
-                                log(lines_to_tabular(lines, header=header, separator='\t'))
-                            except Exception as e:
-                                # traceback.print_exc(e)
-                                log(js)
+                                tabulize(lines, header=header, separator='\t')
                         except:
                             if urlparse(r.url).hostname != urlparse(uri).hostname and not retried:
                                 app_login = app_session.login(idp_uri=app_login.idp_uri, forced=forced, use_token_from_env=False, use_cached_creds=False)
@@ -147,7 +142,7 @@ class AppSession:
                 debug(f'{r.text}')
 
                 self.app_login = AppLogin(session, app_access_token, idp_uri)
-            except Exception:
+            except Exception as e:
                 try:
                     need = urlparse(r.url).hostname
                     if idp_login.idp_uri:
@@ -160,7 +155,7 @@ class AppSession:
                         log2(f"Invalid username/password.")
                     break
                 finally:
-                    debug(traceback.format_exc())
+                    debug_trace()
 
                     if 'res_text' in locals():
                         Log.log_to_file(res_text)

adam/apps.py

@@ -12,7 +12,8 @@ from adam.utils_k8s.services import Services
 from adam.utils import copy_config_file
 
 class AppAction:
-    def __init__(self, name: str, payload: str = None, args: dict[str, str] = None, help: str = None):
+    def __init__(self, typ: str, name: str, payload: str = None, args: dict[str, str] = None, help: str = None):
+        self.typ = typ
         self.name = name
         self.payload = payload
         self.args = args
@@ -33,6 +34,19 @@ class AppAction:
 
         return args
 
+    def __str__(self):
+        line = None
+
+        args = ','.join(self.arguments())
+        if args:
+            line = f'{self.typ}.{self.name},{args}'
+        else:
+            line = f'{self.typ}.{self.name},'
+        if self.help:
+            line = f'{line},{self.help}'
+
+        return line
+
 class AppType:
     all_types: list['AppType'] = []
 
@@ -62,12 +76,12 @@ class AppType:
                         aa: AppAction = None
 
                         if isinstance(v, str):
-                            aa = AppAction(k, help=v)
+                            aa = AppAction(typ, k, help=v)
                         elif isinstance(v, dict):
                             args = {k: v1 for k, v1 in v.items()}
-                            aa = AppAction(k, payload=v['payload'], args=args, help=v['help'])
+                            aa = AppAction(typ, k, payload=v['payload'], args=args, help=v['help'])
                         else:
-                            aa = AppAction(k)
+                            aa = AppAction(typ, k)
 
                         app_actions.append(aa)
 

adam/batch.py

@@ -3,7 +3,7 @@ import click
 from adam.commands.audit.audit import Audit, AuditCommandHelper
 from adam.commands.bash.bash import Bash
 from adam.commands.check import Check, CheckCommandHelper
-from adam.commands.cp import ClipboardCopy, CopyCommandHelper
+from adam.commands.clipboard_copy import ClipboardCopy, CopyCommandHelper
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterCommandHelper, ClusterOrPodCommandHelper, PodCommandHelper
 from adam.commands.cql.cqlsh import CqlCommandHelper, Cqlsh
@@ -11,7 +11,7 @@ from adam.commands.deploy.deploy import Deploy, DeployCommandHelper
 from adam.commands.deploy.undeploy import Undeploy, UndeployCommandHelper
 from adam.commands.issues import Issues
 from adam.commands.login import Login
-from adam.commands.logs import Logs
+from adam.commands.download_cassandra_log import DownloadCassandraLog
 from adam.commands.ls import Ls
 from adam.commands.medusa.medusa import Medusa
 from adam.commands.nodetool import NodeTool, NodeToolCommandHelper
@@ -19,8 +19,8 @@ from adam.commands.postgres.postgres import Postgres, PostgresCommandHelper
 from adam.commands.preview_table import PreviewTable
 from adam.commands.reaper.reaper import Reaper, ReaperCommandHelper
 from adam.commands.repair.repair import Repair, RepairCommandHelper
-from adam.commands.report import Report
-from adam.commands.restart import Restart
+from adam.commands.generate_report import GenerateReport
+from adam.commands.restart_nodes import RestartNodes
 from adam.commands.rollout import RollOut
 from adam.commands.show.show import Show, ShowCommandHelper
 from adam.commands.watch import Watch
@@ -128,7 +128,7 @@ def login(kubeconfig: str, config: str, param: list[str], namespace: str, pod: s
 @click.option('--pod', '-p', required=False, metavar='pod', help='Kubernetes pod name')
 @click.argument('extra_args', nargs=-1, metavar='<pod>', type=click.UNPROCESSED)
 def logs(kubeconfig: str, config: str, param: list[str], namespace: str, pod: str, extra_args):
-    run_command(Logs(), kubeconfig, config, param, None, namespace, pod, extra_args)
+    run_command(DownloadCassandraLog(), kubeconfig, config, param, None, namespace, pod, extra_args)
 
 
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterCommandHelper, help='List statefulset or pods.')
@@ -221,7 +221,7 @@ def repair(kubeconfig: str, config: str, param: list[str], cluster: str, namespa
 @click.option('--show', '-s', is_flag=True, help='show output from Cassandra nodes')
 @click.argument('extra_args', nargs=-1, metavar='[cluster|pod]', type=click.UNPROCESSED)
 def report(kubeconfig: str, config: str, param: list[str], cluster: str, namespace: str, pod: str, show: bool, extra_args):
-    run_command(Report(), kubeconfig, config, param, cluster, namespace, pod, ('-s',) + extra_args if show else extra_args)
+    run_command(GenerateReport(), kubeconfig, config, param, cluster, namespace, pod, ('-s',) + extra_args if show else extra_args)
 
 
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help='Restart Cassandra Cluster or Node')
@@ -234,7 +234,7 @@ def report(kubeconfig: str, config: str, param: list[str], cluster: str, namespa
 @click.option('--force', is_flag=True, help='need for restarting the whole cluster')
 @click.argument('extra_args', nargs=-1, metavar='<cluster|pod>', type=click.UNPROCESSED)
 def restart(kubeconfig: str, config: str, param: list[str], cluster: str, namespace: str, pod: str, force: bool, extra_args):
-    run_command(Restart(), kubeconfig, config, param, cluster, namespace, pod, ('--force',) + extra_args if force else extra_args)
+    run_command(RestartNodes(), kubeconfig, config, param, cluster, namespace, pod, ('--force',) + extra_args if force else extra_args)
 
 
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help='Rolling restart Cassandra Cluster.')

adam/checks/check_utils.py

@@ -47,7 +47,9 @@ def run_checks(cluster: str = None, namespace: str = None, pod: str = None, chec
                 if not pod or pod == pod_name:
                     sts_ns_pods.append((sts, ns, pod_name))
 
-    with parallelize(sts_ns_pods, Config().action_workers('issues', 30), msg='d`Running|Ran checks on {size} pods') as exec:
+    with parallelize(sts_ns_pods,
+                     Config().action_workers('issues', 30),
+                     msg='d`Running|Ran checks on {size} pods') as exec:
         return exec.map(lambda sts_ns_pod: run_checks_on_pod(checks, sts_ns_pod[0], sts_ns_pod[1], sts_ns_pod[2], show_out))
 
 def run_checks_on_pod(checks: list[Check], cluster: str = None, namespace: str = None, pod: str = None, show_out=True):

adam/checks/disk.py

@@ -6,6 +6,7 @@ from adam.checks.check_context import CheckContext
 from adam.checks.check_result import CheckResult
 from adam.checks.issue import Issue
 from adam.config import Config
+from adam.utils import log_exc
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
 
 class Disk(Check):
@@ -87,10 +88,8 @@ class Disk(Check):
 
         ss_size = 0.0
         if ss_out:
-            try:
+            with log_exc():
                 ss_size = round(float(ss_out.strip(' \r\n')) / 1024 / 1024, 2)
-            except:
-                pass
 
         def parse_du_out(l: str, default: str = None):
             groups = re.match(r'^(\S+)\s+(\S+)$', l.strip('\r'))

adam/columns/memory.py

@@ -3,6 +3,7 @@ from kubernetes.utils import parse_quantity
 from adam.checks.check_result import CheckResult
 from adam.checks.memory import Memory as MemoryCheck
 from adam.columns.column import Column
+from adam.utils import log_exc
 
 class Memory(Column):
     def name(self):
@@ -18,7 +19,5 @@ class Memory(Column):
         return f"{Memory.to_g(mem['used'])}/{Memory.to_g(mem['limit'])}"
 
     def to_g(v: str):
-        try:
-            return f'{round(parse_quantity(v) / 1024 / 1024 / 1024, 2)}G'
-        except:
-            return v
+        with log_exc():
+            return f'{round(parse_quantity(v) / 1024 / 1024 / 1024, 2)}G'

adam/commands/__init__.py

@@ -1,15 +1,24 @@
-from adam.commands.command import ExtractAllOptionsHandler, ExtractOptionsHandler, ExtractTrailingOptionsHandler
+from collections.abc import Callable
+from adam.commands.command import ExtractAllOptionsHandler, ExtractOptionsHandler, ExtractSequenceOptionsHandler, ExtractTrailingOptionsHandler, ValidateArgCountHandler
 from adam.repl_state import ReplState
-from adam.utils_app import AppHandler
+from adam.commands.app.utils_app import AppHandler
 
 def app(state: ReplState) -> AppHandler:
     return AppHandler(state)
 
-def extract_options(args: list[str], options = None):
+def extract_options(args: list[str], options: list[str]):
     return ExtractOptionsHandler(args, options = options)
 
-def extract_trailing_options(args: list[str], trailing = None):
+def extract_trailing_options(args: list[str], trailing: list[str]):
     return ExtractTrailingOptionsHandler(args, trailing = trailing)
 
-def extract_all_options(args: list[str], trailing = None, options = None):
-    return ExtractAllOptionsHandler(args, trailing = trailing, options = options)
+def extract_all_options(args: list[str], trailing = None, sequence = None, options = None):
+    return ExtractAllOptionsHandler(args, trailing = trailing, sequence = sequence, options = options)
+
+def extract_sequence(args: list[str], sequence: list[str]):
+    return ExtractSequenceOptionsHandler(args, sequence = sequence)
+
+def validate_args(args: list[str], state: ReplState, at_least: int = 1, exactly: int = -1,
+                  name: str = None, msg: Callable[[], None] = None, default: str = None,
+                  separator=None):
+    return ValidateArgCountHandler(args, state, at_least=at_least, exactly=exactly, name=name, msg=msg, default=default, separator=separator)

adam/commands/alter_tables.py

@@ -1,9 +1,9 @@
-from adam.commands import extract_options
+from adam.commands import extract_options, validate_args
 from adam.commands.command import Command
 from adam.commands.cql.utils_cql import cassandra, cassandra_tables as get_tables
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import log2
+from adam.utils import log2, log_exc
 
 class AlterTables(Command):
     COMMAND = 'alter tables with'
@@ -29,49 +29,34 @@ class AlterTables(Command):
 
         with self.validate(args, state) as (args, state):
             with extract_options(args, '--include-reaper') as (args, include_reaper):
-                if not args:
-                    if state.in_repl:
-                        log2('Please enter gc grace in seconds. e.g. alter gc-grace-seconds 3600')
-                    else:
-                        log2('* gc grace second is missing.')
-                        log2()
-                        Command.display_help()
-
-                    return 'missing-arg'
-
-                arg_str = ' '.join(args)
-
-                excludes = [e.strip(' \r\n') for e in Config().get(
-                    'cql.alter-tables.excludes',
-                    'system_auth,system_traces,reaper_db,system_distributed,system_views,system,system_schema,system_virtual_schema').split(',')]
-                batching = Config().get('cql.alter-tables.batching', True)
-                tables = get_tables(state, on_any=True)
-                for k, v in tables.items():
-                    if k not in excludes or k == 'reaper_db' and include_reaper:
-                        if batching:
-                            # alter table <table_name> with GC_GRACE_SECONDS = <timeout>;
-                            cql = ';\n'.join([f'alter table {k}.{t} with {arg_str}' for t in v])
-                            try:
-                                with cassandra(state) as pods:
-                                    pods.cql(cql, show_out=Config().is_debug(), show_query=not Config().is_debug(), on_any=True)
-                            except Exception as e:
-                                log2(e)
-                                continue
-                        else:
-                            for t in v:
-                                try:
-                                    # alter table <table_name> with GC_GRACE_SECONDS = <timeout>;
-                                    cql = f'alter table {k}.{t} with {arg_str}'
+                with validate_args(args, state, name='gc grace in seconds') as arg_str:
+                    excludes = [e.strip(' \r\n') for e in Config().get(
+                        'cql.alter-tables.excludes',
+                        'system_auth,system_traces,reaper_db,system_distributed,system_views,system,system_schema,system_virtual_schema').split(',')]
+                    batching = Config().get('cql.alter-tables.batching', True)
+                    tables = get_tables(state, on_any=True)
+                    for k, v in tables.items():
+                        if k not in excludes or k == 'reaper_db' and include_reaper:
+                            if batching:
+                                # alter table <table_name> with GC_GRACE_SECONDS = <timeout>;
+                                cql = ';\n'.join([f'alter table {k}.{t} with {arg_str}' for t in v])
+                                with log_exc(True):
                                     with cassandra(state) as pods:
-                                        pods.cql(show_out=Config().is_debug(), show_query=not Config().is_debug(), on_any=True)
-                                except Exception as e:
-                                    log2(e)
+                                        pods.cql(cql, show_out=Config().is_debug(), show_query=not Config().is_debug(), on_any=True)
                                     continue
+                            else:
+                                for t in v:
+                                    with log_exc(True):
+                                        # alter table <table_name> with GC_GRACE_SECONDS = <timeout>;
+                                        cql = f'alter table {k}.{t} with {arg_str}'
+                                        with cassandra(state) as pods:
+                                            pods.cql(show_out=Config().is_debug(), show_query=not Config().is_debug(), on_any=True)
+                                        continue
 
-                        log2(f'{len(v)} tables altered in {k}.')
+                            log2(f'{len(v)} tables altered in {k}.')
 
-                # do not continue to cql route
-                return state
+                    # do not continue to cql route
+                    return state
 
     def completion(self, _: ReplState) -> dict[str, any]:
         # auto completion is taken care of by sql completer

adam/commands/{app_cmd.py → app/app.py}

@@ -31,8 +31,8 @@ class App(Command):
 
                 return state
 
-    def completion(self, state: ReplState):
-        return super().completion(state, {'--force': None})
+    def completion(self, _: ReplState):
+        return {}
 
     def help(self, _: ReplState):
         return f"<AppType>.<AppAction> <args> [--force]\t post app action; check with 'show app actions' command"

adam/commands/{show → app}/show_app_actions.py

@@ -1,9 +1,9 @@
 from adam.app_session import AppSession
-from adam.apps import AppAction, Apps
+from adam.apps import Apps
 from adam.commands.command import Command
 from adam.config import Config
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log
+from adam.utils import tabulize, log
 
 class ShowAppActions(Command):
     COMMAND = 'show app actions'
@@ -28,25 +28,17 @@ class ShowAppActions(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            lines = []
+            actions = []
             for typ in Apps().app_types():
-                for action in typ.actions:
-                    a: AppAction = action
-                    args = ','.join(a.arguments())
-                    if args:
-                        line = f'{typ.name}.{a.name},{args}'
-                    else:
-                        line = f'{typ.name}.{a.name},'
-                    if a.help:
-                        line = f'{line},{a.help}'
-                    lines.append(line)
-            log(lines_to_tabular(lines, 'ACTION,ARGS,DESCRIPTION', separator=','))
+                actions.extend(typ.actions)
+
+            lines = tabulize(actions, lambda a: str(a), header='ACTION,ARGS,DESCRIPTION', separator=',')
             log()
 
             app_session: AppSession = AppSession.create(state.app_env or 'c3', state.app_app or 'c3')
             endpoint = Config().get('app.console-endpoint', 'https://{host}/{env}/{app}/static/console/index.html')
             endpoint = endpoint.replace('{host}', app_session.host).replace('{env}', app_session.env).replace('{app}', state.app_app or 'c3')
-            log(lines_to_tabular([f'CONSOLE:,{endpoint}'], separator=','))
+            tabulize([f'CONSOLE:,{endpoint}'], separator=',')
 
             return lines
 

adam/commands/{show → app}/show_app_queues.py

@@ -32,10 +32,7 @@ class ShowAppQueues(Command):
                 return state
 
     def completion(self, state: ReplState):
-        if state.app_app:
-            return super().completion(state, {'--force': None})
-
-        return {}
+        return super().completion(state, {'--force': None})
 
     def help(self, _: ReplState):
         return f"{ShowAppQueues.COMMAND} [--force]\t show invalidation queue counts"

adam/{utils_app.py → commands/app/utils_app.py}

@@ -3,12 +3,20 @@ from typing import Union
 
 from adam.app_session import AppSession
 from adam.apps import Apps
-from adam.pod_exec_result import PodExecResult
+from adam.utils_k8s.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
 from adam.utils import log2
 from adam.utils_k8s.app_clusters import AppClusters
 from adam.utils_k8s.app_pods import AppPods
 
+def app_cd_dirs(state: ReplState):
+    if state.app_app:
+        return ['..'] + AppPods.pod_names(state.namespace, state.app_env, state.app_app)
+    elif state.app_env:
+        return ['..'] + [app[0].split('-')[1] for app in Apps.apps(state.app_env)]
+    else:
+        return [env[0] for env in Apps.envs()]
+
 class AppRestHandler:
     def __init__(self, state: ReplState, forced = False):
         self.state = state

adam/commands/audit/audit.py

@@ -1,5 +1,7 @@
 import click
 
+from adam.commands import validate_args
+from adam.commands.audit.completions_l import completions_l
 from adam.commands.audit.audit_repair_tables import AuditRepairTables
 from adam.commands.audit.audit_run import AuditRun
 from adam.commands.audit.show_last10 import ShowLast10
@@ -9,7 +11,7 @@ from adam.commands.audit.utils_show_top10 import show_top10_completions_for_nest
 from adam.commands.command import Command
 from adam.commands.intermediate_command import IntermediateCommand
 from adam.repl_state import ReplState
-from adam.sql.sql_completer import SqlCompleter, SqlVariant
+from adam.sql.lark_completer import LarkCompleter
 from adam.utils import log2, wait_log
 from adam.utils_athena import Athena
 
@@ -42,36 +44,17 @@ class Audit(IntermediateCommand):
                 r = self.intermediate_run(cmd, state, args, self.cmd_list(), display_help=False)
 
             if not r or isinstance(r, str) and r == 'command-missing':
-                sql = 'select * from audit order by ts desc limit 10'
-                if args:
-                    sql = ' '.join(args)
-                else:
+                with validate_args(args, state, default='select * from audit order by ts desc limit 10') as sql:
                     log2(sql)
-
-                Athena.run_query(sql)
+                    Athena.run_query(sql)
 
             return state
 
     def completion(self, state: ReplState):
-        if state.device == ReplState.L:
-            if not self.schema_read:
-                wait_log(f'Inspecting audit database schema...')
-                self.schema_read = True
-                # warm up the caches first time when l: drive is accessed
-                Athena.table_names()
-                Athena.column_names()
-                Athena.column_names(partition_cols_only=True)
-
-            return super().completion(state) | show_top10_completions_for_nesting() | SqlCompleter(
-                lambda: Athena.table_names(),
-                expandables={
-                    'columns': lambda table: Athena.column_names(),
-                    'partition_columns': lambda table: Athena.column_names(partition_cols_only=True)
-                },
-                variant=SqlVariant.ATHENA
-            ).completions_for_nesting()
-
-        return {}
+        if state.device != ReplState.L:
+            return {}
+
+        return completions_l()
 
     def cmd_list(self):
         return [AuditRepairTables(), AuditRun(), ShowLast10(), ShowSlow10(), ShowTop10()]

adam/commands/audit/audit_repair_tables.py

@@ -1,5 +1,6 @@
 import time
 
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.config import Config
 from adam.repl_state import ReplState
@@ -31,12 +32,9 @@ class AuditRepairTables(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            tables = Config().get('audit.athena.repair-partition-tables', 'audit').split(',')
-            if args:
-                tables = args
-
-            meta = Audits.get_meta()
-            self.repair(tables, meta)
+            with validate_args(args, state, default=Config().get('audit.athena.repair-partition-tables', 'audit').split(',')) as tables:
+                meta = Audits.get_meta()
+                self.repair(tables, meta)
 
             return state
 
@@ -48,7 +46,7 @@ class AuditRepairTables(Command):
                     with Audits.offload() as exec:
                         exec.submit(lambda: self.auto_repair(hours))
 
-            return super().completion(state)
+            # return super().completion(state)
 
         return {}
 

adam/commands/audit/audit_run.py

@@ -44,7 +44,7 @@ class AuditRun(Command):
             return state
 
     def completion(self, state: ReplState):
-        return super().completion(state)
+        return {}
 
     def help(self, _: ReplState):
         return f"{AuditRun.COMMAND}\t run"

adam/commands/audit/completions_l.py

@@ -0,0 +1,15 @@
+from adam.repl_state import ReplState
+from adam.sql.lark_completer import LarkCompleter
+from adam.utils_athena import Athena
+
+def completions_l():
+    return LarkCompleter(
+        expandables={
+            'tables': lambda x: Athena.table_names(),
+            'columns': lambda table: Athena.column_names(),
+            'partition-columns': lambda table: Athena.column_names(partition_cols_only=True),
+            'topn-counts': lambda x: ['10'],
+            'topn-types': lambda x: ['last', 'slow', 'top'],
+            'topn-windows': lambda x: ['day', 'month'],
+        }, variant=ReplState.L
+    ).completions_for_nesting()

adam/commands/audit/show_last10.py

@@ -1,9 +1,6 @@
-from adam.commands.audit.utils_show_top10 import extract_limit_and_duration
+from adam.commands.audit.utils_show_top10 import run_configured_query
 from adam.commands.command import Command
 from adam.repl_state import ReplState
-from adam.utils import log2
-from adam.utils_athena import Athena
-from adam.utils_audits import Audits
 
 class ShowLast10(Command):
     COMMAND = 'show last'
@@ -28,20 +25,11 @@ class ShowLast10(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            limit, date_condition = extract_limit_and_duration(args)
-
-            query = '\n    '.join([
-                "SELECT * FROM audit",
-                f"WHERE drive <> 'z' and ({date_condition})",
-                f"ORDER BY ts DESC LIMIT {limit};"])
-            log2(query)
-            log2()
-            Athena.run_query(query)
+            run_configured_query('audit.queries.last10', args)
 
             return state
 
     def completion(self, _: ReplState):
-
         return {}
 
     def help(self, _: ReplState):

adam/commands/audit/show_slow10.py

@@ -1,9 +1,6 @@
-from adam.commands.audit.utils_show_top10 import extract_limit_and_duration
+from adam.commands.audit.utils_show_top10 import run_configured_query
 from adam.commands.command import Command
 from adam.repl_state import ReplState
-from adam.utils import log2
-from adam.utils_athena import Athena
-from adam.utils_audits import Audits
 
 class ShowSlow10(Command):
     COMMAND = 'show slow'
@@ -28,15 +25,7 @@ class ShowSlow10(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            limit, date_condition = extract_limit_and_duration(args)
-
-            query = '\n    '.join([
-                "SELECT * FROM audit",
-                f"WHERE drive <> 'z' and ({date_condition})",
-                f"ORDER BY CAST(duration AS REAL) DESC LIMIT {limit};"])
-            log2(query)
-            log2()
-            Athena.run_query(query)
+            run_configured_query('audit.queries.slow10', args)
 
             return state
 

adam/commands/audit/show_top10.py

@@ -1,8 +1,6 @@
-from adam.commands.audit.utils_show_top10 import extract_limit_and_duration
+from adam.commands.audit.utils_show_top10 import run_configured_query
 from adam.commands.command import Command
 from adam.repl_state import ReplState
-from adam.utils import log2
-from adam.utils_athena import Athena
 
 class ShowTop10(Command):
     COMMAND = 'show top'
@@ -27,14 +25,7 @@ class ShowTop10(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            limit, date_condition = extract_limit_and_duration(args)
-            query = '\n    '.join([
-                "SELECT min(c) AS cluster, line, COUNT(*) AS cnt, avg(CAST(duration AS REAL)) AS duration",
-                f"FROM audit WHERE drive <> 'z' and ({date_condition})",
-                f"GROUP BY line ORDER BY cnt DESC LIMIT {limit};"])
-            log2(query)
-            log2()
-            Athena.run_query(query)
+            run_configured_query('audit.queries.top10', args)
 
             return state
 

adam/commands/audit/utils_show_top10.py

@@ -1,17 +1,29 @@
 from datetime import datetime, timedelta
 
+from adam.config import Config
+from adam.utils import log2, log_exc
+from adam.utils_athena import Athena
 from adam.utils_audits import Audits
 from adam.utils_repl.automata_completer import AutomataCompleter
 from adam.utils_repl.state_machine import StateMachine
 
+def run_configured_query(config_key: str, args: list[str]):
+    limit, date_condition = extract_limit_and_duration(args)
+    if query := Config().get(config_key, None):
+        query = '\n    '.join(query.split('\n'))
+        query = query.replace('{date_condition}', date_condition)
+        query = query.replace('{limit}', str(limit))
+
+        log2(query)
+        log2()
+        Athena.run_query(query)
+
 def extract_limit_and_duration(args: list[str]) -> tuple[int, datetime]:
     limit = 10
     _from = datetime.now() - timedelta(days=30)
     if args:
-        try:
+        with log_exc():
             limit = int(args[0])
-        except:
-            pass
 
         if len(args) > 2 and args[1] == 'over':
             if args[2] == 'day':