cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/probes/frameworks/wsgi.py

@@ -0,0 +1,353 @@
+"""Interceptors and utilities for dealing with WSGI-based apps/frameworks"""
+import os
+import sys
+import pstats 
+from sys import settrace
+from datetime import datetime, timedelta
+import importlib.util as _importlib_util
+import inspect
+from functools import wraps
+import threading
+import pythonagent.agent
+from ..base import EntryPointInterceptor
+#from lib import LazyWsgiRequest
+from pythonagent import config
+ENTRY_WSGI =8
+#from agent.internal.proxy import *
+from pyclbr import readmodule
+import os
+import inspect
+from pythonagent.utils import get_true_false
+import cProfile
+import pstats
+from pythonagent.agent.probes.frameworks.test import dumpstacks
+from pythonagent.agent.probes.havoc.havoc_manager import NDHavocException
+#from pythonagent.agent.probes.frameworks.aisess import Aisession
+#import AIsession
+#import aisess
+#aisess
+#import importlib.util
+#spec = importlib.util.spec_from_file_location("aisess", "/home/cavisson/my-shop/env/env/lib/python3.7/site-packages/pythonagent/agent/probes/frameworks/aisess.py")
+#foo = importlib.util.module_from_spec(spec)
+#spec.loader.exec_module(foo)
+from pythonagent.utils import get_current_thread_time_in_us, get_current_timestamp_in_us, get_validated_duration
+#os.environ['Aisession_flag'] = 'True'
+
+#profiler = None
+def aiflagset(s,st,d,sname):
+    os.environ['Aisession_flag'] = 'True'   
+    global duration
+    duration = d
+    global starttime
+    starttime = st
+    global istart
+    istart = s 
+    global sess
+    sess = sname
+
+class WSGIInterceptor(EntryPointInterceptor):
+
+    def attach(self, application):
+        super(WSGIInterceptor, self).attach(application, patched_method_name='application_callable')
+
+    def application_callable(self, application, instance, environ, start_response):
+        path = environ.get('PATH_INFO', '/')
+        query = environ.get('QUERY_STRING', '')
+        method = environ.get('REQUEST_METHOD', 'GET')
+        url = path + ('?' + query if query else '')
+
+        raw_headers = [
+            (k[5:].lower().replace('_', '-'), v)
+            for k, v in environ.items() if k.startswith('HTTP_')
+        ]
+        req_headers = self.parse_headers(raw_headers, "$", "|")
+        bt_header_value = self.parse_headers(raw_headers, "=", "&")
+
+        fp_instance = environ.get('HTTP_CAVNDFPINSTANCE')
+
+        nd_cookie_key = self.agent.nd_cookie_key
+        nv_cookie_key = self.agent.nv_cookie_key
+
+        nd_cookie_value = None
+        nv_cookie_value = None
+
+        cookie_str = environ.get('HTTP_COOKIE', '')
+        for cookie in cookie_str.split('; '):
+            parts = cookie.split('=', 1)
+            if len(parts) == 2:
+                k, v = parts
+                k = k.strip()
+                if k == nd_cookie_key:
+                    nd_cookie_value = v
+                if k == nv_cookie_key:
+                    nv_cookie_value = v
+
+        bt_name = url + "|" + 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)
+
+        # Build FQM using same approach as MethodInterceptor
+        fqmforentry = "default.default.default"
+        try:
+            app_cls = type(instance)
+            if hasattr(app_cls, "__module__"):  # Class Level Method
+                fqmforentry = app_cls.__module__ + "." + app_cls.__name__ + "." + application.__name__
+            else:  # Module Level Method
+                fqmforentry = app_cls.__name__ + "." + application.__name__
+        except Exception as e:
+            self.agent.logger.debug("Could not build entry_point_fqm: {}".format(e))
+
+        self.agent.http_req_resp_wrapper(bt, req_headers, "req", 200)
+
+        # 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(url, btname)
+        except Exception as e:
+            if isinstance(e, NDHavocException):
+                self.agent.set_current_status_code(503)
+                cpu_time_after = get_current_thread_time_in_us()
+                cpu_time = cpu_time_after - cpu_time_before
+                rc = self.agent.end_business_transaction(bt, cpu_time)
+                raise e
+            else:
+                self.agent.logger.debug("Non-Havoc Exception {}".format(e))
+
+        self.agent.logger.debug("Modulename: WSGI interceptor class || bt value is :{0}".format(bt))
+
+        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
+
+        before_time = get_current_timestamp_in_us()
+        if bt:
+            self.agent.method_entry(bt, fqmforentry, before_time)
+
+        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:
+            cpu_time_after = get_current_thread_time_in_us()
+            cpu_time = cpu_time_after - cpu_time_before
+            after_time = get_current_timestamp_in_us()
+            duration = get_validated_duration(before_time, after_time, fqmforentry)
+            if bt:
+                self.agent.method_exit(bt, fqmforentry, duration, cpu_time, before_time)
+            self.end_business_transaction(bt, cpu_time)
+
+        return response
+
+    def _make_start_response_wrapper(self, start_response):
+        @wraps(start_response)
+        def start_response_wrapper(status, headers, exc_info=None):
+            #Deal with HTTP status codes, errors and EUM correlation.
+            #See https://www.python.org/dev/peps/pep-0333/#the-start-response-callable for more information.
+            with self.log_exceptions():
+                bt = self.bt
+
+                nd_cookie_key = self.agent.nd_cookie_key
+                cookie_domain = self.agent.cookie_domain
+                x_cav_nv = None
+                x_nd_cookie_value = 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)
+
+                if x_cav_nv:
+                    nd_cookie_value = self.agent.sdk_getNDSessionCookie(bt)
+                    x_nd_cookie_value = nd_cookie_value
+                    if x_nd_cookie_value:
+                        headers.append(('X-CavNV', x_nd_cookie_value.decode()))
+                        x_cav_nv_headers = "|X-CavNV$" + x_nd_cookie_value.decode()
+
+                    if nd_cookie_key:                                  # X-CavNV Enabled and CavNV Enabled
+                        if nd_cookie_value:
+                            if cookie_domain:
+                                nd_cookie_str = "{}={}; Path=/; Domain={}".format(nd_cookie_key, nd_cookie_value.decode(), cookie_domain)
+                            else:
+                                nd_cookie_str = "{}={}; Path=/".format(nd_cookie_key, nd_cookie_value.decode())
+
+                            headers.append(('Set-Cookie', nd_cookie_str))
+                    else:                                              # X-CavNV Enabled and CavNV Disabled
+                        if self.agent.disable_nd_nv:
+                            if cookie_domain:
+                                nd_cookie_str = "CavNV=None; Max-Age=0; Path=/; Domain={}".format(cookie_domain)
+                            else:
+                                nd_cookie_str = "CavNV=None; Max-Age=0; Path=/"
+                            headers.append(('Set-Cookie', nd_cookie_str))
+                            self.agent.disable_nd_nv = False
+
+                else:
+                    if nd_cookie_key:                                  # X-CavNV Disabled and CavNV Enabled
+                        nd_cookie_value = self.agent.sdk_getNDSessionCookie(bt)
+                        if nd_cookie_value:
+                            if cookie_domain:
+                                nd_cookie_str = "{}={}; Path=/; Domain={}".format(nd_cookie_key, nd_cookie_value.decode(), cookie_domain)
+                            else:
+                                nd_cookie_str = "{}={}; Path=/".format(nd_cookie_key, nd_cookie_value.decode())
+
+                            headers.append(('Set-Cookie', nd_cookie_str))
+                    else:                                              # X-CavNV Disabled and CavNV Disabled
+                        if self.agent.disable_nd_nv:
+                            if cookie_domain:
+                                nd_cookie_str = "CavNV=None; Max-Age=0; Path=/; Domain={}".format(cookie_domain)
+                            else:
+                                nd_cookie_str = "CavNV=None; Max-Age=0; Path=/"
+
+                            headers.append(('Set-Cookie', nd_cookie_str))
+                            self.agent.disable_nd_nv = False
+
+                resp_headers = self.parse_headers(headers.copy(), "$", "|")
+
+                # if x_cav_nv_headers:
+                    # resp_headers = resp_headers + x_cav_nv_headers
+
+                #traceparent_bytes, tracestate_bytes = self.agent.get_trace_headers(bt)
+                #telemetry_headers = "|Traceparent$" + traceparent_bytes.decode() + "|Tracestate$" + tracestate_bytes.decode()
+                #resp_headers = resp_headers + telemetry_headers
+
+                self.agent.http_req_resp_wrapper(bt, resp_headers, "resp", 200)
+                self.agent.logger.info("Modulename: WSGI interceptor class || bt value is :{0}".format(bt))
+
+                if bt:
+                    # Store the HTTP status code and deal with errors.
+                    status_code, msg = status.split(' ', 1)
+                    self.handle_http_status_code(bt, int(status_code), msg)
+
+                    # Inject EUM metadata into the response headers.
+                    # inject_eum_metadata(self.agent.eum_config, bt, headers)
+
+            return start_response(status, headers, exc_info)
+
+        return start_response_wrapper
+
+    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 |
+        # output_str = output_str.replace("&", "|")
+
+        return output_str
+
+    def parse_bt_headers(self, input_list):
+        output_str = ""
+        for key, value in input_list:
+            new_str = key + "=" + value + "&"
+            output_str += new_str
+        output_str = output_str[:-1]  # Remove last |
+        # output_str = output_str.replace("&", "|")
+
+        return output_str
+
+    def parse_cookie_method_position(self, mpos):
+        mpos_bin = format(mpos, '04b')
+        return (get_true_false(mpos_bin[0]), get_true_false(mpos_bin[1]),
+                get_true_false(mpos_bin[2]), get_true_false(mpos_bin[3]))
+
+    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])
+
+
+class WSGIMiddleware(object):
+    #self.agent.logger.info('Modulename: WSGIMiddleware class ')
+  
+    def __init__(self, application=None):
+        self._application = application
+        self._configured = False
+        self._interceptor = WSGIInterceptor(pythonagent.agent.get_agent_instance(), None)
+        self._load_application_lock = threading.Lock()
+        #get_script()
+        #from pythonagent import config
+        #config.WSGI_SCRIPT_ALIAS = input("Enter the absolute path of WSGI application script. (command to get 'readlink -f <script_path.py>') : ")
+
+    def load_application(self):
+        wsgi_callable = config.WSGI_CALLABLE_OBJECT or 'application'
+
+        # Fix 2: honour CAV_ prefix first, fall back to legacy unprefixed name for compatibility
+        config.WSGI_SCRIPT_ALIAS = (
+            os.environ.get('CAV_WSGI_SCRIPT_ALIAS') or
+            os.environ.get('WSGI_SCRIPT_ALIAS') or
+            config.WSGI_SCRIPT_ALIAS
+        )
+
+        if not config.WSGI_SCRIPT_ALIAS and not config.WSGI_MODULE:
+            raise AttributeError(
+                'Cannot get WSGI application: the agent cannot load your '
+                'application. You must set CAV_WSGI_MODULE or '
+                'CAV_WSGI_SCRIPT_ALIAS in order to load your application.')
+
+        if config.WSGI_MODULE:
+            module_name = config.WSGI_MODULE
+
+            if ':' in module_name:
+                module_name, wsgi_callable = module_name.split(':', 1)
+
+            __import__(module_name)
+            # __import__('a.b') returns the top-level package 'a', not 'a.b'.
+            # sys.modules lookup always gives the exact sub-module requested.
+            wsgi_module = sys.modules[module_name]
+        else:
+            # Fix 1: imp.load_source was removed in Python 3.12; use importlib.util instead.
+            spec = _importlib_util.spec_from_file_location('wsgi_module', config.WSGI_SCRIPT_ALIAS)
+            wsgi_module = _importlib_util.module_from_spec(spec)
+            sys.modules['wsgi_module'] = wsgi_module
+            spec.loader.exec_module(wsgi_module)
+
+        if wsgi_callable.endswith('()'):  # factory callable e.g. "create_app()"
+            app = getattr(wsgi_module, wsgi_callable[:-2])
+            app = app()
+        else:
+            app = getattr(wsgi_module, wsgi_callable)
+
+        self._application = app
+
+    def wsgi_application(self, environ, start_response):
+        return self._application(environ, start_response)
+
+    def __call__(self, environ, start_response):
+        #config.WSGI_SCRIPT_ALIAS = input("Enter the absolute path of WSGI application script. (command to get 'readlink -f <script_path.py>') : ")
+        if not self._configured:
+            # Approach 7: translate UWSGI_* env vars to CAV_* before configure() reads them
+            config.map_uwsgi_environ()
+            pythonagent.agent.configure(environ)
+            self._configured = True
+
+        if not self._application:
+            # CORE-60212 - Double-checked locking: only the first burst of
+            # concurrent requests enters load_application(); all subsequent
+            # calls skip straight through once _application is set.
+            with self._load_application_lock:
+                if not self._application:
+                    self.load_application()
+
+        # The interceptor expects an unbound function to call, hence why this function is called like this.
+        return self._interceptor.application_callable(WSGIMiddleware.wsgi_application, self, environ, start_response)
+
+    def get_script():
+        config.WSGI_SCRIPT_ALIAS = input("Enter the absolute path of WSGI application script. (command to get 'readlink -f <script_path.py>') : ")
+        
+

pythonagent/agent/probes/grpc/__init__.py

@@ -0,0 +1,76 @@
+"""gRPC client + server instrumentation entry point.
+
+grpc.insecure_channel/secure_channel/server are bare module-level factory
+functions, not class methods, so BaseInterceptor.attach() (which requires
+self.cls.__mro__) does not apply here - these are patched directly with
+plain setattr-based wrapping instead, following the same intent as attach()
+(preserve original callable, guard against double-patching) without reusing
+machinery that only works against classes.
+"""
+
+import inspect
+from functools import wraps
+
+__all__ = ['intercept_grpc']
+
+
+def _bind_args(func, args, kwargs):
+    bound = inspect.signature(func).bind(*args, **kwargs)
+    bound.apply_defaults()
+    return bound
+
+
+def _wrap_channel_factory(agent, mod, factory_name):
+    from .client_interceptor import NDGrpcClientInterceptor
+
+    real_factory = getattr(mod, factory_name)
+
+    @wraps(real_factory)
+    def wrapper(*args, **kwargs):
+        bound = _bind_args(real_factory, args, kwargs)
+        target = bound.arguments.get('target')
+        channel = real_factory(*args, **kwargs)
+        try:
+            interceptor = NDGrpcClientInterceptor(agent, target, "grpc." + factory_name)
+            channel = mod.intercept_channel(channel, interceptor)
+        except Exception:
+            agent.logger.exception("Error registering gRPC client interceptor for target %s", target)
+        return channel
+
+    wrapper._pythonagent_intercepted = True
+    setattr(mod, factory_name, wrapper)
+
+
+def _wrap_server_factory(agent, mod):
+    from .server_interceptor import NDGrpcServerInterceptor
+
+    real_server = mod.server
+
+    @wraps(real_server)
+    def wrapper(*args, **kwargs):
+        bound = _bind_args(real_server, args, kwargs)
+        try:
+            interceptor = NDGrpcServerInterceptor(agent)
+            interceptors = bound.arguments.get('interceptors') or ()
+            bound.arguments['interceptors'] = tuple(interceptors) + (interceptor,)
+        except Exception:
+            agent.logger.exception("Error registering gRPC server interceptor")
+            return real_server(*args, **kwargs)
+        return real_server(*bound.args, **bound.kwargs)
+
+    wrapper._pythonagent_intercepted = True
+    setattr(mod, 'server', wrapper)
+
+
+def intercept_grpc(agent, mod):
+    if getattr(mod, '_pythonagent_grpc_intercepted', False):
+        return
+
+    if hasattr(mod, 'insecure_channel') and not hasattr(mod.insecure_channel, '_pythonagent_intercepted'):
+        _wrap_channel_factory(agent, mod, 'insecure_channel')
+    if hasattr(mod, 'secure_channel') and not hasattr(mod.secure_channel, '_pythonagent_intercepted'):
+        _wrap_channel_factory(agent, mod, 'secure_channel')
+    if hasattr(mod, 'server') and not hasattr(mod.server, '_pythonagent_intercepted'):
+        _wrap_server_factory(agent, mod)
+
+    mod._pythonagent_grpc_intercepted = True

pythonagent/agent/probes/grpc/client_interceptor.py

@@ -0,0 +1,132 @@
+"""Client-side gRPC interceptor.
+
+Implements all four grpc client interceptor shapes (unary-unary, unary-stream,
+stream-unary, stream-stream) in one class so every stub flavor (blocking,
+future/callback-based, streaming) is covered uniformly through gRPC's own
+public interceptor SPI - the same approach used by the Java agent's
+ClientInterceptor-based design, adapted to grpc-python's shape-split ABCs.
+"""
+
+from collections import namedtuple
+
+import grpc
+
+from pythonagent.agent.probes.base import ExitCallInterceptor
+from pythonagent.utils import get_current_timestamp_in_us, get_validated_duration, generate_callout_id
+
+
+class _ClientCallDetails(
+        namedtuple('_ClientCallDetails',
+                   ('method', 'timeout', 'metadata', 'credentials', 'wait_for_ready', 'compression')),
+        grpc.ClientCallDetails):
+    """Immutable ClientCallDetails carrying an extra CavNDFPInstance metadata entry."""
+    pass
+
+
+class NDGrpcClientInterceptor(ExitCallInterceptor,
+                               grpc.UnaryUnaryClientInterceptor,
+                               grpc.UnaryStreamClientInterceptor,
+                               grpc.StreamUnaryClientInterceptor,
+                               grpc.StreamStreamClientInterceptor):
+    """One interceptor instance per intercepted channel.
+
+    `target` is captured at channel-creation time (see agent/probes/grpc/__init__.py)
+    since grpc.ClientCallDetails carries no channel/host identity of its own.
+    """
+
+    def __init__(self, agent, target, req_method=None):
+        super(NDGrpcClientInterceptor, self).__init__(agent, None)
+        self.backend_name = "GRPC_" + str(target)
+        self.req_method = req_method
+
+    def _begin(self, client_call_details):
+        bt = self.bt
+        method = client_call_details.method or ""
+        callout_id = generate_callout_id()
+        start_time = get_current_timestamp_in_us()
+
+        exit_call = None
+        with self.log_exceptions():
+            exit_call = self.http_call_begin(
+                bt, self.backend_name, method, self.req_method, start_time, self.backend_name, callout_id)
+
+        metadata = list(client_call_details.metadata or [])
+        with self.log_exceptions():
+            headers_value = self.agent.get_nd_header(bt, self.backend_name, callout_id)
+            if headers_value:
+                headers_value = headers_value.decode() if isinstance(headers_value, bytes) else headers_value
+                metadata.append(('cavndfpinstance', headers_value))
+
+        new_details = _ClientCallDetails(
+            client_call_details.method,
+            client_call_details.timeout,
+            metadata,
+            client_call_details.credentials,
+            client_call_details.wait_for_ready,
+            client_call_details.compression)
+
+        return bt, new_details, exit_call, method, start_time
+
+    def _end(self, bt, exit_call, method, start_time, status_code):
+        with self.log_exceptions():
+            current_time = get_current_timestamp_in_us()
+            duration = get_validated_duration(start_time, current_time, "GRPC")
+            method = self.req_method
+            self.http_call_end(bt, exit_call, method, status_code, duration, start_time, self.backend_name)
+
+    @staticmethod
+    def _status_code_from_response(response):
+        try:
+            code = response.code()
+        except Exception:
+            return 200
+        return 200 if (code is None or code == grpc.StatusCode.OK) else 500
+
+    def intercept_unary_unary(self, continuation, client_call_details, request):
+        bt, new_details, exit_call, method, start_time = self._begin(client_call_details)
+        try:
+            response = continuation(new_details, request)
+        except Exception:
+            self._end(bt, exit_call, method, start_time, 500)
+            raise
+        self._end(bt, exit_call, method, start_time, self._status_code_from_response(response))
+        return response
+
+    def intercept_stream_unary(self, continuation, client_call_details, request_iterator):
+        bt, new_details, exit_call, method, start_time = self._begin(client_call_details)
+        try:
+            response = continuation(new_details, request_iterator)
+        except Exception:
+            self._end(bt, exit_call, method, start_time, 500)
+            raise
+        self._end(bt, exit_call, method, start_time, self._status_code_from_response(response))
+        return response
+
+    def intercept_unary_stream(self, continuation, client_call_details, request):
+        bt, new_details, exit_call, method, start_time = self._begin(client_call_details)
+        try:
+            response_iterator = continuation(new_details, request)
+        except Exception:
+            self._end(bt, exit_call, method, start_time, 500)
+            raise
+        return self._wrap_response_iterator(bt, exit_call, method, start_time, response_iterator)
+
+    def intercept_stream_stream(self, continuation, client_call_details, request_iterator):
+        bt, new_details, exit_call, method, start_time = self._begin(client_call_details)
+        try:
+            response_iterator = continuation(new_details, request_iterator)
+        except Exception:
+            self._end(bt, exit_call, method, start_time, 500)
+            raise
+        return self._wrap_response_iterator(bt, exit_call, method, start_time, response_iterator)
+
+    def _wrap_response_iterator(self, bt, exit_call, method, start_time, response_iterator):
+        status_code = 200
+        try:
+            for response in response_iterator:
+                yield response
+        except Exception:
+            status_code = 500
+            raise
+        finally:
+            self._end(bt, exit_call, method, start_time, status_code)