kaqing 2.0.99__tar.gz → 2.0.152__tar.gz

{kaqing-2.0.99 → kaqing-2.0.152}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.99
+Version: 2.0.152
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.99 → kaqing-2.0.152}/adam/batch.py

@@ -1,7 +1,7 @@
 import click
 
 from adam.commands.audit.audit import Audit, AuditCommandHelper
-from adam.commands.bash import Bash
+from adam.commands.bash.bash import Bash
 from adam.commands.check import Check, CheckCommandHelper
 from adam.commands.cp import ClipboardCopy, CopyCommandHelper
 from adam.commands.command import Command
@@ -9,7 +9,6 @@ from adam.commands.command_helpers import ClusterCommandHelper, ClusterOrPodComm
 from adam.commands.cql.cqlsh import CqlCommandHelper, Cqlsh
 from adam.commands.deploy.deploy import Deploy, DeployCommandHelper
 from adam.commands.deploy.undeploy import Undeploy, UndeployCommandHelper
-from adam.commands.describe.describe import Describe, DescribeCommandHelper
 from adam.commands.issues import Issues
 from adam.commands.login import Login
 from adam.commands.logs import Logs
@@ -97,19 +96,6 @@ def deploy(kubeconfig: str, config: str, param: list[str], namespace: str, extra
     run_command(Deploy(), kubeconfig, config, param, None, namespace, None, extra_args)
 
 
-@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=DescribeCommandHelper, help='Describe keyspace(s) or table(s).')
-@click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
-@click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
-@click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
-@click.option('--cluster', '-c', required=False, metavar='statefulset', help='Kubernetes statefulset name')
-@click.option('--namespace', '-n', required=False, metavar='namespace', help='Kubernetes namespace')
-@click.option('--pod', '-p', required=False, metavar='pod', help='Kubernetes pod name')
-@click.option('--all-nodes', '-a', is_flag=True, help='execute on all Cassandra nodes')
-@click.argument('extra_args', nargs=-1, metavar='<cluster|pod>', type=click.UNPROCESSED)
-def describe(kubeconfig: str, config: str, param: list[str], cluster: str, namespace: str, pod: str, all_nodes: bool, extra_args):
-    run_command(Describe(), kubeconfig, config, param, cluster, namespace, pod, extra_args + ('&',) if all_nodes else extra_args)
-
-
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help="Print Qing's issues.")
 @click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
 @click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')

{kaqing-2.0.99 → kaqing-2.0.152}/adam/checks/cpu.py

@@ -7,6 +7,7 @@ from adam.checks.issue import Issue
 from adam.config import Config
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.utils_k8s.custom_resources import CustomResources
+from adam.utils_k8s.pods import Pods
 
 class Cpu(Check):
     def name(self):
@@ -20,10 +21,15 @@ class Cpu(Check):
             'namespace': ctx.namespace,
             'statefulset': ctx.statefulset,
             'cpu': 'Unknown',
-            'idle': 'Unknown'
+            'idle': 'Unknown',
+            'limit': 'NA'
         }
 
         try:
+            container = Pods.get_container(ctx.namespace, ctx.pod, container_name='cassandra')
+            if container.resources.limits and "cpu" in container.resources.limits:
+                details['limit'] = container.resources.limits["cpu"]
+
             idle = 'Unknown'
             result = CassandraNodes.exec(ctx.pod, ctx.namespace, "mpstat 5 2 | grep Average | awk '{print $NF}'", show_out=ctx.show_output)
             lines = result.stdout.strip(' \r\n').split('\n')

kaqing-2.0.152/adam/checks/cpu_metrics.py

@@ -0,0 +1,52 @@
+from kubernetes.utils import parse_quantity
+
+from adam.checks.check import Check
+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_k8s.custom_resources import CustomResources
+from adam.utils_k8s.pods import Pods
+
+class CpuMetrics(Check):
+    def name(self):
+        return 'cpu-metrics'
+
+    def check(self, ctx: CheckContext) -> CheckResult:
+        issues: list[Issue] = []
+
+        details = {
+            'name': ctx.pod,
+            'namespace': ctx.namespace,
+            'statefulset': ctx.statefulset,
+            'cpu': 'Unknown',
+            'limit': 'NA'
+        }
+
+        try:
+            container = Pods.get_container(ctx.namespace, ctx.pod, container_name='cassandra')
+            if container.resources.limits and "cpu" in container.resources.limits:
+                details['limit'] = container.resources.limits["cpu"]
+
+            metrics = CustomResources.get_metrics(ctx.namespace, ctx.pod, container_name='cassandra')
+            usage = 'Unknown'
+            if metrics:
+                usage = details['cpu'] = metrics["usage"]["cpu"]
+
+            cpu_threshold = Config().get('checks.cpu-threshold', 0.0)
+            if  cpu_threshold != 0.0 and usage != "Unknown" and parse_quantity(usage) > cpu_threshold:
+                issues.append(Issue(
+                    statefulset=ctx.statefulset,
+                    namespace=ctx.namespace,
+                    pod=ctx.pod,
+                    category='cpu',
+                    desc=f'CPU is too busy: {usage}',
+                    suggestion=f"qing restart {ctx.pod}@{ctx.namespace}"
+                ))
+        except Exception as e:
+            issues.append(self.issue_from_err(sts_name=ctx.statefulset, ns=ctx.namespace, pod_name=ctx.pod, exception=e))
+
+        return CheckResult(self.name(), details, issues)
+
+    def help(self):
+        return f'{CpuMetrics().name()}: check cpu busy percentage with metrics'

{kaqing-2.0.99 → kaqing-2.0.152}/adam/columns/columns.py

@@ -1,6 +1,7 @@
 from adam.columns.column import Column
 from adam.columns.compactions import Compactions
 from adam.columns.cpu import Cpu
+from adam.columns.cpu_metrics import CpuMetrics
 from adam.columns.dir_data import DataDir
 from adam.columns.dir_snapshots import SnapshotsDir
 from adam.columns.gossip import Gossip
@@ -23,7 +24,7 @@ class Columns:
     COLUMNS_BY_NAME = None
 
     def all_columns():
-        return [Compactions(), Cpu(), DataDir(), SnapshotsDir(), Gossip(), HostId(), Memory(),
+        return [Compactions(), Cpu(), CpuMetrics(), DataDir(), SnapshotsDir(), Gossip(), HostId(), Memory(),
                 NodeAddress(), NodeLoad(), NodeOwns(), NodeStatus(),NodeTokens(), PodName(), CassandraVolume(), RootVolume()]
 
     def columns_by_name():
@@ -38,6 +39,7 @@ class Columns:
             name = name.strip(' ')
             if not name in Columns.COLUMNS_BY_NAME:
                 return None
+
             cols.append(Columns.COLUMNS_BY_NAME[name]())
 
         return cols

{kaqing-2.0.99 → kaqing-2.0.152}/adam/columns/cpu.py

@@ -1,3 +1,5 @@
+from kubernetes.utils.quantity import parse_quantity
+
 from adam.checks.check_result import CheckResult
 from adam.checks.cpu import Cpu as CpuCheck
 from adam.columns.column import Column
@@ -14,4 +16,4 @@ class Cpu(Column):
         cpu = r.details[CpuCheck().name()]
         busy = 100.0 - float(cpu['idle'])
 
-        return f'{round(busy)}%'
+        return f'{round(busy)}%/{parse_quantity(cpu["limit"]) * 100}%'

kaqing-2.0.152/adam/columns/cpu_metrics.py

@@ -0,0 +1,22 @@
+from kubernetes.utils.quantity import parse_quantity
+
+from adam.checks.check_result import CheckResult
+from adam.checks.cpu_metrics import CpuMetrics as CpuCheck
+from adam.columns.column import Column
+
+class CpuMetrics(Column):
+    def name(self):
+        return 'cpu-metrics'
+
+    def checks(self):
+        return [CpuCheck()]
+
+    def pod_value(self, check_results: list[CheckResult], pod_name: str):
+        r = self.result_by_pod(check_results, pod_name)
+        cpu = r.details[CpuCheck().name()]
+
+        cpu_decimal = parse_quantity(cpu['cpu'])
+        cpu_limit = parse_quantity(cpu['limit'])
+        business = cpu_decimal * 100 / cpu_limit
+
+        return f"{business:.2f}%({cpu_decimal}/{cpu_limit})"

{kaqing-2.0.99 → kaqing-2.0.152}/adam/commands/alter_tables.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.commands.cql.cql_utils import tables as get_tables, run_cql
+from adam.commands.cql.cql_utils import cassandra_tables as get_tables, run_cql
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
@@ -43,11 +43,6 @@ class AlterTables(Command):
         args, include_reaper = Command.extract_options(args, '--include-reaper')
         arg_str = ' '.join(args)
 
-        # r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=True)
-        # if not r:
-        #     log2('No pod is available')
-        #     return 'no-pod'
-
         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(',')]
@@ -78,8 +73,9 @@ class AlterTables(Command):
         # do not continue to cql route
         return state
 
-    def completion(self, state: ReplState) -> dict[str, any]:
+    def completion(self, _: ReplState) -> dict[str, any]:
+        # auto completion is taken care of by sql completer
         return {}
 
     def help(self, _: ReplState) -> str:
-        return f'{AlterTables.COMMAND} <param = value> [--include-reaper] \t alter on all tables'
+        return f'{AlterTables.COMMAND} <param = value> [--include-reaper] \t alter schema on all tables'

{kaqing-2.0.99 → kaqing-2.0.152}/adam/commands/app.py

@@ -22,14 +22,14 @@ class App(Command):
         return App.COMMAND
 
     def required(self):
-        return RequiredState.CLUSTER_OR_POD
+        return RequiredState.APP_APP
 
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
         state, args = self.apply_state(args, state)
-        if not self.validate_state(state, app_required=RequiredState.APP_APP):
+        if not self.validate_state(state):
             return state
 
         args, forced = Command.extract_options(args, '--force')
@@ -64,4 +64,4 @@ class App(Command):
         return {}
 
     def help(self, _: ReplState):
-        return f"{App.COMMAND} [--force]\t post app API query with type and function"
+        return f"<AppType>.<AppAction> <args> [--force]\t post app action; check with 'show app actions' command"

{kaqing-2.0.99 → kaqing-2.0.152}/adam/commands/app_ping.py

@@ -18,14 +18,14 @@ class AppPing(Command):
         return AppPing.COMMAND
 
     def required(self):
-        return RequiredState.CLUSTER_OR_POD
+        return RequiredState.APP_APP
 
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
         state, args = self.apply_state(args, state)
-        if not self.validate_state(state, app_required=RequiredState.APP_APP):
+        if not self.validate_state(state):
             return state
 
         _, forced = Command.extract_options(args, '--force')

{kaqing-2.0.99 → kaqing-2.0.152}/adam/commands/audit/audit.py

@@ -1,12 +1,16 @@
 import click
 
 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
+from adam.commands.audit.show_slow10 import ShowSlow10
+from adam.commands.audit.show_top10 import ShowTop10
+from adam.commands.audit.utils_show_top10 import show_top10_completions_for_nesting
 from adam.commands.command import Command
-from adam.config import Config
 from adam.repl_state import ReplState
-from adam.sql.sql_completer import SqlCompleter
-from adam.utils import log2
-from adam.utils_athena import audit_column_names, audit_table_names, run_audit_query
+from adam.sql.sql_completer import SqlCompleter, SqlVariant
+from adam.utils import log2, wait_log
+from adam.utils_athena import Athena
 
 class Audit(Command):
     COMMAND = 'audit'
@@ -24,11 +28,16 @@ class Audit(Command):
     def command(self):
         return Audit.COMMAND
 
+    def required(self):
+        return ReplState.L
+
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
         state, args = self.apply_state(args, state)
+        if not self.validate_state(state):
+            return state
 
         r = None
         if len(args) > 0:
@@ -41,37 +50,36 @@ class Audit(Command):
             else:
                 log2(sql)
 
-            run_audit_query(sql)
+            Athena.run_query(sql)
 
         return state
 
     def completion(self, state: ReplState):
         if state.device == ReplState.L:
             if not self.schema_read:
-                Config().wait_log(f'Inspecting audit database schema...')
+                wait_log(f'Inspecting audit database schema...')
                 self.schema_read = True
                 # warm up the caches first time when l: drive is accessed
-                audit_column_names()
-                audit_column_names(partition_cols_only=True)
-
-            # def columns(_):
-            #     return audit_column_names()
-
-            return super().completion(state) | SqlCompleter.completions(
-                lambda: audit_table_names(),
-                columns=lambda table: audit_column_names(),
-                partition_columns=lambda table: audit_column_names(partition_cols_only=True),
-                variant='athena'
-            ) | {
-                'desc': {table: None for table in audit_table_names()}}
+                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 {}
 
     def cmd_list():
-        return [AuditRepairTables()]
+        return [AuditRepairTables(), AuditRun(), ShowLast10(), ShowSlow10(), ShowTop10()]
 
     def help(self, _: ReplState):
-        return f'[{Audit.COMMAND}] <sql-statements>\t run SQL queries on Authena audit database'
+        return f'[{Audit.COMMAND}] [<sql-statements>]\t run SQL queries on Authena audit database'
 
 class AuditCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):

{kaqing-2.0.99 → kaqing-2.0.152}/adam/commands/audit/audit_repair_tables.py

@@ -1,12 +1,12 @@
 import concurrent
 import time
-import requests
 
 from adam.commands.command import Command
 from adam.config import Config
 from adam.repl_state import ReplState
 from adam.utils import log, log2
-from adam.utils_athena import audit_query, run_audit_query
+from adam.utils_athena import Athena
+from adam.utils_audits import AuditMeta, Audits
 
 class AuditRepairTables(Command):
     COMMAND = 'audit repair'
@@ -24,17 +24,23 @@ class AuditRepairTables(Command):
     def command(self):
         return AuditRepairTables.COMMAND
 
+    def required(self):
+        return ReplState.L
+
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
         state, args = self.apply_state(args, state)
+        if not self.validate_state(state):
+            return state
 
-        tables = Config().get('audit.tables', 'audit').split(',')
+        tables = Config().get('audit.athena.repair-partition-tables', 'audit').split(',')
         if args:
             tables = args
 
-        self.repair(tables)
+        meta = Audits.get_meta()
+        self.repair(tables, meta)
 
         return state
 
@@ -52,43 +58,20 @@ class AuditRepairTables(Command):
     def auto_repair(self, hours: int):
         self.auto_repaired = True
 
-        state, _, rs = audit_query(f'select * from meta')
-        if state == 'SUCCEEDED':
-            do_repair = True
-            if len(rs) > 1:
-                try:
-                    checked_in = float(rs[1]['Data'][0]['VarCharValue'])
-                    do_repair = checked_in + hours * 60 * 60 < time.time()
-                except:
-                    pass
-
-            if do_repair:
-                tables = Config().get('audit.athena.tables', 'audit').split(',')
-                self.repair(tables, show_sql=True)
-                log2(f'Audit tables have been auto-repaired.')
-
-    def repair(self, tables: list[str], show_sql = False):
+        meta: AuditMeta = Audits.get_meta()
+        if meta.partitions_last_checked + hours * 60 * 60 < time.time():
+            tables = Config().get('audit.athena.repair-partition-tables', 'audit').split(',')
+            self.repair(tables, meta, show_sql=True)
+            log2(f'Audit tables have been auto-repaired.')
+
+    def repair(self, tables: list[str], meta: AuditMeta, show_sql = False):
         with concurrent.futures.ThreadPoolExecutor(max_workers=Config().get('audit.workers', 3)) as executor:
             for table in tables:
                 if show_sql:
                     log(f'MSCK REPAIR TABLE {table}')
 
-                executor.submit(run_audit_query, f'MSCK REPAIR TABLE {table}', None,)
-            executor.submit(self.check_in,)
+                executor.submit(Athena.run_query, f'MSCK REPAIR TABLE {table}', None,)
+            executor.submit(Audits.put_meta, Audits.PARTITIONS_ADDED, meta,)
 
     def help(self, _: ReplState):
-        return f"{AuditRepairTables.COMMAND} \t run MSCK REPAIR command for new partition discovery"
-
-    def check_in(self):
-        payload = {
-            'action': 'check-in'
-        }
-        audit_endpoint = Config().get("audit.endpoint", "https://4psvtaxlcb.execute-api.us-west-2.amazonaws.com/prod/")
-        try:
-            response = requests.post(audit_endpoint, json=payload, timeout=Config().get("audit.timeout", 10))
-            if response.status_code in [200, 201]:
-                Config().debug(response.text)
-            else:
-                log2(f"Error: {response.status_code} {response.text}")
-        except requests.exceptions.Timeout as e:
-            log2(f"Timeout occurred: {e}")
+        return f"{AuditRepairTables.COMMAND} \t run MSCK REPAIR command for new partition discovery"

kaqing-2.0.152/adam/commands/audit/audit_run.py

@@ -0,0 +1,58 @@
+import concurrent
+
+from adam.commands.command import Command
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.utils import log2
+from adam.utils_athena import Athena
+from adam.utils_audits import AuditMeta, Audits
+
+class AuditRun(Command):
+    COMMAND = 'audit run'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(AuditRun, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+        self.auto_repaired = False
+
+    def command(self):
+        return AuditRun.COMMAND
+
+    def required(self):
+        return ReplState.L
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        state, args = self.apply_state(args, state)
+        if not self.validate_state(state):
+            return state
+
+        meta: AuditMeta = Audits.get_meta()
+        clusters = Audits.find_new_clusters(meta.cluster_last_checked)
+        Audits.put_meta(Audits.ADD_CLUSTERS, meta, clusters=clusters)
+        if clusters:
+            log2(f'Added {len(clusters)} new clusters.')
+            tables = Config().get('audit.athena.repair-cluster-tables', 'cluster').split(',')
+            with concurrent.futures.ThreadPoolExecutor(max_workers=Config().get('audit.workers', 3)) as executor:
+                for table in tables:
+                    executor.submit(Athena.run_query, f'MSCK REPAIR TABLE {table}', None,)
+        else:
+            log2(f'No new clusters were found.')
+
+        return state
+
+    def completion(self, state: ReplState):
+        if state.device == ReplState.L:
+            return super().completion(state)
+
+        return {}
+
+    def help(self, _: ReplState):
+        return f"{AuditRun.COMMAND} \t run"

kaqing-2.0.152/adam/commands/audit/show_last10.py

@@ -0,0 +1,51 @@
+from adam.commands.audit.utils_show_top10 import extract_limit_and_duration
+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'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowLast10, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowLast10.COMMAND
+
+    def required(self):
+        return ReplState.L
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        state, args = self.apply_state(args, state)
+        if not self.validate_state(state):
+            return 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)
+
+        return state
+
+    def completion(self, _: ReplState):
+
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{ShowLast10.COMMAND} [limit]\t show last <limit> audit lines'

kaqing-2.0.152/adam/commands/audit/show_slow10.py

@@ -0,0 +1,50 @@
+from adam.commands.audit.utils_show_top10 import extract_limit_and_duration
+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'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowSlow10, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowSlow10.COMMAND
+
+    def required(self):
+        return ReplState.L
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        state, args = self.apply_state(args, state)
+        if not self.validate_state(state):
+            return 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)
+
+        return state
+
+    def completion(self, _: ReplState):
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{ShowSlow10.COMMAND} [limit]\t show slow <limit> audit lines'

kaqing-2.0.152/adam/commands/audit/show_top10.py

@@ -0,0 +1,48 @@
+from adam.commands.audit.utils_show_top10 import extract_limit_and_duration
+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'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowTop10, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowTop10.COMMAND
+
+    def required(self):
+        return ReplState.L
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        state, args = self.apply_state(args, state)
+        if not self.validate_state(state):
+            return 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)
+
+        return state
+
+    def completion(self, _: ReplState):
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{ShowTop10.COMMAND} [limit]\t show top <limit> audit lines'