cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/probes/frameworks/test.py

@@ -0,0 +1,108 @@
+import json
+import os
+from datetime import datetime
+import platform
+import time
+import threading 
+import traceback
+import sys
+import multiprocessing
+
+
+
+#****creating a function for thread dump related variables ********
+
+def dumpstacks():
+ 
+    #vmName=my_system.system
+
+    my_system = platform.uname()
+    osName=my_system.system
+    osVersion=my_system.version
+    arch=my_system.machine
+    b =multiprocessing.cpu_count()
+    #l=psutil.getloadavg()
+    l=os.getloadavg()
+    res=sum(list(l))
+    u=round(res,2)/3
+    #ndbuild = sdk_getNdBuild()
+    #ndbuild := C.GoString(C.sdk_getNdBuild())
+    k=("Full thread dump Python Agent :- [ Dump Taken at : "+ datetime.now().strftime("%d/%m/%Y %H:%M:%S")+ " , Where BCIAgent build = \" 4.7.0 BUILD 93\" ")
+
+    #k=("Full thread dump BCI Agent :- [ Dump Taken at : "+ datetime.now().strftime("%d/%m/%Y %H:%M:%S")+ " , Where BCIAgent build =\" " + ndbuild + " \""  )
+    a=""
+
+    nid="0x0"
+    prio="5"
+    vendor=""
+    version=""   
+   
+    system_name = os.getenv('HOSTNAME')
+ #//****append the thread details into list(code)*****//    
+    code=[]
+    o=[]
+    al=[]
+    for thread in threading.enumerate():
+        
+        """ if thread.daemon == True:
+           s= 'wait'
+        elif (thread.is_alive() == True ):
+           s="Runnable"
+        else:
+           pass
+        #if not thread.isDaemon():
+           #s= 'wait'"""
+        o.append(thread.name)
+
+        if not thread.isDaemon():
+           s= 'wait'
+   
+        elif thread.is_alive() == True:
+           s='runable'
+        
+        elif thread.daemon == False:
+           s='waiting'
+        
+        elif threading.Lock != null :
+            s='locked'
+       
+        else:
+           pass
+        
+    i=0
+    for threadId, stack in sys._current_frames().items():
+               
+            code.extend(["\n\n'%s'" % o[i] + ' ' + "prio=%s"%prio + ' ' + "tid=%d"% threadId  + ' ' + "nid=%s"%nid + ' ' + "%s"%s+ ' ' + "\n" + "java.lang.Thread.State: %s "% s])
+            i=i+1
+               
+            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()))
+    print ("\n".join(code))
+
+#//*****in dictionary thread dump entry page details comming ********//
+
+    thread1_details = {"":k,"vmName":osName,"version":version ,"vendor":vendor , "osName":osName,"osVersion":osVersion,"arch":arch,"noOfProcessors":b,"SysLoadAvg":u,"deadlocked threads ":a }
+
+#//*********all details dump into logs location************//
+
+    def write_json(target_path, target_file, data):
+        if not os.path.exists(target_path):
+            try:
+                os.makedirs(target_path)
+            except Exception as e:
+                print(e)
+                raise
+        with open(os.path.join(target_path, target_file), 'w') as f:
+            json.dump(data, f)
+            f.write("\n".join((code)))
+
+
+    ndhome = os.environ.get('NDHOME')
+    write_file = ndhome + '/python/logs/'
+
+    write_json(write_file,
+               datetime.now().strftime('thread_dump_%H_%M_%d_%m_%Y.txt'), thread1_details)
+
+#dumpstacks()

pythonagent/agent/probes/frameworks/tornado_async_web.py

@@ -0,0 +1,117 @@
+from __future__ import unicode_literals
+from ..base import EntryPointInterceptor
+from pythonagent.utils import get_current_thread_time_in_us, get_true_false
+from pythonagent.agent.probes.havoc.havoc_manager import NDHavocException
+
+class Tornado_async_RequestHandlerInterceptor(EntryPointInterceptor):
+    async def wrapper_execute(self, _execute, handler, *args, **kwargs):
+        bt = None
+        cpu_time_before = None
+        url = None
+        fp_instance = None
+
+        try:
+            request = handler.request
+            req_headers = self.parse_headers(request.headers.items(), "$", "|")
+            bt_header_value = self.parse_headers(request.headers.items(), "=", "&")
+
+            # if 'Cavndfpinstance' in request.headers.keys():
+            #     fp_instance = request.headers['Cavndfpinstance']
+
+            for key, val in request.headers.items():
+                if key.lower() == 'cavndfpinstance':
+                    fp_instance = val
+
+            nd_cookie_key = self.agent.nd_cookie_key
+            nv_cookie_key = self.agent.nv_cookie_key
+
+            nd_cookie_value = None
+            nv_cookie_value = None
+
+            for k, v in request.cookies.items():
+                if k == nd_cookie_key:
+                    nd_cookie_value = v.value
+                if k == nv_cookie_key:
+                    nv_cookie_value = v.value
+
+            url = request.uri
+            bt_name = url + "|" + request.method
+            correlation_header = ""
+            cpu_time_before = get_current_thread_time_in_us()
+            bt = self.start_business_transaction(bt_name, correlation_header, nd_cookie_value, nv_cookie_value, bt_header_value, fp_instance)
+            self.agent.http_req_resp_wrapper(bt, req_headers, "req", 200)
+            self.agent.logger.debug("Modulename: Tornado_async_RequestHandlerInterceptor class || bt value is :{0}".format(bt))
+        except Exception as e:
+            self.agent.logger.exception("Error in Tornado_async_RequestHandlerInterceptor class start business transaction", e)
+
+        result = await _execute(handler, *args, **kwargs)
+
+        try:
+            if bt:
+                cpu_time_after = get_current_thread_time_in_us()
+                cpu_time = cpu_time_after - cpu_time_before
+
+                nd_cookie_key = None
+                x_cav_nv = None
+                x_cav_nv_headers = None
+
+                if self.agent.header_in_response:
+                    x_cav_nv = get_true_false(self.agent.header_in_response)
+
+                result_headers = handler._headers
+                nd_cookie_value = self.agent.sdk_getNDSessionCookie(bt).decode()
+                if nd_cookie_key:  # CavNV Enabled
+                    if nd_cookie_value:
+                        nd_cookie_str = "{}={}".format(nd_cookie_key, nd_cookie_value)
+                        result_headers['Set-Cookie'] = nd_cookie_str
+                else:
+                    if self.agent.disable_nd_nv:  # CavNV Disabled Just Now
+                        nd_cookie_str = "CavNV=None; Max-Age=0"
+                        result_headers['Set-Cookie'] = nd_cookie_str
+                        self.agent.disable_nd_nv = False
+
+                if x_cav_nv:  # X-CavNV Enabled
+                    if nd_cookie_value:
+                        result_headers['X-CavNV'] = nd_cookie_value
+                        x_cav_nv_headers = "|X-CavNV$" + nd_cookie_value
+
+                result_status = handler.get_status()
+                resp_headers = self.parse_headers(result_headers.items(), "$", "|")
+                self.agent.http_req_resp_wrapper(bt, resp_headers, "resp", result_status)
+
+                try:
+                    context = self.agent.get_transaction_context()
+                    btname = context.btname if context else None
+                    self.agent.havoc_monitor.apply_inbound_service_failure(url, btname)
+                except Exception as e:
+                    if isinstance(e, NDHavocException):
+                        self.agent.set_current_status_code(503)
+                        rc = self.agent.end_business_transaction(bt, cpu_time)
+                        self.agent.havoc_monitor.refresh_configs(self.agent)
+                        raise e
+                    else:
+                        self.agent.logger.debug("Non-Havoc Exception {}".format(e))
+
+                self.agent.end_business_transaction(bt, cpu_time)
+
+        except Exception as e:
+            self.agent.logger.exception("Error in Tornado_async_RequestHandlerInterceptor class end business transaction", e)
+
+        return result
+
+
+    def parse_headers(self, input_list, key_val_sep, item_value_sep):
+        output_str = ""
+        for key, value in input_list:
+            value = value.replace("|", "%7C")    # CavSF has | in value
+            value = value.replace(":", "%3A")    # Host as : in value
+            value = value.replace("=", "%3D")  # Accept, Accept-Language, and ND-NV cookies have = in value
+            new_str = key + key_val_sep + value + item_value_sep
+            output_str += new_str
+        output_str = output_str[:-1]  # Remove last |
+        return output_str
+
+
+def intercept_tornado_async_web(agent, mod):
+    agent.logger.warning("Instrument module: tornado.web{}".format(", mod: {}".format(mod) if mod else ""))
+    Tornado_async_RequestHandlerInterceptor(agent, mod.RequestHandler).attach('_execute', patched_method_name="wrapper_execute")

pythonagent/agent/probes/frameworks/tornado_web.py

@@ -0,0 +1,133 @@
+
+from __future__ import unicode_literals
+import contextlib
+import sys
+#import threading
+
+#from lib import LazyWsgiRequest
+#from appdynamics.agent.core.eum import inject_eum_metadata
+#from appdynamics.agent.models.transactions import ENTRY_TORNADO
+from ..base import EntryPointInterceptor
+#from agent.internal.proxy import *
+#import agent
+#ENTRY_PYTHON_WEB = pb.PYTHON_WEB # need to ask ENTRY_PYTHON_WEB value
+#ENTRY_TORNADO = ENTRY_PYTHON_WEB
+try:
+    import tornado.httputil
+    import tornado.ioloop
+   # import tornado.stack_context
+   # import tornado.stack_context.StackContext
+    import tornado.web
+    import tornado.wsgi
+
+    class TornadoFallbackHandlerInterceptor(EntryPointInterceptor):
+        #proxy = Proxy.getInstance()
+       # print("framework tornado_web: TornadoFallbackHandlerInterceptor function proxy instance inside  tornado_web.py : ", proxy)
+       # print("framework tornado_web: TornadoFallbackHandlerInterceptor function proxy.lib inside class level variable inside tornado_web module : ", proxy.lib)
+        # When using FallbackHandler, the RequestHandler's finish method is
+        # never called.  Wrap the custom fallback callable to end the bt here.
+        def _initialize(self, initialize, handler, fallback):
+            self.agent.logger.info('Modulename: TornadoFallbackHandlerInterceptor class') 
+            def _fallback(request):
+                fallback(request)
+                bt = self.bt
+                self.agent.logger.debug("Modulename: TornadoFallbackHandlerInterceptor class || bt value is :{0}".format(bt))
+                if bt:
+                    #self.end_transaction(bt)
+                    self.end_business_transaction(bt)
+            initialize(handler, _fallback)
+
+    class TornadoRequestHandlerInterceptor(EntryPointInterceptor):
+        def __execute(self, _execute, handler, *args, **kwargs):
+           # bt = self.proxy.start_business_transaction(ENTRY_TORNADO,
+           #                             LazyWsgiRequest(tornado.wsgi.WSGIContainer.environ(handler.request)))
+           # bt = self.start_business_transaction(handler.request,correlation_header=None)
+            requests = handler.request
+            bt = self.start_business_transaction(requests.path,'')
+            #self.agent.logger.info("framework tornado_web: TornadoRequestHandlerInterceptor function print value of bt " .format(bt))
+            self.agent.logger.debug("Modulename: TornadoRequestHandlerInterceptor class || bt value is :{0}".format(bt))
+
+            #local_thread = threading.local()
+            #local_thread.context = bt
+
+            try:
+                #print("framework tornado_web: TornadoRequestHandlerInterceptor  request in  ===>: ", handler.request)
+                                                                                                                   
+                #self.agent.logger.info("Modulename: TornadoRequestHandlerInterceptor class insinde __execute function request is :{0}".format(handler.request))
+                # requests =handler.request
+                #print("framework tornado_web: TornadoRequestHandlerInterceptor  request.PATH_INFO ===>: ", requests.path)
+                #self.agent.logger.info("Modulename: TornadoRequestHandlerInterceptor class insinde __execute function request.PATH_INFO is :{0}".format(requests.path))
+                #print("framework tornado_web: TornadoRequestHandlerInterceptor  request.QUERY_STRING ===>: ", requests.query_string)
+                #self.agent.logger.info("Modulename: TornadoRequestHandlerInterceptor class insinde __execute function request.QUERY_STRING is :{0}".format(requests.query_string))
+                # print("WSGI interceptor request.data ===>: ", request.data)
+                #print("framework tornado_web: TornadoRequestHandlerInterceptor  request.host ===>: ", requests.host)
+                self.agent.logger.info("Modulename: TornadoRequestHandlerInterceptor class insinde __execute function requests.host is :{0}".format(requests.host))
+            except:
+                pass
+
+            if bt:
+                @contextlib.contextmanager
+                def current_bt_manager():
+                    """Set and unset current_bt as tornado moves between execution contexts.
+
+                    By wrapping the handler's execution with this we can ensure that whenever the
+                    IOLoop is executing code for a particular BT, that BT is the 'current_bt'.
+                    For more information see http://www.tornadoweb.org/en/stable/stack_context.html.
+
+                    """
+                    self.agent.set_current_bt(bt)
+                    try:
+                        yield
+                    except:
+                        # Currently can't figure out how to get here, so this code is untested.
+                        #bt.add_exception(*sys.exc_info())
+                        self.agent.logger.debug("Modulename: TornadoRequestHandlerInterceptor class || Exception is :{0}".format(*sys.exc_info()))
+                        raise
+                    finally:
+                        self.agent.unset_current_bt()
+
+               # with tornado.stack_context.StackContext(current_bt_manager):
+                result = _execute(handler, *args, **kwargs)
+            else:
+                result = _execute(handler, *args, **kwargs)
+
+            return result
+
+        def _finish(self, finish, handler, *args, **kwargs):
+            result = finish(handler, *args, **kwargs)
+            bt = self.bt
+            if bt:
+                with self.log_exceptions():
+                    self.handle_http_status_code(bt, handler._status_code, handler._reason)
+                    #self.end_transaction(bt)
+                    self.end_business_transaction(bt)
+            return result
+
+        def _flush(self, flush, handler, *args, **kwargs):
+            with self.log_exceptions():
+                if not handler._headers_written:
+                    bt = self.bt
+                    if bt:
+                        headers = list(handler._headers.get_all())
+                       # inject_eum_metadata(self.agent.eum_config, bt, headers)
+                        handler._headers = tornado.httputil.HTTPHeaders(headers)
+            return flush(handler, *args, **kwargs)
+
+        def __handle_request_exception(self, _handle_request_exception, handler, e, *args, **kwargs):
+            with self.log_exceptions():
+                bt = self.bt
+                if bt and not (hasattr(tornado.web, 'Finish') and isinstance(e, tornado.web.Finish)):
+                    #bt.add_exception(*sys.exc_info())
+                    self.agent.logger.debug("Modulename: TornadoRequestHandlerInterceptor class || Exception is :{0}".format(*sys.exc_info()))
+            return _handle_request_exception(handler, e, *args, **kwargs)
+
+    def intercept_tornado_web(agent, mod):
+        #print("framework torando_web :  intercept_torando_web")
+        TornadoRequestHandlerInterceptor(agent, mod.RequestHandler).attach(
+            ['_execute', 'flush', '_handle_request_exception', 'finish'])
+        TornadoFallbackHandlerInterceptor(agent, mod.FallbackHandler).attach('initialize')
+
+except ImportError:
+    def intercept_tornado_web(agent, mod):
+        pass
+