cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/internal/agent.py

@@ -0,0 +1,1651 @@
+import logging
+from pythonagent.lib import get_ident
+import ctypes
+from ctypes import create_string_buffer
+import os
+import sys
+import time
+import platform
+from pythonagent.agent.probes.havoc.havoc_manager import NDNetHavocMonitor, NDHavocException
+
+from pythonagent.agent.internal import udp
+from pythonagent.agent.internal.provider import ContextProvider, CurrentBTProvider, StatusCodeProvider
+from pythonagent.agent.probes.frameworks import wsgi  # aiflagset
+from pythonagent.agent.probes.Instrumentation.find import find
+from pythonagent.agent.internal.metadata.agent_meta_data import build_metadata_block
+from pythonagent.utils import generate_flow_path_id, get_utf8_bytes, get_current_timestamp_in_us, process_raw_havoc_message
+import threading,gc
+from pythonagent.agent.internal.proc_compat import get_rss_bytes
+from threading import  Timer
+from pythonagent.agent.internal.thread_dump import dumpstacks
+from pythonagent.agent.internal.heap_dump import create_heap_dump_muppy
+from pythonagent.utils import get_current_timestamp_in_us
+
+
+class RepeatedTimer(object):
+    def __init__(self, interval, function, *args, **kwargs):
+        self._timer = None
+        self.interval = interval
+        self.function = function
+        self.args = args
+        self.kwargs = kwargs
+        self.is_running = False
+        self.start()
+
+    def _run(self):
+        self.is_running = False
+        self.start()
+        self.function(*self.args, **self.kwargs)
+    def start(self):
+        if not self.is_running:
+            self._timer = Timer(self.interval, self._run)
+            self._timer.start()
+            self.is_running = True
+
+    def stop(self):
+        self._timer.cancel()
+        self.is_running = False
+
+class TransactionContext(object):
+    def __init__(self):
+        self.nd_init_done = None
+        self.request_id = None
+        self.api_request_id = None
+        self.aws_request_id = None
+        self.function_name = None
+        self.bt_id = None
+        self.tier_callout_type = None
+        self.tier_callout_start_time = 0
+        self.db_callout_start_time = 0
+        self.backend_header = None
+        self.http_request_type = None
+        self.tier_name = None
+        self.server_name = None
+        self.instance_name = None
+        self.url_path = None
+        self.flow_path_id = None
+        self.havoc_applied = False
+        self.fp_topo = None
+        self.host_str = None
+        self.callout_id = 0
+        self.btname = None
+
+
+
+class Agent(object):
+    """The entry point for the Python agent.
+
+    """
+    _instance = None
+    @staticmethod
+    def get_instance():
+        if Agent._instance is None:
+            Agent()
+        return Agent._instance
+
+    def __init__(self):
+        if Agent._instance is not None:
+            raise Exception("Agent class is a singleton! Use get_instance()")
+
+        Agent._instance = self
+
+        super(Agent, self).__init__()
+        self.logger = logging.getLogger('pythonagent.agent')
+        self.aiobj = None
+        # if os.environ['CAV_RUNNING_MODE']=='0':
+        #    os.environ['CAV_RUNNING_MODE']='1'
+        #    return
+        self.app_id = None
+        self.tier_id = None
+        self.node_id = None
+        self.account_guid = None
+        self.controller_guid = None
+        self._tx_factory = None
+
+        # Services
+        # self.proxy_control_svc = None
+        # self.config_svc = None
+        # self.tx_svc = None
+        # self.snapshot_svc = None
+        
+        self.active_bts = set()
+        self.current_bts = {}
+        self.transaction_context = {}
+        self.eum_config = None
+
+        self.nd_init_done = None
+        self.last_forced_snapshot = 0
+        self.lib = None
+        self.fp_topo = None
+
+        if "CAV_APP_AGENT_ENV" in os.environ:
+            if os.environ['CAV_APP_AGENT_ENV'] == "AWS_LAMBDA":
+                self.cav_env = "AWS_LAMBDA"
+            else:
+                self.cav_env = "NATIVE"
+        else:
+            self.cav_env = "NATIVE"
+
+        if "CAV_APP_AGENT_TIER" in os.environ:
+                self.tier_name = os.environ.get("CAV_APP_AGENT_TIER")
+        else:
+            self.tier_name = "default"
+
+        if "CAV_APP_AGENT_SERVER" in os.environ:
+                self.server_name = os.environ.get("CAV_APP_AGENT_SERVER")
+        else:
+            self.server_name = "default"
+
+        if "CAV_APP_AGENT_INSTANCE" in os.environ:
+                self.instance_name = os.environ.get("CAV_APP_AGENT_INSTANCE")
+                self.function_name = os.environ.get("CAV_APP_AGENT_INSTANCE")
+        else:
+            self.instance_name = "default"
+            self.function_name = "default"
+
+        self.nd_cookie_key = None
+        self.nv_cookie_key = None
+        self.cookie_method_position = None
+        self.cookie_domain = None
+        self.header_in_response = None
+        self.disable_nd_nv = False
+        self.exception_stack_depth = 50
+        self.test_running = True
+        self.nf_enabled = False
+
+        self.start()
+
+        if self.cav_env == "NATIVE":
+            self.ai_wrapper_begin()
+            self.ad_wrapper()
+            self.register_nd_cookie_callback()
+            self.gc_nd_status_callback()
+            self.thread_dump_callback()
+            self.nd_pythread_status_callback()
+            self.register_havoc_callback()
+            self.get_nf_status()
+            # self.register_test_status_callback()
+            # self.thd_wrapper()
+            # self.ai_wrapper_end()
+            # self.ai_wrapper_begin()
+
+        self.current_status_code = {}
+
+        self.havoc_monitor = NDNetHavocMonitor.get_instance()
+
+        self.application_loggers = set()
+
+        if self.cav_env == "NATIVE":
+            try:
+                self.gc_monitor_rt = RepeatedTimer(60, self.heap_gc_stats)
+                self.thread_monitor_rt = RepeatedTimer(60, self.thread_stats)
+                self.refresh_config_rt = RepeatedTimer(25, self.havoc_monitor.refresh_configs, self)
+            except Exception as e:
+                self.logger.info("Exception while starting GC thread : {}".format(e))
+
+        self.context_provider = ContextProvider()
+        self.currentbt_provider = CurrentBTProvider()
+        self.statuscode_provider = StatusCodeProvider()
+
+    def start(self):
+        # Use NDHOME env variable to locate libndsdk_py.so, fallback to default if missing
+        ndhome = os.environ.get('NDHOME')
+        path = os.path.join(ndhome,'python' ,'libs', 'libndsdk_py.so')
+
+        if not os.path.exists(path):
+            path = '/usr/local/lib/libndsdk_py.so'
+
+
+
+        if self.cav_env == "NATIVE":
+            self.lib = self.load_common_lib(path)
+            self.register_nv_cookie_callback()
+            self.register_exception_stack_depth_callback()
+            self.register_instr_prof_callback()
+            self.register_heap_dump_callback()
+
+        #self.logger.info("going to start sdk_init()")
+        self.sdk_init()
+        #self.logger.info("sdk_init() done")
+        # self.nd_init_done = True
+        os.environ['nd_init_done'] = '1'
+
+
+    def stop(self):
+        """Stop the agent from doing anything else.
+
+        Ideally this will stop any interceptors from doing anything, it will
+        disconnect all ties to the proxy etc etc.
+
+        """
+        self.nd_init_done = False
+        os.environ['nd_init_done'] = '0'
+
+        # @staticmethod
+        def getInstance(self):
+            """Static Access Method"""
+            if self.start.__shared_instance is None:
+                # Proxy()
+                self.start()
+            # return Proxy.__shared_instance
+            return self.start.__shared_instance
+
+    # @profile
+    def load_common_lib(self, lib_path):
+
+        self.lib = ctypes.cdll.LoadLibrary(lib_path)
+        # self.lib.nd_init2.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
+
+        ################
+        # DECLARATIONS
+        ################
+
+        self.lib.nd_method_entry.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_longlong]
+        self.lib.nd_method_exit.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_longlong, ctypes.c_longlong, ctypes.c_longlong, ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))]
+
+
+        self.lib.nd_bt_begin.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_longlong]
+        self.lib.nd_bt_begin.restype = ctypes.c_void_p
+
+        self.lib.nd_bt_end.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int, ctypes.c_longlong, ctypes.c_longlong, ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))]
+        self.lib.nd_bt_end.restype = ctypes.c_int
+
+        self.lib.nd_bt_store.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+
+        self.lib.nd_ip_db_callout_begin.argtypes = [ctypes.c_char_p, ctypes.c_void_p, ctypes.c_char_p,ctypes.c_char_p, ctypes.c_longlong]
+        self.lib.nd_ip_db_callout_begin.restype = ctypes.c_int
+
+        self.lib.nd_ip_db_callout_end.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_void_p, ctypes.c_int, ctypes.c_longlong, ctypes.c_longlong, ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))]
+        self.lib.nd_ip_db_callout_end.restype = ctypes.c_int
+
+        self.lib.nd_ip_http_callout_begin.argtypes = [ctypes.c_char_p,ctypes.c_void_p, ctypes.c_char_p]
+        self.lib.nd_ip_http_callout_begin.restype = ctypes.c_int
+
+        self.lib.nd_ip_http_callout_end.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_void_p, ctypes.c_int, ctypes.c_longlong, ctypes.c_longlong, ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), ctypes.c_longlong]
+        self.lib.nd_ip_http_callout_end.restype = ctypes.c_int
+
+        self.lib.sdk_getTopoFpStr.argtypes = [ctypes.c_void_p]
+        self.lib.sdk_getTopoFpStr.restype = ctypes.POINTER(ctypes.c_char_p)
+
+        self.lib.sdk_getNFStatus.argtypes = None
+        self.lib.sdk_getNFStatus.restype = ctypes.c_int
+
+        self.lib.sdk_get_propagation_header.argtypes = [ctypes.c_void_p]
+        self.lib.sdk_get_propagation_header.restype = ctypes.POINTER(ctypes.c_char_p)
+
+        self.lib.sdk_getNdBuild.argtypes = None
+        self.lib.sdk_getNdBuild.restype = ctypes.c_char_p
+
+        #self.lib.sdk_free_memory.argtypes = [ctypes.c_char_p]
+
+        self.lib.handleUploadDownload.argtypes = [ctypes.c_char_p]
+        self.lib.handleUploadDownload.restype = ctypes.c_void_p
+
+        self.lib.sdk_getNDSessionCookie.argtypes = [ctypes.c_void_p]
+        self.lib.sdk_getNDSessionCookie.restype = ctypes.POINTER(ctypes.c_char_p)
+
+        self.lib.get_custom_nd_header.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_longlong]
+        self.lib.get_custom_nd_header.restype = ctypes.c_char_p
+
+        self.lib.sendGCReport.argtypes = [ctypes.c_int,ctypes.c_char_p]
+
+        self.lib.sdk_get_otl_traceparent.argtypes = [ctypes.c_void_p]
+        self.lib.sdk_get_otl_traceparent.restype = ctypes.POINTER(ctypes.c_char_p)
+
+        self.lib.sdk_get_otl_tracestate.argtypes = [ctypes.c_void_p]
+        self.lib.sdk_get_otl_tracestate.restype = ctypes.POINTER(ctypes.c_char_p)
+
+        self.lib.getstacktracearray.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p,
+                                                ctypes.c_char_p,
+                                                ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p]
+
+        self.lib.sdk_httpReqRespWrapper.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int]
+
+        self.lib.havoc_response_from_agent.argtypes = [ctypes.c_char_p]
+
+        self.lib.sdk_dumpLogMessage.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+        self.lib.sdk_dumpLogMessage.restype = ctypes.c_void_p
+
+
+
+
+        self.lib.sdk_getTierName.argtypes = []
+        self.lib.sdk_getTierName.restype = ctypes.c_char_p
+
+        self.lib.sdk_getAppServerName.argtypes = []
+        self.lib.sdk_getAppServerName.restype = ctypes.c_char_p
+
+        self.lib.sdk_getAppName.argtypes = []
+        self.lib.sdk_getAppName.restype = ctypes.c_char_p
+
+        self.lib.sdk_getCurrentTR.argtypes = []
+        self.lib.sdk_getCurrentTR.restype = ctypes.c_int
+
+
+
+
+        self.lib.sdk_getBTName.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p]
+        self.lib.sdk_getBTName.restype = ctypes.POINTER(ctypes.c_char_p)
+        
+        self.lib.sdk_getBciInstrSessionPctVal.argtypes=[]
+        self.lib.sdk_getBciInstrSessionPctVal.restype=ctypes.c_int
+
+
+
+        self.lib.sdk_UpdateBTCounters.argtypes=[ctypes.c_char_p, ctypes.c_int, ctypes.c_double, ctypes.c_long, ctypes.c_double, ctypes.c_double, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_long)]
+        self.lib.sdk_UpdateBTCounters.restype=ctypes.c_void_p
+
+        self.lib.sdk_UpdateIPCounters.argtypes = [ctypes.c_char_p, ctypes.c_double, ctypes.c_long, ctypes.c_double, ctypes.c_double, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_long), ctypes.c_char_p, ctypes.c_char_p]
+        self.lib.sdk_UpdateIPCounters.restype = ctypes.c_void_p
+
+
+        self.lib.sdk_settingBackendNameOtel.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
+        self.lib.sdk_settingBackendNameOtel.restype = ctypes.POINTER(ctypes.c_char_p)
+
+
+        self.lib.sdk_getTierCallOutOtel.argtypes = [ctypes.c_char_p, ctypes.c_longlong]
+        self.lib.sdk_getTierCallOutOtel.restype = ctypes.POINTER(ctypes.c_char_p)
+
+        self.lib.sdk_setTierCallOutOtel.argtypes = [ctypes.c_char_p]
+        self.lib.sdk_setTierCallOutOtel.restype = ctypes.c_void_p
+
+        self.lib.sdk_UpdateIPCountersUsingSpan.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_double, ctypes.c_int]
+        self.lib.sdk_UpdateIPCountersUsingSpan.restype = ctypes.c_void_p
+
+        
+        self.lib.sdk_getDelayAtCurrentInstant.argtypes = [ctypes.c_long, ctypes.c_long, ctypes.c_long, ctypes.c_long, ctypes.c_long]
+        self.lib.sdk_getDelayAtCurrentInstant.restype = None
+
+
+
+
+
+        # self.lib.register_AI_end_callback.argtypes = [ctypes.c_char_p]
+
+        #self.lib.getDelayAtCurrentInstant.argtypes = [ctypes.c_long, ctypes.c_long, ctypes.c_long, ctypes.c_long, ctypes.c_long]
+
+        ################
+        # CALLBACKS
+        ################
+
+        CB_FTYPE_DOUBLE_DOUBLE = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_int, ctypes.c_longlong,
+                                                  ctypes.c_longlong, ctypes.c_char_p)
+        self.c_startaisession = CB_FTYPE_DOUBLE_DOUBLE(self.startaisession)
+
+        ai_end_ftype = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_char_p)
+        self.c_endaisession = ai_end_ftype(self.endaisessioncc)
+
+        ftype_autodiscovery = ctypes.CFUNCTYPE(ctypes.c_void_p,  # Return type 
+                                               ctypes.POINTER(ctypes.c_char_p),  # methodFiltersPatternList
+                                               ctypes.POINTER(ctypes.c_char_p),  # classFiltersPatternList
+                                               ctypes.c_int,     # methodListLength
+                                               ctypes.c_int)     # classListLength
+
+
+        self.autodiscovery_c = ftype_autodiscovery(self.autodiscovery_py)
+
+        ftype_exception_stack_depth = ctypes.CFUNCTYPE(ctypes.c_void_p,  # Return type
+                                                       ctypes.c_int)     # Stack Depth
+
+        self.exception_stack_depth_c=ftype_exception_stack_depth(self.exception_stack_depth_py)
+
+        thd_ftype = ctypes.CFUNCTYPE(ctypes.c_char_p)
+        self.c_thd = thd_ftype(self.thd)
+
+        ftype_nd_cookie = ctypes.CFUNCTYPE(ctypes.c_void_p,    # Pointer to Python Function
+                                           ctypes.c_char_p,    # char *name
+                                           ctypes.c_char_p,    # char *domain
+                                           ctypes.c_int,       # int rheader
+                                           ctypes.c_int,       # int mpos
+                                           ctypes.c_longlong)  # long long int duration
+
+        self.nd_cookie_callback_c = ftype_nd_cookie(self.nd_cookie_callback_py)
+
+        ftype_nd_gc_status = ctypes.CFUNCTYPE(ctypes.c_void_p, # Pointer to Python Function
+                                              ctypes.c_int)    # int status
+
+        self.nd_gcstatus_callback_c = ftype_nd_gc_status(self.nd_gcstatus_callback_py)
+
+        ftype_nd_python_thread_status = ctypes.CFUNCTYPE(ctypes.c_void_p,  # Pointer to Python Function
+                                                         ctypes.c_int)     # int status
+        self.nd_pythread_status_callback_c = ftype_nd_python_thread_status(self.nd_pythread_status_callback_py)
+
+        thread_dump_ftype = ctypes.CFUNCTYPE(ctypes.c_char_p)
+        self.nd_thread_dump_callback_c = thread_dump_ftype(self.nd_thread_dump_callback_py)
+        
+        ftype_nv_cookie = ctypes.CFUNCTYPE(ctypes.c_void_p,    # Pointer to Python Function
+                                           ctypes.c_char_p)    # char *name
+
+        self.nv_cookie_callback_c = ftype_nv_cookie(self.nv_cookie_callback_py)
+
+        
+        ftype_havoc_message = ctypes.CFUNCTYPE(ctypes.c_void_p,  # Return type
+                                               ctypes.c_char_p)  # Havoc Message
+
+        ftype_heap_dump = ctypes.CFUNCTYPE(ctypes.c_char_p)
+        self.heap_dump_c = ftype_heap_dump(self.heap_dump_py)
+
+        self.receive_havoc_message_c = ftype_havoc_message(self.receive_havoc_message_py)
+
+       
+        self.logger.info("load common lib -> lib.obj :{0}".format(self.lib))
+
+        ftype_test_status_callback = ctypes.CFUNCTYPE(ctypes.c_void_p,      # Return type
+                                                      ctypes.c_int)         # Test Status
+
+        self.test_status_callback_c = ftype_test_status_callback(self.test_status_callback_py)
+
+        ftype_instr_prof_callback = ctypes.CFUNCTYPE(ctypes.c_void_p,     # Return type
+                                                     ctypes.c_char_p)     # Test Status
+
+        self.instr_prof_callback_c = ftype_instr_prof_callback(self.instr_prof_callback_py)
+
+        
+        return self.lib
+
+    ###############################
+    # GET VALUES FROM COMMONLIB
+    ###############################
+
+    def sdk_getNDSessionCookie(self, bt):
+        if not self.get_current_bt():
+            return None
+        nd_cookie_value = self.lib.sdk_getNDSessionCookie(bt)
+        nd_cookie_value_py = ctypes.cast(nd_cookie_value, ctypes.c_char_p).value
+        self.lib.sdk_free_memory(nd_cookie_value)
+        return nd_cookie_value_py
+
+    def get_nd_header(self, bt, backend_name, unique_id):
+        if not self.get_current_bt():
+            return None
+        backend_name_c = create_string_buffer(get_utf8_bytes(backend_name))
+        header = self.lib.get_custom_nd_header(ctypes.c_void_p(bt), backend_name_c, ctypes.c_longlong(unique_id))
+        del backend_name_c
+        return header
+
+    def get_trace_headers(self, bt):
+        if not self.get_current_bt():
+            return None, None
+
+        traceparent = self.lib.sdk_get_otl_traceparent(bt)
+        traceparent_py = ctypes.cast(traceparent, ctypes.c_char_p).value
+        self.lib.sdk_free_memory(traceparent)
+
+        tracestate = self.lib.sdk_get_otl_tracestate(bt)
+        tracestate_py = ctypes.cast(tracestate, ctypes.c_char_p).value
+        self.lib.sdk_free_memory(tracestate)
+
+        return traceparent_py, tracestate_py
+
+    def sdk_getTopoFpStr(self, bt):
+        if not self.get_current_bt():
+            return None
+        topo = None
+        topo_py = None
+        if bt:
+            topo = self.lib.sdk_getTopoFpStr(bt)
+            topo_py = ctypes.cast(topo, ctypes.c_char_p).value
+            self.lib.sdk_free_memory(topo)
+            if topo_py:
+                topo_py = topo_py.decode()
+        return topo_py
+
+    def sdk_get_propagation_header(self,bt):
+        if not self.get_current_bt():
+            return None
+        prop_headers = self.lib.sdk_get_propagation_header(bt)
+        prop_headers_py = ctypes.cast(prop_headers, ctypes.c_char_p).value
+        self.lib.sdk_free_memory(prop_headers)
+        return prop_headers_py
+
+    def get_nd_build(self):
+        return self.lib.sdk_getNdBuild().decode()
+
+    def get_nf_status(self):
+        nf_enabled = self.lib.sdk_getNFStatus()
+        if nf_enabled == 1:
+            self.nf_enabled = True
+        elif nf_enabled == 0:
+            self.nf_enabled = False
+
+    def get_app_name(self):
+        app_name = self.lib.sdk_getAppName()
+        app_name_py = ctypes.cast(app_name, ctypes.c_char_p).value
+        del app_name
+        return app_name_py
+
+    def get_tier_name(self):
+        tier = self.lib.sdk_getTierName()
+        tier_py = ctypes.cast(tier, ctypes.c_char_p).value
+        del tier
+        return tier_py
+
+
+    def get_app_server_name(self):
+        app_server = self.lib.sdk_getAppServerName()
+
+        app_server_py = ctypes.cast(app_server, ctypes.c_char_p).value
+        del app_server
+
+        return app_server_py
+
+    def get_current_tr(self):
+        TR = self.lib.sdk_getCurrentTR()
+        return TR
+
+    def getBciInstrSessionPctVal(self):
+        BciInstrSessionPctVal= self.lib.sdk_getBciInstrSessionPctVal()
+        return BciInstrSessionPctVal
+
+    def get_bt_name(self, url, parameters, btHeaderValue, httpMethod):
+        try:
+            bt_name = self.lib.sdk_getBTName(url, parameters, btHeaderValue, httpMethod)
+
+            bt_name_py = ctypes.cast(bt_name, ctypes.c_char_p).value
+            if bt_name:
+                self.lib.sdk_free_memory(bt_name)
+
+            return bt_name_py
+        except Exception as e:
+            self.logger.exception("Exception in get_bt_name: {}".format(e))
+            return None
+    
+
+    def get_tier_callout(self, backend_name, thread_id):
+        backend_name_b = backend_name.encode('utf-8') if isinstance(backend_name, str) else backend_name
+        result = self.lib.sdk_getTierCallOutOtel(backend_name_b, thread_id)
+        # Decode the native bridge result into a Python header value.
+        tiercallout_py = ctypes.cast(result, ctypes.c_char_p).value
+
+        if result:
+            self.lib.sdk_free_memory(result)
+
+        return tiercallout_py
+
+    
+    def setting_backend_name_otel(self, backendName, type_):
+        try:
+            # Convert Python str to byte
+            backendName_b = backendName.encode('utf-8') if backendName else None
+            type_b = type_.encode('utf-8') if type_ else None
+            # Call C function
+            result = self.lib.sdk_settingBackendNameOtel(backendName_b, type_b)
+            result_py = ctypes.cast(result,ctypes.c_char_p).value
+            # Free memory from C side
+            if result:
+                self.lib.sdk_free_memory(result)
+
+            return result_py
+        except Exception as e:
+            self.logger.exception("Exception in setting_backend_name_otel: {}".format(e))
+            return None
+
+
+    def UpdateBTCounters(self, bt_name, status_code, sum_value, count, min_val, max_val, boundaries, boundaries_len, bucketsCounts):
+    # Convert bt_name to bytes (C expects char*)
+        bt_name_bytes = bt_name.encode('utf-8')
+
+    # Convert boundaries to ctypes array
+        boundaries_array = (ctypes.c_double * boundaries_len)(*boundaries)
+
+    # Convert bucketsCounts to ctypes array
+        buckets_array = (ctypes.c_long * (boundaries_len+1))(*bucketsCounts)
+
+    # Call the C function
+        BT_Counters = self.lib.sdk_UpdateBTCounters(
+            bt_name_bytes,
+            status_code,
+            ctypes.c_double(sum_value),
+            ctypes.c_long(count),
+            ctypes.c_double(min_val),
+            ctypes.c_double(max_val),
+            boundaries_array,
+            ctypes.c_int(boundaries_len),
+            buckets_array
+        )
+
+        return BT_Counters
+
+    def UpdateIPCounters(self, backend_name, sum_value, count, min_val, max_val, boundaries, boundaries_len, bucketsCounts, type_str, dbtype_str):
+        backend_name_bytes = backend_name.encode('utf-8')
+        type_bytes = type_str.encode('utf-8')
+        dbtype_bytes = dbtype_str.encode('utf-8')
+        # Convert boundaries to ctypes array
+        boundaries_array = (ctypes.c_double * boundaries_len)(*boundaries)
+
+        # Convert bucketsCounts to ctypes array (length = boundaries_len + 1)
+        buckets_array = (ctypes.c_long * (boundaries_len + 1))(*bucketsCounts)
+
+        # Call the C function
+        IP_Counters = self.lib.sdk_UpdateIPCounters(
+            backend_name_bytes,
+            ctypes.c_double(sum_value),
+            ctypes.c_long(count),
+            ctypes.c_double(min_val),
+            ctypes.c_double(max_val),
+            boundaries_array,
+            ctypes.c_int(boundaries_len),
+            buckets_array,
+            type_bytes,
+            dbtype_bytes
+        )
+        
+
+        return IP_Counters
+
+    def set_tier_callout(self, value):
+        if isinstance(value, str):
+            value = value.encode()
+
+        # The setter restores inbound tier-callout state in the native bridge.
+        return self.lib.sdk_setTierCallOutOtel(value)
+    
+    def UpdateIPCountersUsingSpan(self, backend_name, type_str, dbtype_str, duration, status_code):
+        backend_name_bytes = backend_name.encode('utf-8')
+        type_bytes = type_str.encode('utf-8')
+        dbtype_bytes = dbtype_str.encode('utf-8')
+        IP_Counters = self.lib.sdk_UpdateIPCountersUsingSpan(
+            backend_name_bytes,
+            type_bytes,
+            dbtype_bytes,
+            ctypes.c_double(duration),
+            ctypes.c_int(status_code)
+
+        )
+
+        return IP_Counters
+
+
+    #########################
+    # DUMP TO COMMONLIB
+    #########################
+
+    def dump_log_message(self, bt, logs):
+        if not self.get_current_bt():
+            return None
+
+        logs_c = create_string_buffer(get_utf8_bytes(logs))
+
+        resp = self.lib.sdk_dumpLogMessage(bt, logs_c)
+
+        del logs_c
+
+
+    ##########################
+    # REGISTER CALLBACKS
+    ##########################
+
+    def register_nd_cookie_callback(self):
+        self.lib.register_nd_cookie_callback(self.nd_cookie_callback_c)
+        #print("**** callback registered for ND cookie ****")
+
+    def gc_nd_status_callback(self):
+        self.lib.register_GC_status_for_agent(self.nd_gcstatus_callback_c)
+
+    def register_exception_stack_depth_callback(self):
+        self.lib.register_exception_depth_callback(self.exception_stack_depth_c)
+
+    def nd_pythread_status_callback(self):
+        self.lib.register_TH_status_for_agent(self.nd_pythread_status_callback_c)
+
+    def thread_dump_callback(self):
+        self.lib.register_thread_dump_callback(self.nd_thread_dump_callback_c)
+
+    def register_nv_cookie_callback(self):
+        self.lib.register_nv_cookie_callback(self.nv_cookie_callback_c)
+        #print("**** callback registered for NV cookie ****")
+
+    def ad_wrapper(self):
+        self.lib.register_AD_callback(self.autodiscovery_c)
+
+    def thd_wrapper(self):
+        self.lib.register_thread_dump_callback(self.c_thd)
+
+    def ai_wrapper_begin(self):
+        #print("************************ callback registered ********************************************")
+        self.lib.register_AI_start_callback(self.c_startaisession)
+
+    def ai_wrapper_end(self):
+        self.lib.register_AI_end_callback(self.c_endaisession)
+
+    def register_test_status_callback(self):
+        self.lib.register_test_status_for_agent(self.test_status_callback_c)
+
+    def register_instr_prof_callback(self):
+        self.lib.register_instr_prof_callback(self.instr_prof_callback_c)
+
+    def register_heap_dump_callback(self):
+        self.lib.register_heap_dump_callback(self.heap_dump_c)
+
+    def register_havoc_callback(self):
+        self.lib.register_havoc_msg_for_agent_callback_sdk(self.receive_havoc_message_c)
+
+    ##########################
+    # CALLBACK DEFINITIONS
+    ##########################
+
+    def common_sleep(self, havocStarttime, shootUpDuration, stableDuration, tumbleDuration, delayInSec):
+        self.lib.sdk_getDelayAtCurrentInstant(ctypes.c_long(int(havocStarttime)),
+                                              ctypes.c_long(int(shootUpDuration * 1000)),
+                                              ctypes.c_long(int(stableDuration * 1000)),
+                                              ctypes.c_long(int(tumbleDuration * 1000)),
+                                              ctypes.c_long(int(delayInSec)))
+
+    def thd(self):
+        print("INSIDE THD")
+        # dumpstacks()
+
+    def exception_stack_depth_py(self, stack_depth):
+        self.logger.debug("Stack depth callback called {}".format(stack_depth))
+        self.exception_stack_depth=stack_depth
+
+    def test_status_callback_py(self, test_status):
+        if test_status == 1:
+            self.test_running = True
+        elif test_status == 0:
+            self.test_running = False
+        self.logger.info("Test Running: {}".format(self.test_running))
+
+    def nd_cookie_callback_py(self, name, domain, rheader, mpos, duration):
+        self.logger.info(f"nd_cookie name {name} \ndomain {domain}\nrheader {rheader}\nmpos {mpos}\nduration {duration}")
+        if name:
+            self.nd_cookie_key = name.decode()
+        if not mpos:
+            self.nd_cookie_key = None
+            self.disable_nd_nv = True
+
+        self.header_in_response = rheader
+        self.cookie_method_position = mpos
+        if domain:
+            self.cookie_domain = domain.decode()
+
+
+
+    def nd_gcstatus_callback_py(self,status):
+        self.gc_run_status = status
+        if self.gc_run_status == 1:
+            if not self.gc_monitor_rt.is_running:
+                self.gc_monitor_rt.start()
+        elif self.gc_run_status == 0:
+            if self.gc_monitor_rt.is_running:
+                self.gc_monitor_rt.stop()
+
+    def nv_cookie_callback_py(self, name):
+        #print(f"nv_cookie name {name}")
+        if name:
+            self.nv_cookie_key = name.decode()
+
+    def nd_pythread_status_callback_py(self, status):
+        self.pythread_run_status = status
+        if self.pythread_run_status == 1:
+            if not self.thread_monitor_rt.is_running:
+                self.thread_monitor_rt.start()
+        elif self.pythread_run_status == 0:
+            if self.thread_monitor_rt.is_running:
+                self.thread_monitor_rt.stop()
+
+    def nd_thread_dump_callback_py(self):
+        build_details = self.get_nd_build()
+        dump_stack_str = dumpstacks(build_details)
+        try:
+            dump_str = bytes(dump_stack_str, 'utf-8')
+        except:
+            dump_str = bytes(dump_stack_str.encode("utf-8"))
+
+        return dump_str
+
+    def endaisessioncc(self, char):
+        print("INSIDE END AI SESSION")
+
+    def startaisession(self, istart, startTime, duration, sname):
+        # if not self.get_current_bt():
+            # return
+        self.logger.info("ai start")
+        #print(" IN startaisession", sname.decode('ascii'))
+        if sname:
+            wsgi.aiflagset(istart, startTime, duration, sname)
+            #pathd = "/opt/cavisson/netdiagnostics/logs/"
+            ndhome = os.environ.get('NDHOME')
+            pathd = ndhome + '/python/logs/'
+            filenameai1 = str(self.sname.decode('ascii')) + ".txt"
+            aifile_to_open_to_d = os.path.join(pathd, filenameai1)
+            self.lib.handleUploadDownload(bytes(aifile_to_open_to_d, 'utf-8'))
+        self.logger.info("ai end")
+
+
+    def autodiscovery_py(self, method_filters_pattern_list, class_filters_pattern_list,
+                         method_list_length, class_list_length):
+        # if not self.get_current_bt():
+            # return
+
+        self.logger.info("ad start")
+        if method_list_length > 0:
+            method_filter_list = []
+            for i in range(method_list_length):
+                method_filter_list.append(method_filters_pattern_list[i].decode())
+        else:
+            method_filter_list = None
+
+        if class_list_length > 0:
+            class_filter_list = []
+            for i in range(class_list_length):
+                class_filter_list.append(class_filters_pattern_list[i].decode())
+        else:
+            class_filter_list = None
+
+        start_time = time.time()
+
+        try:  # Defensive check for failure of finder.run_script(sys.argv[0])
+            output_from_ad, num_of_modules, num_of_methods = find(method_filter_list, class_filter_list)
+        except Exception as e:
+            self.logger.error("Unable to auto-discover methods, please try again")
+            self.logger.debug(e)
+            output_from_ad = "default||default"
+            num_of_modules = 1
+            num_of_methods = 1
+
+        end_time = time.time()
+        total_time = end_time - start_time
+        ad_summary =  "totalTimeTaken={} ms;totalModules={};totalMethods={};\n".format(total_time, num_of_modules, num_of_methods)
+
+        output_from_ad_c = create_string_buffer(get_utf8_bytes(output_from_ad))
+        self.lib.wraphandleMessageForDiscovery(output_from_ad_c)
+
+        # Metadata must be sent before the "totalTimeTaken=...;" summary line below - that line is
+        # treated by the collector as the terminal response for this discovery request, so anything
+        # sent after it would never be attached to the .adr output. Defensive try/except so a
+        # metadata-collection failure never breaks the rest of auto-discovery.
+        try:
+            metadata_block_c = create_string_buffer(get_utf8_bytes(build_metadata_block(self)))
+            self.lib.wraphandleMessageForDiscovery(metadata_block_c)
+            del metadata_block_c
+        except Exception as e:
+            self.logger.exception("Error building/sending auto-discovery metadata block")
+
+        self.logger.info("ad sending summary")
+        ad_summary_c = create_string_buffer(get_utf8_bytes(ad_summary))
+        self.lib.wraphandleMessageForDiscovery(ad_summary_c)
+        del output_from_ad_c, ad_summary_c
+
+
+    def instr_prof_callback_py(self, instr_prof):
+        self.logger.info("Received Instrumentation Profile Callback")
+        self.logger.debug("Instr Prof {}".format(instr_prof))
+
+        try:
+            if instr_prof:
+                instr_prof_str = instr_prof.decode()
+
+                instr_prof_str_split = instr_prof_str.split("\n\n\n")
+
+                instr_prof_list = []
+
+                for profile in instr_prof_str_split:
+                    profile = profile.strip()
+                    if profile[0] == "[" and profile[-1] != "]":
+                        profile += "}]"
+                    instr_prof_list.append(profile)
+
+                new_instr_prof_str = "\n\n\n".join(instr_prof_list)
+
+
+                from pythonagent import config
+                pythonagent_path = os.path.dirname(config.__file__)
+                instr_prof_path = os.path.join(pythonagent_path, 'agent/internal/instrprof.json')
+                try:
+                    with open(instr_prof_path, "w+") as outfile:
+                        outfile.write(new_instr_prof_str)
+
+                except:
+                    self.logger.exception("Unable to write instrprof.json")
+
+                import pythonagent.agent as agent
+                agent.bootstrap(self)
+
+
+        except Exception as e:
+            self.logger.exception("Error in Instrumentation Profile Callback")
+
+
+    def receive_havoc_message_py(self, havoc_message):
+        self.logger.warning("Havoc callback called{}".format(havoc_message))
+        body, header_dict = process_raw_havoc_message(havoc_message.decode(), self.cav_env)
+        self.logger.debug("Header:".format(header_dict))
+        self.logger.debug("Body:".format(body))
+        self.havoc_monitor.parse_nethavoc_config(body, header_dict)
+
+    def send_havoc_response(self, header_str):
+        if self.cav_env == "NATIVE":
+            self.logger.warning("Havoc Response from Agent{}".format(header_str))
+            header_c = create_string_buffer(get_utf8_bytes(header_str))
+            self.lib.havoc_response_from_agent(header_c)
+            del header_c
+        elif self.cav_env == "AWS_LAMBDA":
+            udp.havoc_message(self, header_str)
+
+
+    #############################
+    # REPEATER TIMER FUNCTIONS
+    #############################
+
+    def send_gc_report(self, record_string):
+
+        record_string_c = create_string_buffer(get_utf8_bytes(record_string))
+
+        self.lib.sendGCReport(ctypes.c_int(77),record_string_c)
+        del record_string_c
+
+    def heap_gc_stats(self):
+        try:
+            RSS = get_rss_bytes()
+            x = gc.get_count()
+            y = gc.get_stats()
+            record_str = ""
+            record_str += str(int(RSS / 1000)) + ' '
+            for i in range(0, 3):
+                record_str += str(x[i]) + ' '
+                record_str += str(y[i]['collected']) + ' '
+                record_str += str(y[i]['uncollectable']) + ' '
+                if i < 2:
+                    record_str += str(y[i]['collections']) + ' '
+                else:
+                    record_str += str(y[i]['collections'])
+            self.send_gc_report(record_str)
+        except Exception as e:
+            self.logger.info("Exception on heap_gc_stats : {}".format(e))
+
+
+    def send_thread_report(self, record_string):
+        record_string_c = create_string_buffer(get_utf8_bytes(record_string))
+
+        self.lib.sendGCReport(ctypes.c_int(83), record_string_c)
+        del record_string_c
+
+    def thread_stats(self):
+        thread_details_ = threading.enumerate()
+        total_threads = str(len(thread_details_))
+        thread_status_dict = {'deamon': 0, 'notdeamon': 0,}
+        for thread in thread_details_:
+
+            if thread.daemon == True:
+                thread_status_dict['deamon'] += 1
+
+            if thread.daemon == False:
+                thread_status_dict['notdeamon'] += 1
+
+        thread_stats_string = (total_threads + " " +
+                               str(thread_status_dict['deamon']) + " " +
+                               str(thread_status_dict['notdeamon']))
+
+        self.send_thread_report(thread_stats_string)
+
+    ######################
+    # CORE SDK FUNCTIONS
+    ######################
+
+    # @profile
+    def sdk_init_native(self):
+        self.logger.info("sdk_init -> lib.obj :{0}".format(self.lib))
+        agent_type = bytes("python", 'utf-8')
+        log_file_name = bytes("cavlib", 'utf-8')
+        version_string = "python" + platform.python_version()
+
+        """
+        appname = None
+        for item in sys.argv:
+            if item.endswith(".py"):
+                appname = item.split("/")[-1]
+                appname = appname[:-3]  # Remove .py extension
+                break
+
+        if not appname:
+            appname = "wsgi"
+        """
+
+        appname = "Python"
+
+
+
+        version_string_c = create_string_buffer(get_utf8_bytes(version_string))
+        appname_string_c = create_string_buffer(get_utf8_bytes(appname))
+        self.lib.nd_init2(agent_type, log_file_name, version_string_c, appname_string_c)
+
+        del version_string_c
+        del appname_string_c
+
+    def sdk_init(self):
+        if self.cav_env == "NATIVE":
+            self.sdk_init_native()
+        elif self.cav_env == "AWS_LAMBDA":
+            udp.sdk_init(self)
+
+    def sdk_free_native(self):
+        self.logger.info("sdk_free -> lib.obj :{0}".format(self.lib))
+        self.lib.nd_free()
+
+    def sdk_free(self):
+        if self.cav_env == "NATIVE":
+            self.sdk_free_native()
+        elif self.cav_env == "AWS_LAMBDA":
+            udp.sdk_free()
+
+    def method_entry_native(self, bt, method, start_time):
+        if not self.get_current_bt():
+            return
+        self.logger.info("method entry: {}".format(method))
+        method_c = create_string_buffer(get_utf8_bytes(method))
+        self.lib.nd_method_entry(bt, method_c, ctypes.c_longlong(start_time))
+        del method_c
+
+
+    def method_entry(self, bt, method, start_time=0):
+        if self.cav_env == "NATIVE":
+            self.method_entry_native(bt, method, start_time)
+        elif self.cav_env == "AWS_LAMBDA":
+            udp.method_entry(self, bt, method, "NA", "NA")
+
+    #@profile
+    def method_exit_native(self, bt, method, duration, cpu_time, method_start_time):
+        if not self.get_current_bt():
+            return
+        self.logger.info("method exit: {}".format(method))
+        method_bytes = get_utf8_bytes(str(method))
+        str_span_c = ctypes.POINTER(ctypes.c_char_p)()
+        method_c = create_string_buffer(get_utf8_bytes(method))
+
+        self.lib.nd_method_exit(bt, method_c, ctypes.c_longlong(cpu_time), ctypes.c_longlong(duration), ctypes.c_longlong(method_start_time), ctypes.byref(str_span_c))
+
+        span_obj = ctypes.c_char_p.from_buffer(str_span_c)
+        self.dump_span(span_obj)
+        self.lib.sdk_free_memory(str_span_c)
+        del span_obj, method_c
+
+    def method_exit(self, bt, method, duration, cpu_time=0, method_start_time=0):
+        if self.cav_env == "NATIVE":
+            self.method_exit_native(bt, method, duration, cpu_time, method_start_time)
+        elif self.cav_env == "AWS_LAMBDA":
+            udp.method_exit(self, bt, method, "NA", 0, duration)
+
+    # @profile
+    def start_business_transaction_native(self, bt_name, correlation_header, nd_cookie, nv_cookie, bt_header_value, fp_instance):
+        start_time = get_current_timestamp_in_us()
+        self.unset_current_bt()
+        if os.environ['nd_init_done'] == '0':
+            self.start()
+            #print("start_business_transaction ->")
+            #self.logger.debug(" start_business_transaction -> lib.obj {0}:".format(self.lib))
+
+        self.logger.info(" start_business_transaction -> bt_name {0}:".format(bt_name))
+        bt_name_c = create_string_buffer(get_utf8_bytes(bt_name))
+        correlation_header_c = create_string_buffer(get_utf8_bytes(correlation_header))
+
+
+        if not fp_instance:
+            self.get_transaction_context().flow_path_id = generate_flow_path_id()
+        else:
+            self.get_transaction_context().flow_path_id = fp_instance
+
+
+        nd_cookie_c = create_string_buffer(get_utf8_bytes(nd_cookie))
+        nv_cookie_c = create_string_buffer(get_utf8_bytes(nv_cookie))
+        bt_header_value_c = create_string_buffer(get_utf8_bytes(bt_header_value))
+        
+        flow_path_id = self.get_transaction_context().flow_path_id
+        flow_path_id_c =  create_string_buffer(get_utf8_bytes(flow_path_id))
+        start_time_c = ctypes.c_longlong(start_time)
+
+        bt = self.lib.nd_bt_begin(bt_name_c, correlation_header_c, nd_cookie_c, nv_cookie_c, bt_header_value_c, flow_path_id_c, start_time_c)
+
+        del start_time_c, bt_header_value_c, nd_cookie, nv_cookie, bt_name_c, correlation_header_c
+
+
+        if not bt:
+            self.logger.warning("BT is None. Either Test Run is stopped or Connection is broken")
+        #self.logger.info("bt datatype : {0}".format(type(bt)))
+        #print("btname value: {0}".format(btname))
+        # print('-----------------\nCurrent heap memory stack for BT: ',bt_name,' is : ',hpy().heap())
+        self.active_bts.add(bt)
+        self.set_current_bt(bt)
+        #print("BT value of this txn: ", bt)
+        return bt
+
+
+    def inbound_havoc_delay_otel(self, req_url, bt_name=None):
+        # Apply configured inbound service delay during OTel instrumentation flow.
+        # req_url is the request URL/path used for havoc matching; bt_name is optional
+        # for backward-compatible OTel callers while ndotel is migrated.
+        try:
+            self.havoc_monitor.apply_inbound_service_delay(req_url, bt_name)
+        except Exception as e:
+            # Keep OTel span processing aligned with the existing BT path:
+            # havoc config/load issues should not break the request.
+            print(e)
+            pass
+
+    def inbound_havoc_failure_otel(self, req_url, bt_name=None):
+        self.havoc_monitor.apply_inbound_service_failure(req_url, bt_name)
+
+    def outbound_havoc_delay_otel(
+        self,
+        req_hostname,
+        backend_name=None,
+        req_url=None,
+        bt_name=None,
+    ):
+        # Apply configured outbound service delay during OTel instrumentation flow.
+        # req_hostname is used for host matching; backend_name, req_url and bt_name
+        # are optional for backward-compatible OTel callers while ndotel is migrated.
+        try:
+            self.havoc_monitor.apply_outbound_service_delay(
+                req_hostname,
+                backend_name,
+                req_url,
+                bt_name,
+            )
+        except Exception as e:
+            print(e)
+            pass
+    
+    def outbound_havoc_failure_otel(
+        self,
+        req_hostname,
+        backend_name=None,
+        req_url=None,
+        bt_name=None,
+    ):
+        self.havoc_monitor.apply_outbound_service_failure(
+            req_hostname,
+            backend_name,
+            req_url,
+            bt_name,
+        )
+    def start_business_transaction(self, urlinfo, correlation_header, nd_cookie=None, nv_cookie=None, bt_header_value=None, fp_instance=None):
+        bt = None
+        btname = urlinfo
+        context = self.get_transaction_context()
+        if context is None:
+            context = TransactionContext()
+            self.set_transaction_context(context)
+
+        if self.cav_env == "NATIVE":
+            bt = self.start_business_transaction_native(urlinfo, correlation_header, nd_cookie, nv_cookie, bt_header_value, fp_instance)
+            fp_topo_val = self.sdk_getTopoFpStr(bt)
+
+            self.get_transaction_context().fp_topo = fp_topo_val
+            self.get_transaction_context().url_path = str(urlinfo).split("|", 1)[0]
+        elif self.cav_env == "AWS_LAMBDA":
+            bt = udp.start_business_transaction(self, urlinfo, correlation_header)
+
+        try:
+            if self.cav_env == "NATIVE":
+                url, http_method = str(urlinfo).rsplit("|", 1) if "|" in str(urlinfo) else (urlinfo, "")
+                btname_value = self.get_bt_name(
+                    get_utf8_bytes(url),
+                    get_utf8_bytes(""),
+                    get_utf8_bytes(bt_header_value or ""),
+                    get_utf8_bytes(http_method)
+                )
+                if btname_value:
+                    btname = btname_value.decode() if isinstance(btname_value, bytes) else btname_value
+        except Exception as e:
+            self.logger.exception("Unable to get BT name from SDK: {}".format(e))
+
+        if self.get_transaction_context():
+            self.get_transaction_context().btname = btname
+
+        try:
+            self.havoc_monitor.apply_inbound_service_delay(urlinfo, btname)
+        except Exception as e:
+            # Will fail first time
+            self.logger.exception("apply_inbound_service_delay exception: {}".format(e))
+            pass
+
+        return bt
+
+    # @profile
+    def end_business_transaction_native(self, bt, cpu_time):
+        end_time = get_current_timestamp_in_us()
+        #print("end_business_transaction--> BT: ", bt)
+        if not self.get_current_bt():
+            return None
+
+        self.logger.info('At end_business_transaction bt value is {0}'.format(bt))
+        statuscode = self.get_current_status_code()
+        if statuscode:
+            c_statuscode = ctypes.c_int(statuscode)
+        else:
+            c_statuscode = ctypes.c_int(200)
+        str_span_c = ctypes.POINTER(ctypes.c_char_p)()
+        end_time_c = ctypes.c_longlong(end_time)
+        rc = self.lib.nd_bt_end(bt, c_statuscode, ctypes.c_int(0), end_time_c, ctypes.c_longlong(cpu_time), ctypes.byref(str_span_c))
+
+        span_obj = ctypes.c_char_p.from_buffer(str_span_c)
+        self.dump_span(span_obj)
+        self.lib.sdk_free_memory(str_span_c)
+        # self.lib.sdk_free_memory(bt)
+
+        del span_obj
+        self.logger.info("nd_bt_end return value:  {0}".format(int(rc)))
+        #self.unset_current_bt()
+        self.unset_current_status_code()
+        self.active_bts.discard(bt)
+        return int(rc)
+
+    def end_business_transaction(self, bt, cpu_time):
+        if self.cav_env == "NATIVE":
+            rc = self.end_business_transaction_native(bt, cpu_time)
+        elif self.cav_env == "AWS_LAMBDA":
+            rc = udp.end_business_transaction(self, bt)
+        if self.get_transaction_context():
+            self.get_transaction_context().havoc_applied = False
+        context_object = self.get_transaction_context()
+        del context_object
+        if sys.version_info >= (3, 7, 0):
+            self.context_provider.reset()
+        else:
+            self.transaction_context.pop(get_ident(), None)
+
+        return rc
+
+    def dump_span(self, span_obj):
+        if not span_obj:
+            return
+        span_value = span_obj.value.decode()
+        for x in self.application_loggers:
+            #print("\n inside for", x.name, "\n")
+            if x.name != "werkzeug" and not x.name.startswith("pythonagent"):
+                #print("\n inside if", x.name, "\n")
+                x.info(span_value)
+
+    """
+    #@profile
+    def store_business_transaction_native(self, bt, unique_bt_id):
+        self.logger.info('lib variable in store business txn: {0}'.format(self.lib))
+        # unique_bt_id_bytes = bytes(unique_bt_id, 'utf-8')
+        try:
+            unique_bt_id_bytes = bytes(unique_bt_id, 'utf-8')
+        except:
+            unique_bt_id_bytes = bytes(unique_bt_id.encode("utf-8"))
+
+        bt_id_c = ctypes.c_char_p(unique_bt_id_bytes)
+        self.lib.nd_bt_store(bt, bt_id_c)
+
+
+    def store_business_transaction(self, bt, unique_bt_id):
+        if self.cav_env == "NATIVE":
+            self.store_business_transaction_native(bt, unique_bt_id)
+        elif self.cav_env == "AWS_LAMBDA":
+            udp.store_business_transaction(bt, unique_bt_id)
+    """
+
+    def db_call_begin_native(self, method_name, bt,  db_host, db_query, query_parameters, db_start_time):
+        if not self.get_current_bt():
+            return None
+        self.logger.info("db call begin: db_host {} db_query {}".format(db_host, db_query))
+
+        db_host_bytes = get_utf8_bytes(str(db_host))
+        db_query_c = create_string_buffer(get_utf8_bytes(db_query))
+
+        if not query_parameters:
+            query_parameters = ""
+
+        db_query_parameters_c = create_string_buffer(get_utf8_bytes(query_parameters))
+        method_name_c = create_string_buffer(get_utf8_bytes(method_name))
+
+        ip_handle = self.lib.nd_ip_db_callout_begin(method_name_c, bt, db_query_c,
+                                                    db_query_parameters_c, ctypes.c_longlong(db_start_time))
+
+        del method_name_c, db_query_parameters_c, db_query_c
+        return ip_handle
+
+    def db_call_begin(self, method_name, bt, db_host, hostinfo, query_parameters=None, db_start_time=None):
+        #db_host = "NA|" + str(db_host) + "|NA|NA|NA|NA|NA|NA|NA|NA|NA|NA"
+        ip_handle = 0
+        if self.cav_env == "NATIVE":
+            ip_handle = self.db_call_begin_native(method_name, bt, db_host, hostinfo, query_parameters, db_start_time)
+        elif self.cav_env == "AWS_LAMBDA":
+            entry_point_fqm = self.get_transaction_context().entry_point_fqm
+            if not query_parameters:
+                query_parameters = "NA"
+            udp.method_entry(self, bt, entry_point_fqm, hostinfo, query_parameters)
+
+        backend_name = None
+        try:
+            if self.cav_env == "NATIVE":
+                context = self.get_transaction_context()
+                host_str = context.host_str if context and context.host_str else db_host
+                backend_name_value = self.setting_backend_name_otel(host_str, "DB")
+                if backend_name_value:
+                    backend_name = backend_name_value.decode() if isinstance(backend_name_value, bytes) else backend_name_value
+        except Exception as e:
+            self.logger.exception("Unable to get DB backend name from SDK: {}".format(e))
+
+        context = self.get_transaction_context()
+        btname = context.btname if context else None
+        req_url = context.url_path if context else None
+        self.havoc_monitor.apply_outbound_service_delay(hostinfo, backend_name, req_url, btname)
+
+        return ip_handle
+
+    #@profile    #@staticmethod
+    def db_call_end_native(self, bt, ip_handle, duration, db_start_time, entry_point_fqm, host_str, _status_code):
+        if not self.get_current_bt():
+            return None
+        str_span_c = ctypes.POINTER(ctypes.c_char_p)()
+
+        if not entry_point_fqm:
+            method_name = get_utf8_bytes("NA")
+        else:
+            method_name = get_utf8_bytes(entry_point_fqm)
+
+        if not host_str:
+            host_name = get_utf8_bytes("NA|NA|NA|NA|NA|NA|NA|NA|NA|NA|NA")
+        else:
+            host_name = get_utf8_bytes(host_str)
+
+        self.logger.info("db call end: db_host {} status {}".format(host_name, _status_code))
+
+        method_name_c = create_string_buffer(method_name)
+        host_name_c = create_string_buffer(host_name)
+
+        rc = self.lib.nd_ip_db_callout_end(method_name_c, host_name_c, bt, ctypes.c_int(_status_code),ctypes.c_longlong(duration), ctypes.c_longlong(db_start_time), ctypes.byref(str_span_c))
+        span_obj = ctypes.c_char_p.from_buffer(str_span_c)
+        self.dump_span(span_obj)
+        self.lib.sdk_free_memory(str_span_c)
+        # self.lib.sdk_free_memory(ip_handle)
+
+        del span_obj
+        del method_name_c, host_name_c
+        return int(rc)
+
+    def db_call_end(self, bt, ip_handle, duration, db_start_time, entry_point_fqm, host_str, status_code):
+        if self.cav_env == "NATIVE":
+            self.db_call_end_native(bt, ip_handle, duration, db_start_time, entry_point_fqm, host_str, status_code)
+        elif self.cav_env == "AWS_LAMBDA":
+            entry_point_fqm = self.get_transaction_context().entry_point_fqm
+            backend_header = self.get_transaction_context().host_str
+            status_code = self.get_transaction_context().status_code
+            udp.method_exit(self, bt, entry_point_fqm, backend_header, status_code, duration)
+
+    #@profile  #@staticmethod
+    def http_call_begin_native(self, bt, http_host, url, method_name, http_start_time):
+        if not self.get_current_bt():
+            return None
+        self.logger.info("http call begin: http_host {} url {}".format(http_host, url))
+        host_bytes = get_utf8_bytes(str(http_host))
+        url_c = create_string_buffer(get_utf8_bytes(url))
+        method_name_c = create_string_buffer(get_utf8_bytes(method_name))
+
+        handle = self.lib.nd_ip_http_callout_begin(method_name_c, bt, url_c, ctypes.c_longlong(http_start_time))
+
+        del url_c, method_name_c
+        return handle
+
+    def http_call_begin(self, bt, http_host, url, method_name, http_start_time=0):
+        if self.cav_env == "NATIVE":
+            handle = self.http_call_begin_native(bt, http_host, url, method_name, http_start_time)
+        elif self.cav_env == "AWS_LAMBDA":
+            handle = udp.method_entry(self, bt, method_name, http_host, url)
+
+        backend_name = None
+        try:
+            if self.cav_env == "NATIVE":
+                backend_name_value = self.setting_backend_name_otel(http_host, "HTTP")
+                if backend_name_value:
+                    backend_name = backend_name_value.decode() if isinstance(backend_name_value, bytes) else backend_name_value
+        except Exception as e:
+            self.logger.exception("Unable to get HTTP backend name from SDK: {}".format(e))
+
+        context = self.get_transaction_context()
+        btname = context.btname if context else None
+        req_url = context.url_path if context else None
+        self.havoc_monitor.apply_outbound_service_delay(http_host, backend_name, req_url, btname)
+        return handle
+
+    #@profile #@staticmethod
+    def http_call_end_native(self, bt, ip_handle, method_name, backend_name, status_code, wall_time, http_start_time, callout_id):
+        if not self.get_current_bt():
+            return None
+        self.logger.info("http call end: backend_name {} status_code {}".format(backend_name, status_code))
+        str_span_c = ctypes.POINTER(ctypes.c_char_p)()
+        method_name_c = create_string_buffer(get_utf8_bytes(method_name))
+        backend_name_c = create_string_buffer(get_utf8_bytes(backend_name))
+        status_code_c = ctypes.c_int(status_code)
+        rc = self.lib.nd_ip_http_callout_end(method_name_c, backend_name_c, bt, status_code_c, ctypes.c_longlong(wall_time), ctypes.c_longlong(http_start_time), ctypes.byref(str_span_c), ctypes.c_longlong(callout_id))
+        span_obj = ctypes.c_char_p.from_buffer(str_span_c)
+        self.dump_span(span_obj)
+        self.lib.sdk_free_memory(str_span_c)
+        # self.lib.sdk_free_memory(ip_handle)
+
+        del span_obj
+        del method_name_c, backend_name_c
+        return int(rc)
+
+    def http_call_end(self, bt, ip_handle, method_name=None, backend_name=None, status_code=200, duration=0, http_start_time=0, callout_id=0):
+        if self.cav_env == "NATIVE":
+            self.http_call_end_native(bt, ip_handle, method_name, backend_name, status_code, duration, http_start_time, callout_id)
+        elif self.cav_env == "AWS_LAMBDA":
+            udp.method_exit(self, bt, method_name, backend_name, status_code, duration)
+
+    def http_req_resp_wrapper_native(self, bt, rbuffer, rtype, statuscode):
+        if not self.get_current_bt():
+            return
+
+        r_buffer_c = create_string_buffer(get_utf8_bytes(rbuffer))
+        r_type_c = create_string_buffer(get_utf8_bytes(rtype))
+
+        self.lib.sdk_httpReqRespWrapper(bt, r_buffer_c, r_type_c, statuscode)
+
+        del r_buffer_c, r_type_c
+
+    def http_req_resp_wrapper(self, bt, rbuffer, rtype, statuscode):
+        if self.cav_env == "NATIVE":
+            self.http_req_resp_wrapper_native(bt, rbuffer, rtype, statuscode)
+        elif self.cav_env == "AWS_LAMBDA":
+            udp.http_req_resp_wrapper(self, bt, rbuffer, rtype, statuscode)
+
+
+    def exception_dump_native(self, bt, mpp, starttime, excptnclsname, excptnmsg, throwingclsname,
+                        throwingmtdname, excptncause, excptnlineno, stacktrace, file_name):
+        if not self.get_current_bt():
+            return
+
+        stack_trace_c = create_string_buffer(get_utf8_bytes(stacktrace))
+        file_name_c = create_string_buffer(get_utf8_bytes(file_name))
+        exception_class_c = create_string_buffer(get_utf8_bytes(excptnclsname))
+        throwing_class_c = create_string_buffer(get_utf8_bytes(throwingclsname))
+        exception_message_c = create_string_buffer(get_utf8_bytes(excptnmsg))
+        throwing_method_c = create_string_buffer(get_utf8_bytes(throwingmtdname))
+        exception_cause_c = create_string_buffer(get_utf8_bytes(excptncause))
+
+        self.lib.getstacktracearray(bt,
+                                    stack_trace_c,
+                                    file_name_c,
+                                    exception_class_c,
+                                    throwing_class_c,
+                                    exception_message_c,
+                                    throwing_method_c,
+                                    excptnlineno,
+                                    exception_cause_c
+                                    )
+
+        del stack_trace_c, file_name_c, exception_class_c, throwing_class_c
+        del exception_message_c, throwing_method_c, exception_cause_c
+
+    def exceptiondump(self, bt, mpp, starttime, excptnclsname, excptnmsg, throwingclsname,
+                      throwingmtdname, excptncause, excptnlineno, stacktrace, file_name):
+        if self.cav_env == "NATIVE":
+            self.exception_dump_native(bt, mpp, starttime, excptnclsname, excptnmsg, throwingclsname,
+                                  throwingmtdname, excptncause, excptnlineno, stacktrace, file_name)
+        elif self.cav_env == "AWS_LAMBDA":
+            udp.exception_dump(self, bt, mpp, starttime, excptnclsname, excptnmsg, throwingclsname,
+                               throwingmtdname, excptncause, excptnlineno, stacktrace)
+
+    def heap_dump_py(self):
+        heap_string = create_heap_dump_muppy(self)
+        heap = bytes(heap_string.encode('utf-8'))
+        return heap
+
+    ######################
+    # UNUSED FUNCTIONS
+    ######################
+
+    def wait_for_start(self, timeout_ms=None):
+            """Wait for the agent to start and get configured.
+
+            Other Parameters
+            ----------------
+            timeout_ms : int, optional
+                The maximum time to wait for the agent to start and be configured
+                before returning.
+
+            Returns
+            -------
+            bool
+                Returns ``True`` if the agent is enabled after waiting, else
+                ``False``.
+
+            """
+            if timeout_ms is not None:
+                with self.timer() as timer:
+                    if self.proxy_control_svc is not None:
+                        self.proxy_control_svc.wait_for_start(timeout_ms=timeout_ms)
+
+                    if self.config_svc is not None:
+                        timeout_ms = max(0, timeout_ms - timer.duration_ms)
+                        self.config_svc.wait_for_config(timeout_ms=timeout_ms)
+
+                    if self.tx_svc is not None:
+                        timeout_ms = max(0, timeout_ms - timer.duration_ms)
+                        self.tx_svc.wait_for_start(timeout_ms=timeout_ms)
+            else:
+                self.proxy_control_svc.wait_for_start()
+                self.config_svc.wait_for_config()
+                self.tx_svc.wait_for_start()
+
+            return self.enabled
+
+
+    def wait_for_end(self, timeout_ms=None):
+        """Wait for the agent to finish reporting any pending BTs.
+
+        """
+        self.tx_svc.wait_for_end(timeout_ms=timeout_ms)
+
+    #@property
+    def enabled(self):
+            """Return true if the agent has started and is enabled.
+
+            """
+            return (
+                    self.nd_init_done and
+                    self.config_svc and self.config_svc.enabled and
+                    self.tx_svc)
+
+    ##################################
+    # TRANSACTION RELATED FUNCTIONS
+    ##################################
+
+    def get_current_bt(self):
+        """Get the currently active BT for the calling context.
+
+        The calling context is the active greenlet or thread, depending on
+        whether greenlets are in use or not. If the agent is disabled, or if
+        there is no active transaction for the calling context, None is
+        returned.
+
+        Returns
+        -------
+        bt : appdynamics.agent.core.bt.Transaction or None
+            the active business transaction (if any)
+
+        """
+        # if not self.enabled:
+        #    return None
+
+        if sys.version_info >= (3, 7, 0):
+            return self.currentbt_provider.active()
+        else:
+            return self.current_bts.get(get_ident(), None)
+
+    def set_current_bt(self, bt):
+        if bt:
+            if sys.version_info >= (3, 7, 0):
+                self.currentbt_provider.activate(bt)
+            else:
+                self.current_bts[get_ident()] = bt
+
+    def unset_current_bt(self):
+        if sys.version_info >= (3, 7, 0):
+            self.currentbt_provider.reset()
+        else:
+            self.current_bts.pop(get_ident(), None)
+
+    def get_current_status_code(self):
+        if sys.version_info >= (3, 7, 0):
+            return self.statuscode_provider.active()
+        else:
+            return self.current_status_code.get(get_ident(), None)
+
+    def set_current_status_code(self, status_code):
+        if status_code:
+            if sys.version_info >= (3, 7, 0):
+                self.statuscode_provider.activate(status_code)
+            else:
+                self.current_status_code[get_ident()] = status_code
+
+    def unset_current_status_code(self):
+        if sys.version_info >= (3, 7, 0):
+            self.statuscode_provider.reset()
+        else:
+            self.current_status_code.pop(get_ident(), None)
+
+    def set_transaction_context(self, context):
+        if context:
+            context.tier_name = self.tier_name
+            context.server_name = self.server_name
+            context.instance_name = self.instance_name
+            context.function_name = self.function_name
+            context.flow_path_id = generate_flow_path_id()
+            context.fp_topo = self.fp_topo
+
+            if sys.version_info >= (3, 7, 0):
+                self.context_provider.activate(context)
+            else:
+                self.transaction_context[get_ident()] = context
+
+    def get_transaction_context(self):
+        if sys.version_info >= (3, 7, 0):
+            context = self.context_provider.active()
+        else:
+            context = self.transaction_context.get(get_ident(), None)
+        return context
+
+    def reset_transaction_context(self):
+        if sys.version_info >= (3, 7, 0):
+            self.currentbt_provider.reset()
+            self.statuscode_provider.reset()
+            self.context_provider.reset()
+        else:
+            self.transaction_context.pop(get_ident(), None)
+            self.current_status_code.pop(get_ident(), None)
+            self.current_bts.pop(get_ident(), None)
+
+
+##################
+# UNUSED CLASSES
+##################
+
+
+class AgentNotStartedException(Exception):
+    pass
+
+
+class AgentNotReadyException(Exception):
+    pass
+
+
+class IgnoreTransaction(Exception):
+    pass
+
+