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

adam/utils_app.py

@@ -0,0 +1,98 @@
+import json
+from typing import Union
+
+from adam.app_session import AppSession
+from adam.apps import Apps
+from adam.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
+
+class AppRestHandler:
+    def __init__(self, state: ReplState, forced = False):
+        self.state = state
+        self.forced = forced
+
+    def __enter__(self):
+        return self.post
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+    def post(self, args: list[str]) -> Union[ReplState, str]:
+        if not args:
+            return 'arg missing'
+
+        t_f = args[0].split('.')
+        if len(t_f) < 2:
+            return 'arg missing'
+
+        state = self.state
+
+        payload, valid = Apps().payload(t_f[0], t_f[1], args[1:] if len(args) > 1 else [])
+        if not valid:
+            log2('Missing one or more action arguments.')
+            return state
+
+        if payload:
+            try:
+                payload = json.loads(payload)
+            except json.decoder.JSONDecodeError as e:
+                log2(f'Invalid json argument: {e}')
+                return state
+
+        AppSession.run(state.app_env, state.app_app, state.namespace, t_f[0], t_f[1], payload=payload, forced=self.forced)
+
+        return state
+
+class AppPodService:
+    def __init__(self, handler: 'AppHandler'):
+        self.handler = handler
+
+    def exec(self, command: str, show_out = True) -> Union[PodExecResult, list[PodExecResult]]:
+        state = self.handler.state
+
+        if state.app_pod:
+            return AppPods.exec(state.app_pod, state.namespace, command, show_out=show_out, shell='bash')
+        elif state.app_app:
+            pods = AppPods.pod_names(state.namespace, state.app_env, state.app_app)
+            return AppClusters.exec(pods, state.namespace, command, action='bash', show_out=show_out, shell='bash')
+
+        return []
+
+    def post(self, args: list[str], forced=False) -> Union[ReplState, str]:
+        state = self.handler.state
+
+        if not args:
+            return 'arg missing'
+
+        t_f = args[0].split('.')
+        if len(t_f) < 2:
+            return 'arg missing'
+
+        payload, valid = Apps().payload(t_f[0], t_f[1], args[1:] if len(args) > 1 else [])
+        if not valid:
+            log2('Missing one or more action arguments.')
+            return state
+
+        if payload:
+            try:
+                payload = json.loads(payload)
+            except json.decoder.JSONDecodeError as e:
+                log2(f'Invalid json argument: {e}')
+                return state
+
+        AppSession.run(state.app_env, state.app_app, state.namespace, t_f[0], t_f[1], payload=payload, forced=forced)
+
+        return state
+
+class AppHandler:
+    def __init__(self, state: ReplState):
+        self.state = state
+
+    def __enter__(self):
+        return AppPodService(self)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False

adam/utils_athena.py

@@ -0,0 +1,145 @@
+import functools
+import time
+import boto3
+import botocore
+
+from adam.config import Config
+from adam.utils import lines_to_tabular, log, log2, wait_log
+
+# no state utility class
+class Athena:
+   @functools.lru_cache()
+   def database_names(like: str = None):
+      # this function is called only from export currently
+      wait_log(f'Inspecting export database schema...')
+
+      query = f"SELECT schema_name FROM information_schema.schemata WHERE schema_name <> 'information_schema'"
+      if like:
+         query = f"{query} AND schema_name like '{like}'"
+
+      try:
+         state, reason, rs = Athena.query(query)
+         if rs:
+            names = []
+            for row in rs[1:]:
+                  row_data = [col.get('VarCharValue') if col else '' for col in row['Data']]
+                  names.append(row_data[0])
+
+            return names
+      except:
+         pass
+
+      return []
+
+   def clear_cache(cache: str = None):
+      if not cache or cache == 'databases':
+         Athena.database_names.cache_clear()
+      if not cache or cache == 'tables':
+         Athena.table_names.cache_clear()
+      if not cache or cache == 'columns':
+         Athena.column_names.cache_clear()
+
+   @functools.lru_cache()
+   def table_names(database: str = 'audit', function: str = 'audit'):
+      table_names = []
+      try:
+         region_name = Config().get(f'{function}.athena.region', 'us-west-2')
+         database_name = Config().get(f'{function}.athena.database', database)
+         catalog_name = Config().get(f'{function}.athena.catalog', 'AwsDataCatalog')
+
+         athena_client = boto3.client('athena', region_name=region_name)
+         paginator = athena_client.get_paginator('list_table_metadata')
+
+         for page in paginator.paginate(CatalogName=catalog_name, DatabaseName=database_name):
+            for table_metadata in page.get('TableMetadataList', []):
+               table_names.append(table_metadata['Name'])
+      except botocore.exceptions.NoCredentialsError as e:
+         # aws credentials not found
+         if function == 'audit':
+            log2(f'Please configure AWS credentials to Audit Log Database.')
+      except:
+         pass
+
+      return table_names
+
+   @functools.lru_cache()
+   def column_names(tables: list[str] = [], database: str = None, function: str = 'audit', partition_cols_only = False):
+      try:
+         if not database:
+            database = Config().get(f'{function}.athena.database', 'audit')
+
+         if not tables:
+            tables = Config().get(f'{function}.athena.tables', 'audit').split(',')
+
+         table_names = "'" + "','".join([table.strip() for table in tables]) + "'"
+
+         query = f"select column_name from information_schema.columns where table_name in ({table_names}) and table_schema = '{database}'"
+         if partition_cols_only:
+            query = f"{query} and extra_info = 'partition key'"
+
+         _, _, rs = Athena.query(query)
+         if rs:
+            return [row['Data'][0].get('VarCharValue') for row in rs[1:]]
+      except:
+         # aws credentials not found
+         pass
+
+      return []
+
+   def run_query(sql: str, database: str = None):
+      state, reason, rs = Athena.query(sql, database)
+
+      if state == 'SUCCEEDED':
+         if rs:
+            column_info = rs[0]['Data']
+            columns = [col.get('VarCharValue') for col in column_info]
+            lines = []
+            for row in rs[1:]:
+                  row_data = [col.get('VarCharValue') if col else '' for col in row['Data']]
+                  lines.append('\t'.join(row_data))
+
+            log(lines_to_tabular(lines, header='\t'.join(columns), separator='\t'))
+
+            return len(lines)
+      else:
+         log2(f"Query failed or was cancelled. State: {state}")
+         log2(f"Reason: {reason}")
+
+      return 0
+
+   def query(sql: str, database: str = None, function: str = 'audit') -> tuple[str, str, list]:
+      region_name = Config().get(f'{function}.athena.region', 'us-west-2')
+      athena_client = boto3.client('athena', region_name=region_name)
+
+      if not database:
+         database = Config().get(f'{function}.athena.database', 'audit')
+
+      s3_output_location = Config().get(f'{function}.athena.output', f's3://s3.ops--{function}/ddl/results')
+
+      response = athena_client.start_query_execution(
+         QueryString=sql,
+         QueryExecutionContext={
+               'Database': database
+         },
+         ResultConfiguration={
+               'OutputLocation': s3_output_location
+         }
+      )
+
+      query_execution_id = response['QueryExecutionId']
+
+      while True:
+         query_status = athena_client.get_query_execution(QueryExecutionId=query_execution_id)
+         state = query_status['QueryExecution']['Status']['State']
+         if state in ['SUCCEEDED', 'FAILED', 'CANCELLED']:
+               break
+         time.sleep(1)
+
+      if state == 'SUCCEEDED':
+         results_response = athena_client.get_query_results(QueryExecutionId=query_execution_id)
+         if results_response['ResultSet']['Rows']:
+            return (state, None, results_response['ResultSet']['Rows'])
+
+         return (state, None, [])
+      else:
+         return (state, query_status['QueryExecution']['Status'].get('StateChangeReason'), [])

adam/utils_audits.py

@@ -0,0 +1,106 @@
+from datetime import datetime
+import getpass
+import time
+import requests
+
+from adam.config import Config
+from adam.utils import OffloadHandler, debug, log2, offload
+from adam.utils_athena import Athena
+from adam.utils_net import get_my_host
+
+class AuditMeta:
+   def __init__(self, partitions_last_checked: float, cluster_last_checked: float):
+      self.partitions_last_checked = partitions_last_checked
+      self.cluster_last_checked = cluster_last_checked
+
+# no state utility class
+class Audits:
+   PARTITIONS_ADDED = 'partitions-added'
+   ADD_CLUSTERS = 'add-clusters'
+
+   def log(cmd: str, cluster = 'NA', drive: str = 'NA', duration: float = 0.0, audit_extra = None):
+      payload = {
+         'cluster': cluster if cluster else 'NA',
+         'ts': time.time(),
+         'host': get_my_host(),
+         'user': getpass.getuser(),
+         'line': cmd.replace('"', '""').replace('\n', ' '),
+         'drive': drive,
+         'duration': duration,
+         'audit_extra': audit_extra if audit_extra else '',
+      }
+      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]:
+               debug(response.text)
+         else:
+               log2(f"Error: {response.status_code} {response.text}")
+      except requests.exceptions.Timeout as e:
+         log2(f"Timeout occurred: {e}")
+
+   def get_meta() -> AuditMeta:
+      checked_in = 0.0
+      cluster_last_checked = 0.0
+
+      state, _, rs = Athena.query(f'select partitions_last_checked, clusters_last_checked from meta')
+      if state == 'SUCCEEDED':
+         if len(rs) > 1:
+            try:
+               row = rs[1]['Data']
+               checked_in = float(row[0]['VarCharValue'])
+               cluster_last_checked = float(row[1]['VarCharValue'])
+            except:
+               pass
+
+      return AuditMeta(checked_in, cluster_last_checked)
+
+   def put_meta(action: str, meta: AuditMeta, clusters: list[str] = None):
+      payload = {
+         'action': action,
+         'partitions-last-checked': meta.partitions_last_checked,
+         'clusters-last-checked': meta.cluster_last_checked
+      }
+      if clusters:
+         payload['clusters'] = clusters
+
+      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]:
+               debug(response.text)
+         else:
+               log2(f"Error: {response.status_code} {response.text}")
+      except requests.exceptions.Timeout as e:
+         log2(f"Timeout occurred: {e}")
+
+   def find_new_clusters(cluster_last_checked: float) -> list[str]:
+      dt_object = datetime.fromtimestamp(cluster_last_checked)
+
+      # select distinct c2.name from cluster as c1 right outer join
+      #     (select distinct c as name from audit where y = '1969' and m = '12' and d >= '31' or y = '1969' and m > '12' or y > '1969') as c2
+      #     on c1.name = c2.name where c1.name is null
+      query = '\n    '.join([
+         'select distinct c2.name from cluster as c1 right outer join',
+         f'(select distinct c as name from audit where {Audits.date_from(dt_object)}) as c2',
+         'on c1.name = c2.name where c1.name is null'])
+      log2(query)
+      state, _, rs = Athena.query(query)
+      if state == 'SUCCEEDED':
+         if len(rs) > 1:
+               try:
+                  return [r['Data'][0]['VarCharValue'] for r in rs[1:]]
+               except:
+                  pass
+
+      return []
+
+   def date_from(dt_object: datetime):
+        y = dt_object.strftime("%Y")
+        m = dt_object.strftime("%m")
+        d = dt_object.strftime("%d")
+
+        return f"y = '{y}' and m = '{m}' and d >= '{d}' or y = '{y}' and m > '{m}' or y > '{y}'"
+
+   def offload() -> OffloadHandler:
+       return offload(max_workers=Config().get('audit.workers', 3))

adam/utils_issues.py

@@ -0,0 +1,32 @@
+from adam.checks.check_result import CheckResult
+from adam.checks.issue import Issue
+from adam.repl_session import ReplSession
+from adam.utils import lines_to_tabular, log, log2
+
+class IssuesUtils:
+    def show(check_results: list[CheckResult], in_repl = False):
+        IssuesUtils.show_issues(CheckResult.collect_issues(check_results), in_repl=in_repl)
+
+    def show_issues(issues: list[Issue], in_repl = False):
+        if not issues:
+            log2('No issues found.')
+        else:
+            suggested = 0
+            log2(f'* {len(issues)} issues found.')
+            lines = []
+            for i, issue in enumerate(issues, start=1):
+                lines.append(f"{i}||{issue.category}||{issue.desc}")
+                lines.append(f"||statefulset||{issue.statefulset}@{issue.namespace}")
+                lines.append(f"||pod||{issue.pod}@{issue.namespace}")
+                if issue.details:
+                    lines.append(f"||details||{issue.details}")
+
+                if issue.suggestion:
+                    lines.append(f'||suggestion||{issue.suggestion}')
+                    if in_repl:
+                        ReplSession().prompt_session.history.append_string(issue.suggestion)
+                        suggested += 1
+            log(lines_to_tabular(lines, separator='||'))
+            if suggested:
+                log2()
+                log2(f'* {suggested} suggested commands are added to history. Press <Up> arrow to access them.')

adam/utils_k8s/app_clusters.py

@@ -0,0 +1,28 @@
+import sys
+from typing import TypeVar
+
+from adam.utils_k8s.app_pods import AppPods
+from adam.pod_exec_result import PodExecResult
+from adam.utils import log, log2
+from adam.utils_k8s.pods import Pods
+from .kube_context import KubeContext
+
+T = TypeVar('T')
+
+# utility collection on app clusters; methods are all static
+class AppClusters:
+    def exec(pods: list[str], namespace: str, command: str, action: str = 'action',
+             max_workers=0, show_out=True, on_any = False, shell = '/bin/sh', background = False) -> list[PodExecResult]:
+        samples = 1 if on_any else sys.maxsize
+        msg = 'd`Running|Ran ' + action + ' command onto {size} pods'
+        with Pods.parallelize(pods, max_workers, samples, msg, action=action) as exec:
+            results: list[PodExecResult] = exec.map(lambda pod: AppPods.exec(pod, namespace, command, False, False, shell, background))
+            for result in results:
+                if KubeContext.show_out(show_out):
+                    log(result.command)
+                    if result.stdout:
+                        log(result.stdout)
+                    if result.stderr:
+                        log2(result.stderr, file=sys.stderr)
+
+            return results

adam/utils_k8s/app_pods.py

@@ -0,0 +1,33 @@
+import functools
+from typing import List
+from kubernetes import client
+
+from adam.config import Config
+from adam.utils_k8s.pods import Pods
+from adam.pod_exec_result import PodExecResult
+from adam.repl_session import ReplSession
+
+# utility collection on app pods; methods are all static
+class AppPods:
+    @functools.lru_cache()
+    def pod_names(namespace: str, env: str, app: str):
+        return [pod.metadata.name for pod in AppPods.app_pods(namespace, env, app)]
+
+    def app_pods(namespace: str, env: str, app: str) -> List[client.V1Pod]:
+        v1 = client.CoreV1Api()
+
+        env_key = Config().get('app.env', 'c3__env-0')
+        app_key = Config().get('app.app', 'c3__app-0')
+        label_selector = f'applicationGroup=c3,{env_key}=0{env}0,{app_key}=0{app}0'
+
+        return v1.list_namespaced_pod(namespace, label_selector=label_selector).items
+
+    def exec(pod_name: str, namespace: str, command: str, show_out = True, throw_err = False, shell = '/bin/sh', background = False) -> PodExecResult:
+        container = Config().get('app.container-name', 'c3-server')
+        r = Pods.exec(pod_name, container, namespace, command, show_out = show_out, throw_err = throw_err, shell = shell, background = background)
+
+        if r and Config().get('repl.history.push-cat-remote-log-file', True):
+            if r.log_file and ReplSession().prompt_session:
+                ReplSession().prompt_session.history.append_string(f'@{r.pod} cat {r.log_file}')
+
+        return r

adam/utils_k8s/cassandra_clusters.py

@@ -0,0 +1,36 @@
+import sys
+from typing import TypeVar
+
+from adam.config import Config
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.pod_exec_result import PodExecResult
+from adam.utils import log, log2
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.statefulsets import StatefulSets
+
+T = TypeVar('T')
+
+# utility collection on cassandra clusters; methods are all static
+class CassandraClusters:
+    def exec(sts: str, namespace: str, command: str, action: str = 'action',
+             max_workers=0, show_out=True, on_any = False, shell = '/bin/sh', background = False, log_file = None) -> list[PodExecResult]:
+
+        pods = StatefulSets.pod_names(sts, namespace)
+        samples = 1 if on_any else sys.maxsize
+        msg = 'd`Running|Ran ' + action + ' command onto {size} pods'
+        with Pods.parallelize(pods, max_workers, samples, msg, action=action) as exec:
+            results: list[PodExecResult] = exec.map(lambda pod: CassandraNodes.exec(pod, namespace, command, False, False, shell, background, log_file))
+            for result in results:
+                if show_out and not Config().is_debug():
+                    log(result.command)
+                    if result.stdout:
+                        log(result.stdout)
+                    if result.stderr:
+                        log2(result.stderr, file=sys.stderr)
+
+            return results
+
+    def pod_names_by_host_id(sts: str, ns: str):
+        pods = StatefulSets.pods(sts, ns)
+
+        return {CassandraNodes.get_host_id(pod.metadata.name, ns): pod.metadata.name for pod in pods}

adam/utils_k8s/cassandra_nodes.py

@@ -0,0 +1,33 @@
+from adam.config import Config
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.secrets import Secrets
+from adam.pod_exec_result import PodExecResult
+from adam.repl_session import ReplSession
+
+# utility collection on cassandra nodes; methods are all static
+class CassandraNodes:
+    def exec(pod_name: str, namespace: str, command: str, show_out = True, throw_err = False, shell = '/bin/sh', background = False, log_file = None) -> PodExecResult:
+        r = Pods.exec(pod_name, "cassandra", namespace, command, show_out = show_out, throw_err = throw_err, shell = shell, background = background, log_file=log_file)
+
+        if r and Config().get('repl.history.push-cat-remote-log-file', True):
+            if r.log_file and ReplSession().prompt_session:
+                ReplSession().prompt_session.history.append_string(f'@{r.pod} cat {r.log_file}')
+
+        return r
+
+    def get_host_id(pod_name: str, ns: str):
+        try:
+            user, pw = Secrets.get_user_pass(pod_name, ns)
+            command = f'echo "SELECT host_id FROM system.local; exit" | cqlsh --no-color -u {user} -p {pw}'
+            result: PodExecResult = CassandraNodes.exec(pod_name, ns, command, show_out=Config().is_debug())
+            next = False
+            for line in result.stdout.splitlines():
+                if next:
+                    return line.strip(' ')
+                if line.startswith('----------'):
+                    next = True
+                    continue
+        except Exception as e:
+            return str(e)
+
+        return 'Unknown'

adam/utils_k8s/config_maps.py

@@ -0,0 +1,34 @@
+from kubernetes import client
+
+# utility collection on config maps; methods are all static
+class ConfigMaps:
+    def create(name: str, namespace: str, data: dict[str, str], labels: dict[str, str] = {}):
+        v1 = client.CoreV1Api()
+
+        metadata = client.V1ObjectMeta(
+            name=name,
+            namespace=namespace,
+            labels=labels
+        )
+
+        configmap = client.V1ConfigMap(
+            api_version="v1",
+            kind="ConfigMap",
+            metadata=metadata,
+            data=data
+        )
+
+        try:
+            api_response = v1.create_namespaced_config_map(body=configmap, namespace=namespace)
+            # print(f"ConfigMap '{name}' created successfully in namespace '{namespace}'.")
+            # print(api_response)
+        except client.ApiException as e:
+            # print(f"Error creating ConfigMap: {e}")
+            raise e
+
+    def delete_with_selector(namespace: str, label_selector: str):
+        v1 = client.CoreV1Api()
+
+        ret = v1.list_namespaced_config_map(namespace=namespace, label_selector=label_selector)
+        for i in ret.items:
+            v1.delete_namespaced_config_map(name=i.metadata.name, namespace=namespace)

{walker/k8s_utils → adam/utils_k8s}/custom_resources.py

@@ -1,10 +1,11 @@
+import functools
 import re
 import time
 from kubernetes import client
 
-from walker.config import Config
+from adam.config import Config
 from .kube_context import KubeContext
-from walker.utils import elapsed_time, lines_to_tabular, log2
+from adam.utils import elapsed_time, lines_to_tabular, log2
 
 
 # utility collection; methods are all static
@@ -171,6 +172,10 @@ class CustomResources:
 
         return None
 
+    def clear_caches():
+        CustomResources.medusa_show_backupjobs.cache_clear()
+
+    @functools.lru_cache()
     def medusa_show_backupjobs(dc: str, ns: str) -> list[dict]:
         api_instance = client.CustomObjectsApi()
         group = 'medusa.k8ssandra.io'

adam/utils_k8s/deployment.py

@@ -0,0 +1,56 @@
+from kubernetes import client
+
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.volumes import ConfigMapMount
+
+# utility collection on deployments; methods are all static
+class Deployments:
+    def delete_with_selector(namespace: str, label_selector: str, grace_period_seconds: int = None):
+        v1 = client.AppsV1Api()
+
+        ret = v1.list_namespaced_deployment(namespace=namespace, label_selector=label_selector)
+        for i in ret.items:
+            v1.delete_namespaced_deployment(name=i.metadata.name, namespace=namespace, grace_period_seconds=grace_period_seconds)
+
+    def create_deployment_spec(name: str, image: str, image_pull_secret: str,
+                               envs: list, container_security_context: client.V1SecurityContext,
+                               volume_name: str, pvc_name:str, mount_path:str,
+                               command: list[str]=None, sa_name=None, labels: dict[str, str] = {},
+                               config_map_mount: ConfigMapMount = None):
+        return client.V1DeploymentSpec(
+            replicas=1,
+            selector=client.V1LabelSelector(match_labels=labels),
+            template=client.V1PodTemplateSpec(
+                metadata=client.V1ObjectMeta(labels=labels),
+                spec=Pods.create_pod_spec(name, image, image_pull_secret, envs, container_security_context,
+                                          volume_name, pvc_name, mount_path, command=command, sa_name=sa_name,
+                                          restart_policy="Always", config_map_mount=config_map_mount),
+            ),
+        )
+
+    def create(namespace: str, deployment_name: str, image: str,
+               command: list[str] = None,
+               secret: str = None,
+               env: dict[str, any] = {},
+               container_security_context: client.V1SecurityContext = None,
+               labels: dict[str, str] = {},
+               volume_name: str = None,
+               pvc_name: str = None,
+               mount_path: str = None,
+               sa_name=None,
+               config_map_mount: ConfigMapMount = None):
+        v1 = client.AppsV1Api()
+        envs = []
+        for k, v in env.items():
+            envs.append(client.V1EnvVar(name=str(k), value=str(v)))
+        deployment = Deployments.create_deployment_spec(deployment_name, image, secret, envs,
+                                                        container_security_context, volume_name, pvc_name,
+                                                        mount_path, command=command, sa_name=sa_name, labels=labels,
+                                                        config_map_mount=config_map_mount)
+        return v1.create_namespaced_deployment(
+            namespace=namespace,
+            body=client.V1Deployment(spec=deployment, metadata=client.V1ObjectMeta(
+                name=deployment_name,
+                labels=labels
+            ))
+        )

{walker/k8s_utils → adam/utils_k8s}/ingresses.py

@@ -1,7 +1,7 @@
 from kubernetes import client
 
-from walker.config import Config
-from walker.utils import log2
+from adam.config import Config
+from adam.utils import debug, log2
 
 # utility collection on ingresses; methods are all static
 class Ingresses:
@@ -63,8 +63,7 @@ class Ingresses:
                 log2(f"200 Ingress '{name}' in namespace '{namespace}' deleted successfully.")
             else:
                 api.delete_namespaced_ingress(name=name, namespace=namespace)
-                if Config().is_debug():
-                    log2(f"200 Ingress '{name}' in namespace '{namespace}' deleted successfully.")
+                debug(f"200 Ingress '{name}' in namespace '{namespace}' deleted successfully.")
         except client.ApiException as e:
             log2(f"Error deleting Ingress: {e}")