cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/internal/proc_compat.py

@@ -0,0 +1,75 @@
+import os
+import sys
+import platform
+
+
+def get_process_name():
+    """Return current process name (basename of argv[0])."""
+    try:
+        # Linux fast path
+        with open('/proc/self/comm', 'r') as f:
+            return f.read().strip()
+    except (IOError, OSError):
+        pass
+    # Cross-platform fallback
+    if sys.argv:
+        return os.path.basename(sys.argv[0])
+    return os.path.basename(sys.executable)
+
+
+def get_cmdline():
+    """Return command line as a list of strings."""
+    try:
+        with open('/proc/self/cmdline', 'rb') as f:
+            return f.read().decode('utf-8', errors='replace').split('\x00')
+    except (IOError, OSError):
+        pass
+    return list(sys.argv)  # fallback: sys.argv covers script args
+
+
+def get_rss_bytes():
+    """Return process RSS (resident set size) in bytes."""
+    try:
+        # Linux: /proc/self/status — VmRSS in kB
+        with open('/proc/self/status', 'r') as f:
+            for line in f:
+                if line.startswith('VmRSS:'):
+                    return int(line.split()[1]) * 1024
+    except (IOError, OSError):
+        pass
+    try:
+        # macOS / BSD fallback via resource module
+        import resource
+        rss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+        if platform.system() == 'Linux':
+            rss *= 1024  # Linux reports ru_maxrss in kB
+        return rss
+    except (ImportError, AttributeError):
+        pass
+    return 0
+
+
+def get_virtual_memory():
+    """Return (total, available, percent, used, free) in bytes."""
+    try:
+        mem = {}
+        with open('/proc/meminfo', 'r') as f:
+            for line in f:
+                parts = line.split()
+                if len(parts) >= 2:
+                    mem[parts[0].rstrip(':')] = int(parts[1]) * 1024
+        total     = mem.get('MemTotal', 0)
+        available = mem.get('MemAvailable', mem.get('MemFree', 0))
+        free      = mem.get('MemFree', 0)
+        used      = total - available
+        percent   = (used / total * 100) if total else 0.0
+        return (total, available, percent, used, free)
+    except (IOError, OSError, ValueError):
+        pass
+    return (0, 0, 0.0, 0, 0)
+
+
+def get_free_memory_mb():
+    """Return free physical memory in MB."""
+    return get_virtual_memory()[4] >> 20
+

pythonagent/agent/internal/profile.py

@@ -0,0 +1,47 @@
+import time
+from pythonagent.agent.internal.proc_compat import get_rss_bytes
+ 
+ 
+#def elapsed_since(start):
+#    return time.strftime("%H:%M:%S", time.gmtime(time.time() - start))
+
+def elapsed_since(start):
+    #return time.strftime("%H:%M:%S", time.gmtime(time.time() - start))
+    elapsed = time.time() - start
+    if elapsed < 1:
+        return str(round(elapsed*1000,2)) + " ms"
+    if elapsed < 60:
+        return str(round(elapsed, 2)) + " s"
+    if elapsed < 3600:
+        return str(round(elapsed/60, 2)) + " min"
+    else:
+        return str(round(elapsed / 3600, 2)) + " hrs"
+
+def format_bytes(bytes):
+    if abs(bytes) < 1000:
+        return str(bytes)+" B"
+    elif abs(bytes) < 1e6:
+        return str(round(bytes/1e3,2)) + " kB"
+    elif abs(bytes) < 1e9:
+        return str(round(bytes / 1e6, 2)) + " MB"
+    else:
+        return str(round(bytes / 1e9, 2)) + " GB"
+ 
+def get_process_memory():
+    return get_rss_bytes()
+ 
+ 
+def profile(func):
+    def wrapper(*args, **kwargs):
+        mem_before = get_process_memory()
+        start = time.time()
+        result = func(*args, **kwargs)
+        elapsed_time = elapsed_since(start)
+        mem_after = get_process_memory()
+        print("{0}: memory before: {1}, after: {2}, consumed: {3}; exec time: {4}".format(
+            func.__name__,
+            format_bytes(mem_before), format_bytes(mem_after), format_bytes(mem_after - mem_before),
+            elapsed_time))
+        return result
+    return wrapper
+

pythonagent/agent/internal/provider.py

@@ -0,0 +1,83 @@
+import contextvars
+
+
+_CAV_CONTEXTVAR = contextvars.ContextVar("cavisson_contextvar", default=None)
+_CURRENTBT_CONTEXTVAR = contextvars.ContextVar("currentbt_contextvar", default=None)
+_STATUSCODE_CONTEXTVAR = contextvars.ContextVar("statuscode_contextvar", default=None)
+
+
+class ContextProvider(object):
+
+    def __init__(self):
+        self.token = None
+
+    def _has_active_context(self):
+        ctx = _CAV_CONTEXTVAR.get()
+        return ctx is not None
+
+    def activate(self, ctx):
+        self.token = _CAV_CONTEXTVAR.set(ctx)
+
+    def active(self):
+        item = _CAV_CONTEXTVAR.get()
+        return item
+
+    def reset(self):
+        pass
+        #if self.token:
+            #_CAV_CONTEXTVAR.reset(self.token)
+
+
+
+class CurrentBTProvider(object):
+
+    def __init__(self):
+        self.token = None
+
+    def _has_active_context(self):
+        ctx = _CURRENTBT_CONTEXTVAR.get()
+        return ctx is not None
+
+    def activate(self, ctx):
+        self.token = _CURRENTBT_CONTEXTVAR.set(ctx)
+
+    def active(self):
+        item = _CURRENTBT_CONTEXTVAR.get()
+        return item
+
+    def reset(self):
+        pass
+        #if self.token:
+            #_CURRENTBT_CONTEXTVAR.reset(self.token)
+
+
+
+class StatusCodeProvider(object):
+
+    def __init__(self):
+        self.token = None
+
+    def _has_active_context(self):
+        ctx = _STATUSCODE_CONTEXTVAR.get()
+        return ctx is not None
+
+    def activate(self, ctx):
+        self.token = _STATUSCODE_CONTEXTVAR.set(ctx)
+
+    def active(self):
+        item = _STATUSCODE_CONTEXTVAR.get()
+        return item
+
+    def reset(self):
+        pass
+        #if self.token:
+            #_STATUSCODE_CONTEXTVAR.reset(self.token)
+
+
+
+
+
+
+
+
+

pythonagent/agent/internal/thread_dump.py

@@ -0,0 +1,85 @@
+import json
+import os
+from datetime import datetime
+import platform
+import time
+import threading
+import traceback
+import sys
+import multiprocessing
+
+
+def dumpstacks(nd_build):
+    my_system = platform.uname()
+    osName = my_system.system
+    osVersion = my_system.version
+    arch = my_system.machine
+    cpu_count = multiprocessing.cpu_count()
+    l = os.getloadavg()
+    res = sum(list(l))
+    sys_load_avg = round(res, 2) / 3
+    header = ("Full thread dump BCI Agent :- [ Dump Taken at : " + datetime.now().strftime(
+        "%d/%m/%Y %H:%M:%S") + " , Where BCIAgent build = " + nd_build + "]")
+    deadlocked_threads = ""
+    nid = "0x0"
+    prio = "5"
+    vendor = ""
+    version = ""
+    system_name = os.getenv('HOSTNAME')
+    # //****append the thread details into list(code)*****//
+    code = []
+    o = []
+    al = []
+
+    thread_dict = {}
+    for thread in threading.enumerate():
+        thread_dict[thread.ident] = thread
+
+    for threadId, stack in sys._current_frames().items():
+        thread_name = None
+        thread_status = None
+        thread_object = thread_dict.get(threadId, None)
+
+        if thread_object:
+            thread_name = thread_object.name
+            if thread_object.isDaemon():
+                thread_status = 'Daemon'
+            else:
+                thread_status = 'Non-Daemon'
+
+        if not thread_name:
+            thread_name = "unknown"
+
+        if not thread_status:
+            thread_status = "unknown"
+
+        thread_string = ("\n\n'{}'".format(thread_name)
+                         + " prio={}".format(prio)
+                         + " tid={}".format(threadId)
+                         + " nid={}".format(nid)
+                         + " " + thread_status + " \n"
+                         + "java.lang.Thread.State: {} ".format(thread_status))
+
+        code.extend([thread_string])
+
+        for filename, lineno, name, line in traceback.extract_stack(stack):
+            code.append('File: "%s", line %d, in %s, at %s' % (filename, lineno, name, datetime.now()))
+            if line:
+                code.append("  %s" % (line.strip()))
+
+    thread_dump_header = {
+        "": header,
+        "vmName": osName,
+        "version": version,
+        "vendor": vendor,
+        "osName": osName,
+        "osVersion": osVersion,
+        "arch": arch,
+        "noOfProcessors": cpu_count,
+        "SysLoadAvg": sys_load_avg,
+        "deadlocked threads": deadlocked_threads
+    }
+    joined_code = "\n".join((code))
+    return f"{thread_dump_header}" + '\n' + f"{joined_code}\n"
+
+

pythonagent/agent/internal/udp.py

@@ -0,0 +1,245 @@
+import uuid
+import os
+import socket
+
+import sys
+import threading
+import json
+from .udp_message import create_start_transaction_message, create_end_transaction_message
+from .udp_message import create_method_entry_message, create_method_exit_message
+from .udp_message import create_transaction_encode_http_message
+from .udp_message import create_exception_encode_message
+from .udp_message import create_havoc_message
+from .udp_message import create_init_message, create_agent_initialize_message
+from .udp_message import create_heartbeat_message
+import time
+import logging
+
+udp_connection = None
+
+logger = logging.getLogger('pythonagent.agent')
+
+
+class UDPConnection(object):
+    def __init__(self, agent_obj):
+
+        if 'CAV_APP_AGENT_PROXYIP' in os.environ:
+            self.cav_proxy_ip = os.environ['CAV_APP_AGENT_PROXYIP']
+        else:
+            self.cav_proxy_ip = "127.0.0.1"
+
+        if 'CAV_APP_AGENT_PROXYPORT' in os.environ:
+            self.cav_proxy_port = int(os.environ['CAV_APP_AGENT_PROXYPORT'])
+
+        else:
+            self.cav_proxy_port = 10000
+
+        self.server_address_port = (self.cav_proxy_ip, self.cav_proxy_port)
+
+        # Create a UDP socket at client side
+        try:
+
+            self.UDPClientSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+            logger.debug("Server Port {}".format(self.server_address_port))
+
+            havoc_thread = threading.Thread(target=incoming_message_processor, name="havoc_thread",
+                                            args=(self.UDPClientSocket, agent_obj), daemon=True)
+            havoc_thread.start()
+
+            heartbeat_thread = threading.Thread(target=heartbeat_sender, name="heartbeat_thread",
+                                                args=(self.UDPClientSocket, self.server_address_port, agent_obj),
+                                                daemon=True)
+            heartbeat_thread.start()
+
+
+        except:
+            logger.warning("Unable to create UDP Connection")
+
+    def send(self, message, tx_type="non_start_fp"):
+
+        # Send to server using created UDP socket
+        try:
+            self.UDPClientSocket.sendto(message, self.server_address_port)
+
+        except:
+            logger.warning("Unable to send UDP packet")
+
+
+def heartbeat_sender(udp_socket, address_port, ag_obj):
+    logger.info("heartbeat sender started")
+    context = ag_obj.get_transaction_context()
+    if not context:
+        from pythonagent.agent.internal.agent import TransactionContext
+        context = TransactionContext()  # Create dummy context to avoid failure
+    message = create_heartbeat_message(context, ag_obj)
+    logger.info("heartbeat message {}".format(message))
+    while True:
+        try:
+            logger.debug("heartbeat about to send")
+            udp_socket.sendto(message, address_port)
+            logger.info("heartbeat sent")
+            time.sleep(10)
+            logger.debug("heartbeat sleep completed")
+        except Exception as e:
+            logger.error("heartbeat exception", e)
+
+
+def incoming_message_processor(udp_socket, agent_obj):
+    logger.debug("New thread started")
+
+    from pythonagent.agent.probes.havoc.havoc_manager import NDNetHavocMonitor  # Don't shift to top, it will cause circular import
+    from pythonagent.utils import process_raw_havoc_message, process_udp_agent_init_response
+    havoc_monitor = NDNetHavocMonitor.get_instance()
+    # logger.debug("udp.py havoc id {}".format(id(havoc_monitor)))
+    udp_socket.settimeout(2.0)
+    buffer_size = 4096
+    counter = 0
+
+    while True:
+
+        try:  # timeout (non-blocking behaviour) added because in warm-start, listener is not working sometimes
+            counter += 1
+            logger.debug("counter: {}".format(counter))
+            logger.debug("Going to call recv from api for {} time".format(counter))
+            logger.debug("Going to call recv from api")
+            data, address = udp_socket.recvfrom(buffer_size)
+            logger.debug("incoming received message = {} from address {}".format(data, address))
+            logger.debug("after gettting message")
+
+            output = str(data)
+
+            if output[2:5] == "[\\n":  # Output starts with b'[\n
+                process_udp_agent_init_response(output, agent_obj)
+                continue
+
+            if output == "b'Heart Beat Received'":
+                logger.debug("ignoring heartbeat acknowledgement")
+                continue
+            try:
+                body, header_dict = process_raw_havoc_message(output, agent_obj.cav_env)
+                havoc_monitor.parse_nethavoc_config(body, header_dict)
+
+            except Exception as e:
+                logger.warning("Unable to parse config: {}", e)
+
+        except socket.timeout:
+            logger.debug("recv timed out")  # This is not an exception, but a mechanism to implement timeout
+
+
+def generate_bt():
+    id = uuid.uuid4()
+    id_int = id.int
+    return id_int
+
+
+def sdk_init(agent_obj):
+    agent_obj.udp_connection = UDPConnection(agent_obj)
+    logger.debug("called sdk init")
+    context = agent_obj.get_transaction_context()
+    if not context:
+        from pythonagent.agent.internal.agent import TransactionContext
+        context = TransactionContext()  # Create dummy context to avoid failure
+    logger.debug("transaction context dictionary inside sdk init in udp.py {}".format(context.function_name))
+    message = create_init_message(context, agent_obj)
+    logger.debug("first message to be sent to proxy {}".format(message))
+    agent_obj.udp_connection.send(message)
+    logger.debug("init sent")
+
+    message = create_agent_initialize_message(context, agent_obj)
+    logger.debug("sending agent initialize message {}".format(message))
+    agent_obj.udp_connection.send(message)
+    logger.debug("sent agent initialize message")
+    return udp_connection
+
+
+def sdk_free(agent_obj):
+    pass
+
+
+def method_entry(agent_obj, bt, method, query_string, url_parameter, query_parameter="NA"):
+    context = agent_obj.get_transaction_context()
+    message = create_method_entry_message(context, bt, method, query_string, url_parameter, query_parameter, agent_obj)
+
+    logger.info("method_entry {}".format(message))
+    agent_obj.udp_connection.send(message)
+
+
+def method_exit(agent_obj, bt, method, backend_header, status, duration):
+    context = agent_obj.get_transaction_context()
+    # message = create_method_exit_message(context, bt, method)
+    message = create_method_exit_message(context, bt, method, backend_header, status, duration, agent_obj)
+    logger.info("method_exit: status {}, duration {}, message {}".format(status, duration, message))
+    agent_obj.udp_connection.send(message)
+
+
+def start_business_transaction(agent_obj, bt_name, correlation_header):
+    if os.environ['nd_init_done'] == '0':
+        agent_obj.sdk_init()
+
+    context = agent_obj.get_transaction_context()
+    # message = udp_message.create_start_transaction_message(context, bt_name, correlation_header)
+    message = create_start_transaction_message(context, bt_name, correlation_header, agent_obj)
+    logger.info("start_business_transaction {}".format(message))
+    agent_obj.udp_connection.send(message, "start_fp")
+
+    bt = generate_bt()
+
+    agent_obj.active_bts.add(bt)
+    agent_obj.set_current_bt(bt)
+
+    return bt
+
+
+def end_business_transaction(agent_obj, bt):
+    status_code = agent_obj.get_current_status_code()
+    context = agent_obj.get_transaction_context()
+    message = create_end_transaction_message(context, bt, status_code, agent_obj)
+
+    agent_obj.logger.info("status_code {}, message {}".format(status_code, message))
+
+    agent_obj.udp_connection.send(message)
+    rc = 0  # DUMMY VALUE FOR SUCCESS
+    agent_obj.reset_transaction_context()
+
+    return rc
+
+
+def store_business_transaction(agent_obj, bt, unique_bt_id):
+    pass
+
+
+def db_call_begin(bt, db_host, db_query, db_query_params=None):
+    pass
+
+
+def db_call_end(bt, ip_handle):
+    pass
+
+
+def http_call_begin(agent_obj, bt, http_host, url):
+    handle = 0  # DUMMY NON ZERO VALUE
+    return handle
+
+
+def http_call_end(agent_obj, bt, ip_handle):
+    pass
+
+def http_req_resp_wrapper(agent_obj, bt, rbuffer, rtype, statuscode):
+    context = agent_obj.get_transaction_context()
+    message = create_transaction_encode_http_message(context, bt, rbuffer, rtype, statuscode, agent_obj)
+    logger.info("transaction_encode_http message {}".format(message))
+    agent_obj.udp_connection.send(message)
+
+def exception_dump(agent_obj, bt, mpp, starttime, excptnclsname, excptnmsg, throwingclsname,
+                   throwingmtdname, excptncause, excptnlineno, stacktrace):
+    context = agent_obj.get_transaction_context()
+    message = create_exception_encode_message(context, excptnlineno, excptnclsname, throwingclsname, throwingmtdname,  
+                                              excptnmsg, excptncause, stacktrace, starttime, agent_obj)
+    logger.info("exception_encode message {}".format(message))
+    agent_obj.udp_connection.send(message)
+
+def havoc_message(agent_obj, havoc_header):
+    context = agent_obj.get_transaction_context()
+    message = create_havoc_message(context, havoc_header, agent_obj)
+    logger.debug("havoc_message: {}".format(message))
+    agent_obj.udp_connection.send(message)