cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/probes/frameworks/__init__.py

@@ -0,0 +1,27 @@
+
+"""Entry-point interceptors for various web/application frameworks.
+
+"""
+
+from __future__ import unicode_literals
+
+from .django import intercept_django_wsgi_handler, intercept_django_base_handler, intercept_django_asgi_handler
+from .flask import intercept_flask
+from .bottle import intercept_bottle
+from .tornado_web import intercept_tornado_web
+from .cherry import intercept_cherrypy
+from .pyramid import intercept_pyramid
+from .falcon import intercept_falcon
+from .fastapi import intercept_fastapi_asgi_handler
+from .tornado_async_web import intercept_tornado_async_web
+from .aiohttp_web import intercept_aiohttp_web
+from .asgi import intercept_uvicorn_config
+
+
+#__all__ = [
+#    'intercept_flask',
+#    'intercept_django_wsgi_handler',
+#    'intercept_django_base_handler',
+#    'intercept_bottle',
+#    'intercept_tornado_web',
+#]

pythonagent/agent/probes/frameworks/agentprofiler.py

@@ -0,0 +1,105 @@
+from pyclbr import readmodule
+import os
+import threading 
+    
+    
+def application_callable_pro(self, application, instance, environ, start_response):
+    stack = inspect.stack()
+    temp={}
+    the_method_called = stack[3][0].f_code.co_name
+    request = Request(environ)
+    prof = cProfile.Profile()
+    prof.enable()
+    bt = self.start_business_transaction(request.full_path, '')
+    self.agent.logger.debug("Modulename: WSGI intercepto class || bt value is :{0}".format(bt))
+    method = self.agent.method_entry(bt,the_method_called)
+
+    try:
+        self.agent.logger.info("Modulename: WSGI interceptor class || request is :{0} || request path is {1} || query_string: {2} || host: {3} ".format(request,(request.path,request.query_string,request.host)))
+    except:
+        pass
+
+    try:
+        response = application(instance, environ, self._make_start_response_wrapper(start_response))
+        self.agent.logger.info("Modulename: WSGI interceptor class || response is :{0}".format(response))
+
+    except:
+        with self.log_exceptions():
+            if bt:
+                bt.add_exception(*sys.exc_info())
+        raise
+    finally:
+        method = the_method_called
+        self.agent.method_exit(bt,method)
+        self.end_business_transaction(bt)
+        prof.disable()
+        prof.print_stats()
+        p = pstats.Stats(prof)
+        #client application path
+        client_app_root = os.path.dirname(sys.argv[0])
+
+        for k,v in p.stats.items():
+
+            if client_app_root in k[0]:
+                module = k[0]
+                print("module:-", k[0])
+                module_path = os.path.split(os.path.abspath(module))[0]
+                modulefullname  = os.path.split(os.path.abspath(module))[1]
+                module_name = modulefullname.split('.')[0]
+                methodname = k[-1]
+                print('module path:-', module_path)
+                print('module name:-', module_name)
+                print('method name:- ',k[-1])
+                print('Total call:- ',v[1])
+                print('Response time of method:-',v[3])
+                mod = readmodule(module_name, path=[module_path])
+                li = []
+                for k, v in mod.items():
+                    li.append(k)
+                    methods = v.methods.items()
+                    lk = []
+                    for method, lineno in methods:
+                        lk.append(method)
+                    li.append(lk)
+                count=0
+                for i in li:
+                    count +=1
+                    if type(i)==str:
+                        pass
+                    else:
+                        for j in i:
+                            if j == methodname:
+                                print("classname:-",li[count-2])
+                            else:
+                                pass
+    return response
+
+def application_callable(self, application, instance, environ, start_response):
+    stack = inspect.stack()
+    temp={}
+    the_method_called = stack[3][0].f_code.co_name
+    request = Request(environ)
+    bt = self.start_business_transaction(request.full_path, '')
+    self.agent.logger.debug("Modulename: WSGI interceptor class || bt value is :{0}".format(bt))
+    method = self.agent.method_entry(bt,the_method_called)
+
+    try:
+        self.agent.logger.info("Modulename: WSGI interceptor class || request is :{0} || request path is {1} || query_string: {2} || host: {3} ".format(request,(request.path,request.query_string,request.host)))
+    except:
+        pass
+
+    try:
+        response = application(instance, environ, self._make_start_response_wrapper(start_response))
+        self.agent.logger.info("Modulename: WSGI interceptor class || response is :{0}".format(response))
+
+    except:
+        with self.log_exceptions():
+            if bt:
+                bt.add_exception(*sys.exc_info())
+        raise
+    finally:
+        method = the_method_called
+        self.agent.method_exit(bt,method)
+        self.end_business_transaction(bt)
+
+    return response

pythonagent/agent/probes/frameworks/aiohttp_web.py

@@ -0,0 +1,155 @@
+"""Interceptor for AIOHTTP Server framework.
+
+"""
+
+
+from ..base import BaseInterceptor
+from pythonagent.utils import get_current_thread_time_in_us, parse_headers, get_true_false
+from pythonagent.agent.probes.havoc.havoc_manager import NDHavocException
+
+class AIOHTTPWebInterceptor(BaseInterceptor):
+
+    def decode_cookie_method_position(self, mpos):
+        mpos_bin = format(mpos, '03b')
+        return get_true_false(mpos_bin[0]), get_true_false(mpos_bin[1]), get_true_false(mpos_bin[2])
+
+    async def wrapped_handle(self, _handle, *args, **kwargs):
+
+        bt = None
+        cpu_time_before = None
+        path = None
+
+        try:
+            request = args[1]
+            raw_request_message = request._message
+
+            path = raw_request_message.path
+            method = raw_request_message.method
+            raw_headers = raw_request_message.raw_headers
+
+            bt_name = path + "|" + method
+            correlation_header = ""
+            req_headers = parse_headers(raw_headers, "$", "|")
+            bt_header_value = parse_headers(raw_headers, "=", "&")
+
+            nd_cookie_value = None
+            nv_cookie_value = None
+            fp_instance = None
+
+            nd_cookie_key = self.agent.nd_cookie_key
+            nv_cookie_key = self.agent.nv_cookie_key
+
+            for key, val in raw_headers:
+                key = key.decode()
+                val = val.decode()
+
+                if key.lower() == 'cavndfpinstance':
+                    fp_instance = val
+
+                if key.lower() == 'cookie':
+                    cookie_list = val.split("; ")
+                    for cookie in cookie_list:
+                        cookie_key_val = cookie.split("=")
+                        cookie_key = cookie_key_val[0]
+                        cookie_val = cookie_key_val[1]
+
+                        if cookie_key == nd_cookie_key:
+                            nd_cookie_value = cookie_val
+                        if cookie_key == nv_cookie_key:
+                            nv_cookie_value = cookie_val
+
+            cpu_time_before = get_current_thread_time_in_us()
+
+            bt = self.agent.start_business_transaction(bt_name, correlation_header, nd_cookie_value,
+                                                       nv_cookie_value, bt_header_value, fp_instance)
+            print("bt", bt)
+
+            self.agent.http_req_resp_wrapper(bt, req_headers, "req", 200)
+
+        except Exception as e:
+            self.agent.logger.exception("Exception in Start BT for AIOHTTP Web {}".format(e))
+
+        # Invoking inbound havoc failure at the entry of the instrumented method
+        # so that the transaction fails at the start and does not continue
+        # processing to capture callouts or other downstream operations.
+        try:
+            context = self.agent.get_transaction_context()
+            btname = context.btname if context else None
+            self.agent.havoc_monitor.apply_inbound_service_failure(path, btname)
+        except Exception as e:
+            if isinstance(e, NDHavocException):
+                cpu_time_after = get_current_thread_time_in_us()
+                cpu_time = cpu_time_after - (cpu_time_before or 0)
+                self.agent.set_current_status_code(503)
+                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))
+
+        response = await _handle(*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.cookie_method_position:
+                    r_commit, m_entry, m_exit = self.decode_cookie_method_position(self.agent.cookie_method_position)
+
+                if self.agent.header_in_response:
+                    x_cav_nv = get_true_false(self.agent.header_in_response)
+
+                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)
+                        response.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"
+                        response.headers['Set-Cookie'] = nd_cookie_str
+                        self.agent.disable_nd_nv = False
+
+                if x_cav_nv:                                              # X-CavNV Enabled
+                    if nd_cookie_value:
+                        response.headers['X-CavNV'] = nd_cookie_value
+                        x_cav_nv_headers = "|X-CavNV$" + nd_cookie_value
+
+                key_val_sep = "$"
+                item_value_sep = "|"
+                resp_headers = ""
+
+                for key, value in response.headers.items():
+
+                    print("key", key)
+                    print("value", value)
+                    key = str(key)
+                    value = str(value)
+
+                    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
+                    resp_headers += new_str
+                resp_headers = resp_headers[:-1]  # Remove last |
+
+                self.agent.http_req_resp_wrapper(bt, resp_headers, "resp", 200)
+
+                self.agent.end_business_transaction(bt, cpu_time)
+                print("END BT")
+
+        except Exception as e:
+            self.agent.logger.exception("Exception in End BT for AIOHTTP Web {}".format(e))
+
+        return response
+
+
+def intercept_aiohttp_web(agent, mod):
+    agent.logger.warning("Instrument module: aiohttp.web_app{}".format(", mod: {}".format(mod) if mod else ""))
+    AIOHTTPWebInterceptor(agent, mod.Application).attach('_handle', patched_method_name='wrapped_handle')

pythonagent/agent/probes/frameworks/aisess.py

@@ -0,0 +1,151 @@
+import os
+import sys
+import cProfile
+import threading
+import pstats
+from collections import Counter
+from pyclbr import readmodule
+
+class Aisession():
+    def __init__(self, istart, starttime, duration, sess):
+        self.duration = duration
+        self.istart = istart
+        self.starttime = starttime
+        self.sess = sess
+        print("SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSEEEEEEEEEEEEEEEEEEEEEEEEEEEESSSSSSSSSSSSSSSSSSSSSSSSSSSSSS", sess)
+        self.prof = cProfile.Profile()
+        os.environ['aisess_status'] = 'True' 
+
+    def enableprof(self):
+        self.prof.enable()
+        #os.environ['aisess_status'] = 'True'
+        #os.environ['Aisession_flag'] = 'True'
+
+    def endsession(self):
+        self.prof.disable()
+        self.printst()
+        os.environ['aisess_status'] = 'False'
+        os.environ['Aisession_flag'] = 'False'
+        print("@!#@$#%$^&*^&%^$%#$@####$#%$^% IN endsession")
+        self.prof = None
+        
+    """def disableprof(self):
+        timer = threading.Timer(self.time,self.endsession)
+        timer.start()"""
+    def disableprof(self):
+        #if self.istart == 0:
+        #   self.endsession()
+        timer = threading.Timer(self.duration,self.endsession)
+        timer.start()
+        print("exiting endsession")
+
+
+    """def stopaisession(self, duration):
+        self.disableprof(duration)
+        print(" IN stopaisession")
+        self.printst()
+        self.aiobj = None"""
+
+
+    def printst(self):
+        ndhome = os.environ.get('NDHOME')
+        path = ndhome + '/python/logs/'
+        filename = str(self.sess.decode('ascii'))+"_AI.txt"
+        file_to_open = os.path.join(path, filename)
+        filenameai = str(self.sess.decode('ascii'))+".txt"
+        aifile_to_open = os.path.join(path, filenameai)
+        xmlfilename = str(self.sess.decode('ascii'))+".xml"
+        xmlfile_to_open = os.path.join(path, xmlfilename)
+        xmlfile = open(xmlfile_to_open, 'w')
+        f = open(file_to_open, 'w')
+        f2 = open(aifile_to_open, 'w')
+        #f = open(f'/opt/cavisson/netdiagnostics/logs/{self.sess}.txt', 'w')
+        f.writelines("************************************  AUTO-INSTRUMENTATION  **************************************** \n")
+        f2.writelines("************************************  AUTO-INSTRUMENTATION  **************************************** \n")
+        f.writelines("# <FQM>| <I:(instrumented) / C :(consisdered) / R :(remove) >| < Total Count > | < Total Duration > | < Added TimeStamp > | < Remove TimeStamp > \n")
+        f.writelines(f"#Start_Time {self.starttime}\n")
+        #f.writelines(f"#End_Time {}")
+        f.writelines(f"#Total Duration {self.duration}\n")
+        p = pstats.Stats(self.prof)
+        client_app_root = os.path.abspath(os.path.dirname(sys.argv[0]))
+        print("application:-",client_app_root)
+        methodcountdict = {}
+        for k,v in p.stats.items():
+            #print(k[0])
+            if client_app_root in k[0]:
+                modulek001 = k[0]
+                print("$$$$$$$$$$$$$$$$$$", modulek001)
+                module = k[0]
+                print("module:-", k[0])
+                module_path = os.path.split(os.path.abspath(module))[0]
+                modulefullname = os.path.split(os.path.abspath(module))[1]
+                module_name = modulefullname.split('.')[0]
+                methodname = k[-1]
+                modulemethod = module_path+'*'+module_name+'*'+methodname
+                total_call = str(v[1])
+                total_duration =str(v[3])
+                print('modulemethod:-', modulemethod)
+                print('module path:-', module_path)
+                print('module name:-', module_name)
+                print('method name:- ',k[-1])
+                print('Total call:- ',v[1])
+                print('Response time of method:-',v[3])
+                #methodcountdict = {}
+                methodcountdict[modulemethod] = total_call
+                mod = readmodule(module_name, path=[module_path])
+                li = []
+                for k, v in mod.items():
+                    li.append(k)
+                    methods = v.methods.items()
+                    lk = []
+                    for method, lineno in methods:
+                        lk.append(method)
+                    li.append(lk)
+                count=0
+                classname =''
+                for i in li:
+                    count +=1
+                    if type(i)==str:
+                        pass
+                    else:
+                        for j in i:
+                            if j == methodname:
+                                classname = li[count-2]
+                               #print("classname:-",li[count-2])
+                                varfullname = module_name+"."+li[count-2]+"."+methodname
+                               #print("))))))))))))*((((((((((((",a)
+                            else:
+                                pass
+                if len(classname)>0:
+                    print(varfullname)
+                else:
+                    varfullname = module_name+"."+methodname
+                    print(varfullname)
+                outputform = varfullname+"|"+"I"+"|"+total_call+"|"+total_duration+"|"+"0"+"|"+"0"
+                print("************************************XWWDWSASSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS", outputform)
+               # f.writelines("************************************  AUTO-INSTRUMENTATION  **************************************** \n")
+                f.writelines(f"{outputform}  \n")
+                if (float(total_duration)/int(total_call)) >=0.7:
+                   outputformai = varfullname+"|"+"I"+"|"+total_call+"|"+total_duration+"|"+"0"+"|"+"0"
+                   f2.writelines(f"{outputformai}  \n")
+        f.close()    
+        f2.close()
+        xmlfile.close()
+        print(methodcountdict)            
+
+"""def aisession():
+    ai = WSGIInterceptor()
+    ai.application_callable = agentprofiler.application_callable_pro
+
+#aisession()
+
+def ta():
+    wsgi.WSGIInterceptor.application_callable = agentprofiler.application_callable
+
+#if flag ==True:
+#timer = threading.Timer(300, ta)
+#timer.start()
+def enablendisablesess():
+    aisession()
+    timer = threading.Timer(300, ta)
+    timer.start()"""