cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/probes/frameworks/asgi.py

@@ -0,0 +1,340 @@
+import os
+import sys
+import threading
+import pythonagent.agent
+from pythonagent import config
+from ..base import EntryPointInterceptor
+from pythonagent.utils import get_current_thread_time_in_us, get_true_false, get_current_timestamp_in_us, get_validated_duration
+from functools import wraps
+from pythonagent.agent.probes.havoc.havoc_manager import NDHavocException
+
+
+class ASGIInterceptor(EntryPointInterceptor):
+
+    def attach(self, application, wrapper_func=None, patched_method_name=None):
+        super(ASGIInterceptor, self).attach(application, patched_method_name='application_callable')
+
+    async def application_callable(self, application, instance, scope, receive, send):
+        # Pass lifespan and WebSocket scopes through without starting a BT.
+        # Lifespan has no path/method/headers; WebSocket BTs are not meaningful.
+        if scope.get("type") != "http":
+            return await application(instance, scope, receive, send)
+
+        bt = None
+        cpu_time_before = None
+        other_info = {}
+
+        try:
+            try:
+                bt_name = scope.get("path") + "|" + scope.get("method")
+                other_info["path"] = scope.get("path")
+            except Exception:
+                bt_name = "/default|GET"
+                other_info["path"] = "/default"
+
+            correlation_header = ""
+
+            request_headers_list = scope.get("headers")
+            req_headers = self.parse_headers(request_headers_list, "$", "|")
+            bt_header_value = self.parse_headers(request_headers_list, "=", "&")
+
+            fp_instance = None
+            nd_cookie_value = None
+            nv_cookie_value = None
+
+            nd_cookie_key = self.agent.nd_cookie_key
+            nv_cookie_key = self.agent.nv_cookie_key
+
+            if scope.get("headers"):
+                for header_key_val in scope.get("headers"):
+                    header_key = header_key_val[0].decode()
+                    header_val = header_key_val[1].decode()
+
+                    if header_key.lower() == 'cavndfpinstance':
+                        fp_instance = header_val
+
+                    if header_key.lower() == 'cookie':
+                        cookie_list = header_val.split("; ")
+                        for cookie in cookie_list:
+                            # maxsplit=1 preserves Base64 padding (=) in cookie values
+                            cookie_key_val = cookie.split("=", 1)
+                            if len(cookie_key_val) < 2:
+                                continue
+                            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.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)
+
+        except Exception as e:
+            self.agent.logger.exception("Exception in Start BT for ASGI {}".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(other_info.get("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))
+
+        other_info["cpu_time_before"] = cpu_time_before
+        other_info["fqmforentry"] = fqmforentry
+        # Store bt in other_info so send_wrapper uses the per-request bt instead of
+        # self.bt (which is thread-local and wrong under concurrent async requests).
+        other_info["bt"] = bt
+
+        before_time = get_current_timestamp_in_us()
+        other_info["before_time"] = before_time
+        if bt:
+            self.agent.method_entry(bt, fqmforentry, before_time)
+        try:
+            return await application(instance, scope, receive, self.wrapped_send(send, other_info))
+        except Exception as e:
+            if isinstance(e, NDHavocException):
+                try:
+                    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)
+                    fqmforentry = other_info.get("fqmforentry", "default.default.default")
+                    before_time = other_info.get("before_time", 0)
+                    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.agent.end_business_transaction(bt, cpu_time)
+                except Exception as cleanup_error:
+                    self.agent.logger.exception(
+                        "Failed to close ASGI transaction after Havoc failure: {}".format(cleanup_error)
+                    )
+            raise
+
+    def wrapped_send(self, send, other_info):
+        @wraps(send)
+        async def send_wrapper(*args, **kwargs):
+            send_event_dict = args[0]
+            # Use the closed-over bt — not self.bt — to avoid thread-local races
+            # when multiple async requests share one OS thread.
+            bt = other_info.get("bt")
+
+            if send_event_dict.get('type') == 'http.response.start':
+                status = send_event_dict.get('status', 200)
+
+                # Inject session cookies before forwarding the response start event
+                try:
+                    self._inject_cookies(bt, send_event_dict)
+                except Exception as e:
+                    self.agent.logger.debug("Exception injecting ASGI cookies: {}".format(e))
+
+                resp_headers = self.parse_headers(send_event_dict.get('headers', []), "$", "|")
+                self.agent.http_req_resp_wrapper(bt, resp_headers, "resp", status)
+
+                try:
+                    self.handle_http_status_code(bt, status, "")
+                except Exception as e:
+                    self.agent.logger.debug("Exception in handle_http_status_code for ASGI: {}".format(e))
+
+            await send(*args, **kwargs)
+
+            if send_event_dict.get("type") == "http.response.body":
+                more_body = send_event_dict.get("more_body", False)
+                if not more_body:
+                    try:
+                        if bt:
+                            cpu_time_after = get_current_thread_time_in_us()
+                            cpu_time_before = other_info.get("cpu_time_before")
+
+                            if cpu_time_before:
+                                cpu_time = cpu_time_after - cpu_time_before
+                            else:
+                                cpu_time = cpu_time_after - 0
+
+                            fqmforentry = other_info.get("fqmforentry", "default.default.default")
+                            before_time = other_info.get("before_time", 0)
+                            after_time = get_current_timestamp_in_us()
+                            duration = get_validated_duration(before_time, after_time, fqmforentry)
+                            self.agent.method_exit(bt, fqmforentry, duration, cpu_time, before_time)
+
+                            self.agent.end_business_transaction(bt, cpu_time)
+                    except Exception as e:
+                        self.agent.logger.warning("Exception in End BT for ASGI {}".format(e))
+
+        return send_wrapper
+
+    def _inject_cookies(self, bt, send_event_dict):
+        """Mirror WSGI cookie injection: append CavNV / X-CavNV headers to
+        an http.response.start event dict before it is forwarded to the client."""
+        nd_cookie_key = self.agent.nd_cookie_key
+        cookie_domain = self.agent.cookie_domain
+        x_cav_nv = None
+
+        # Copy headers list so the original is not mutated unexpectedly
+        response_headers = list(send_event_dict.get('headers', []))
+
+        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)
+            if nd_cookie_value:
+                response_headers.append((b'x-cavnv', nd_cookie_value))
+
+            if nd_cookie_key:
+                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())
+                    response_headers.append((b'set-cookie', nd_cookie_str.encode()))
+            else:
+                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=/"
+                    response_headers.append((b'set-cookie', nd_cookie_str.encode()))
+                    self.agent.disable_nd_nv = False
+        else:
+            if nd_cookie_key:
+                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())
+                    response_headers.append((b'set-cookie', nd_cookie_str.encode()))
+            else:
+                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=/"
+                    response_headers.append((b'set-cookie', nd_cookie_str.encode()))
+                    self.agent.disable_nd_nv = False
+
+        send_event_dict['headers'] = response_headers
+
+    def parse_headers(self, input_list, key_val_sep, item_value_sep):
+        output_str = ""
+        if input_list:
+            for key, value in input_list:
+                key = key.decode()
+                value = value.decode()
+                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
+ 
+
+class ASGIMiddleware:
+    """Generic ASGI middleware that instruments any ASGI callable for transaction capture.
+
+    Analogous to WSGIMiddleware in wsgi.py. Supports two usage modes:
+      1. Wrap an existing app directly: ASGIMiddleware(app)
+      2. Load app from config: set ASGI_MODULE env var, use module-level `application` singleton
+    """
+
+    def __init__(self, application=None):
+        self._application = application
+        self._interceptor = None  # lazy — created on first request to avoid circular import
+        self._load_application_lock = threading.Lock()
+
+    def _load_application(self):
+        asgi_callable = config.ASGI_CALLABLE_OBJECT or 'application'
+        module_str = os.environ.get('ASGI_MODULE') or config.ASGI_MODULE
+
+        if not module_str:
+            raise AttributeError(
+                'Cannot load ASGI application: set ASGI_MODULE '
+                '(e.g. myapp.asgi:application).')
+
+        if ':' in module_str:
+            module_str, asgi_callable = module_str.split(':', 1)
+
+        __import__(module_str)
+        asgi_module = sys.modules[module_str]
+
+        if asgi_callable.endswith('()'):
+            app = getattr(asgi_module, asgi_callable[:-2])()
+        else:
+            app = getattr(asgi_module, asgi_callable)
+
+        self._application = app
+
+    async def asgi_application(self, scope, receive, send):
+        return await self._application(scope, receive, send)
+
+    async def __call__(self, scope, receive, send):
+        if self._interceptor is None:
+            self._interceptor = ASGIInterceptor(pythonagent.agent.get_agent_instance(), None)
+        if not self._application:
+            with self._load_application_lock:
+                if not self._application:
+                    self._load_application()
+
+        return await self._interceptor.application_callable(
+            ASGIMiddleware.asgi_application, self, scope, receive, send
+        )
+
+
+# Module-level singleton — allows: uvicorn pythonagent.agent.probes.frameworks.asgi:application
+application = ASGIMiddleware()
+
+
+def intercept_uvicorn_config(agent, mod):
+    """Patch uvicorn Config.load to auto-wrap any ASGI app with our interceptor.
+
+    Fires when uvicorn.config is imported. After Config.load() runs, self.loaded_app
+    is the real ASGI callable. We wrap it with ASGIMiddleware so all HTTP requests
+    go through our instrumentation regardless of which ASGI framework is used.
+
+    Frameworks already instrumented at method level (Django ASGI, FastAPI/Starlette)
+    have _cav_asgi_patched set on their base class and are skipped to avoid double BTs.
+    """
+    original_load = mod.Config.load
+
+    def patched_load(self):
+        original_load(self)
+        loaded = getattr(self, 'loaded_app', None)
+        if loaded is None or isinstance(loaded, ASGIMiddleware):
+            return
+        # Skip if the app's class hierarchy has already been instrumented at method level.
+        for klass in type(loaded).__mro__:
+            if klass.__dict__.get('_cav_asgi_patched'):
+                return
+        self.loaded_app = ASGIMiddleware(loaded)
+
+    mod.Config.load = patched_load

pythonagent/agent/probes/frameworks/bottle.py

@@ -0,0 +1,27 @@
+"""Interceptor for Bottle.
+
+"""
+
+import sys
+
+from pythonagent.agent.probes.frameworks.wsgi import WSGIInterceptor
+from pythonagent.agent.probes.base import BaseInterceptor
+
+
+class BottleInterceptor(BaseInterceptor):
+    def add_exception(self, func, *args, **kwargs):
+        self.agent.logger.info('Modulename: BottleInterceptor class')
+        with self.log_exceptions():
+            bt = self.bt
+            self.agent.logger.info("Modulename: BottleInterceptor class inside add_exception function bt value is :{0}".format(bt))
+            if bt:
+                bt.add_exception(*sys.exc_info())
+        return func(*args, **kwargs)
+
+
+
+def intercept_bottle(agent, mod):
+    agent.logger.warning("Instrument module: bottle{}".format(", mod: {}".format(mod) if mod else ""))
+    WSGIInterceptor(agent, mod.Bottle).attach('__call__')
+    #print("framework.bottle.intercept_bottle: intercepting bottle ......")
+    BottleInterceptor(agent, mod.HTTPError).attach('__init__', patched_method_name='add_exception')

pythonagent/agent/probes/frameworks/cherry.py

@@ -0,0 +1,25 @@
+"""Interceptor for Cherry framework.
+
+"""
+from __future__ import unicode_literals
+import sys
+
+from pythonagent.agent.probes.frameworks.wsgi import WSGIInterceptor
+from pythonagent.agent.probes.base import BaseInterceptor
+
+class CherrypyExceptionAdder(BaseInterceptor):
+    def add_exception(self, func, *args, **kwargs):
+        with self.log_exceptions():
+            bt = self.bt
+            self.agent.logger.info("Modulename: cherry exception  class || bt  value is {0} :".format(bt))
+            if bt:
+                bt.add_exception(*sys.exc_info())
+                self.agent.logger.debug("Exception occured as  !!! {0}".format(sys.exc_info()))
+        return func(*args, **kwargs)
+
+
+def intercept_cherrypy(agent, mod):
+    agent.logger.warning("Instrument module: cherrypy{}".format(", mod: {}".format(mod) if mod else ""))
+    WSGIInterceptor(agent, mod.Application).attach('__call__')
+    CherrypyExceptionAdder(agent, mod._cprequest.Request).attach('handle_error', patched_method_name='add_exception')
+    CherrypyExceptionAdder(agent, mod.HTTPError).attach('set_response', patched_method_name='add_exception')

pythonagent/agent/probes/frameworks/django.py

@@ -0,0 +1,128 @@
+"""Interceptor for Django.
+
+"""
+
+
+from __future__ import unicode_literals
+import sys
+
+from pythonagent.agent.probes.frameworks.wsgi import WSGIInterceptor
+from pythonagent.agent.probes.frameworks.asgi import ASGIInterceptor
+from pythonagent.agent.probes.base import BaseInterceptor
+import logging
+#from django.conf import settings
+
+
+
+def add_exception(interceptor, exc_info):
+    with interceptor.log_exceptions():
+        bt = interceptor.bt
+        if bt:
+            bt.add_exception(*exc_info)
+
+#from django.utils.deprecation import MiddlewareMixin
+
+
+
+
+class DjangoBaseHandlerInterceptor(BaseInterceptor):
+    def _load_middleware(self, load_middleware, base_handler, **kwargs):
+        self.agent.logger.info("Loading middleware of django !")
+        self.agent.logger.info('Modulename: DjangoBaseHandlerInterceptor class inside _load_middleware function : loading middleware of django !')
+        #settings.MIDDLEWARE.append('agent.my_middleware.CustomMiddleware')
+        load_middleware(base_handler, **kwargs)
+
+        if hasattr(base_handler, '_exception_middleware'):
+            base_handler._exception_middleware.insert(0, pythonagentDjangoMiddleware(self).process_exception)
+        #base_handler._request_middleware.insert(0, pythonagentDjangoMiddleware(self).process_request)
+        #base_handler._response_middleware.insert(0, pythonagentDjangoMiddleware(self).process_response)
+        #base_handler._template_response_middleware.insert(0, pythonagentDjangoMiddleware(self).process_template_response)
+        #base_handler._view_middleware.insert(0, pythonagentDjangoMiddleware(self).process_view)
+
+
+
+    def _handle_uncaught_exception(self, handle_uncaught_exception, base_handler, request, resolver, exc_info):
+        add_exception(self, exc_info)
+        return handle_uncaught_exception(base_handler, request, resolver, exc_info)
+
+
+class DjangoExceptionInterceptor(BaseInterceptor):
+    def _handle_uncaught_exception(self, handle_uncaught_exception, request, resolver, exc_info):
+        add_exception(self, exc_info)
+        return handle_uncaught_exception(request, resolver, exc_info)
+
+
+
+
+class pythonagentDjangoMiddleware(object):
+    def __init__(self, interceptor):
+        self.interceptor = interceptor
+        self.logger = logging.getLogger('pythonagent.agent')
+
+    def process_exception(self, request, exception):
+        add_exception(self.interceptor, sys.exc_info())
+        #print("Django application process_request called and request as= ", request)
+
+
+def intercept_django_wsgi_handler(agent, mod):
+    agent.logger.warning("Instrument module: django.core.handlers.wsgi{}".format(", mod: {}".format(mod) if mod else ""))
+    WSGIInterceptor(agent, mod.WSGIHandler).attach('__call__')
+
+
+def intercept_django_asgi_handler(agent, mod):
+    agent.logger.warning("Instrument module: django.core.handlers.asgi{}".format(", mod: {}".format(mod) if mod else ""))
+    # Patch base class handle()
+    ASGIInterceptor(agent, mod.ASGIHandler).attach('handle')
+
+    # Patch a concrete subclass if it overrides handle or __call__ in its own __dict__.
+    # This is needed because Python MRO resolves the subclass method first, bypassing
+    # any patch we placed on the base class (e.g. Saleor's PatchedASGIHandler overrides
+    # handle() to fix a Django memory leak and its own handle shadows our base-class patch).
+    def _patch_subclass(cls):
+        if 'handle' in cls.__dict__:
+            ASGIInterceptor(agent, cls).attach('handle')
+        if '__call__' in cls.__dict__:
+            ASGIInterceptor(agent, cls).attach('__call__')
+
+    # Patch any ASGIHandler subclasses already defined when the hook fires
+    # (covers the late-bootstrap case where sys.modules already has the module).
+    queue = list(mod.ASGIHandler.__subclasses__())
+    while queue:
+        subclass = queue.pop(0)
+        _patch_subclass(subclass)
+        queue.extend(subclass.__subclasses__())
+
+    # Install __init_subclass__ hook so subclasses defined AFTER this hook fires
+    # (the common case: Saleor imports django.core.handlers.asgi first, then
+    # defines PatchedASGIHandler) are automatically patched at class-definition time.
+    _original_init_subclass = mod.ASGIHandler.__dict__.get('__init_subclass__', None)
+
+    @classmethod
+    def _auto_patch_subclass(cls, **kwargs):
+        if _original_init_subclass is not None:
+            _original_init_subclass.__func__(cls, **kwargs)
+        else:
+            super(mod.ASGIHandler, cls).__init_subclass__(**kwargs)
+        _patch_subclass(cls)
+
+    mod.ASGIHandler.__init_subclass__ = _auto_patch_subclass
+
+    # Prevent the generic uvicorn.config hook from double-wrapping Django ASGI apps.
+    # The hook checks _cav_asgi_patched on the class MRO before adding ASGIMiddleware.
+    mod.ASGIHandler._cav_asgi_patched = True
+
+
+def intercept_django_base_handler(agent, mod):
+    agent.logger.warning("Instrument module: django.core.handlers.base{}".format(", mod: {}".format(mod) if mod else ""))
+    base_handler_methods = ['load_middleware']
+
+    try:
+        import django.core.handlers.exception
+        if hasattr(django.core.handlers.exception, 'handle_uncaught_exception'):
+            DjangoExceptionInterceptor(agent, django.core.handlers.exception).attach('handle_uncaught_exception')
+        else:
+            base_handler_methods.append('handle_uncaught_exception')
+    except ImportError:
+        base_handler_methods.append('handle_uncaught_exception')
+
+    DjangoBaseHandlerInterceptor(agent, mod.BaseHandler).attach(base_handler_methods)

pythonagent/agent/probes/frameworks/falcon.py

@@ -0,0 +1,21 @@
+
+from __future__ import unicode_literals
+import sys
+
+from pythonagent.agent.probes.frameworks.wsgi import WSGIInterceptor
+from pythonagent.agent.probes.base import BaseInterceptor
+
+class FalconExceptionAdder(BaseInterceptor):
+    def add_exception(self, func, *args, **kwargs):
+        with self.log_exceptions():
+            bt = self.bt
+            if bt:
+                bt.add_exception(*sys.exc_info())
+        return func(*args, **kwargs)
+
+
+def intercept_falcon(agent, mod):
+    agent.logger.warning("Instrument module: falcon{}".format(", mod: {}".format(mod) if mod else ""))
+    WSGIInterceptor(agent, mod.App).attach('__call__')
+    FalconExceptionAdder(agent, mod.App).attach('_handle_exception', patched_method_name='add_exception')
+    #FalconExceptionAdder(agent, mod.Request).attach('set_response', patched_method_name='add_exception')

pythonagent/agent/probes/frameworks/fastapi.py

@@ -0,0 +1,35 @@
+
+"""Interceptor for FastApi framework.
+
+"""
+
+from __future__ import unicode_literals
+import sys
+
+from pythonagent.agent.probes.frameworks.asgi import ASGIInterceptor
+from pythonagent.agent.probes.base import BaseInterceptor
+
+
+class FastapiInterceptor(BaseInterceptor):
+    def _run_endpoint_function(self, run_endpoint_function):
+        with self.log_exceptions():
+            bt = self.bt
+            # self.agent.logger.info("Modulename: FlaskInterceptor  class || bt  value is {0} :".format(bt))
+            if bt:
+                pass
+            return run_endpoint_function
+
+def intercept_fastapi_asgi_handler(agent, mod):
+    agent.logger.warning("Instrument module: starlette.routing{}".format(", mod: {}".format(mod) if mod else ""))
+    ASGIInterceptor(agent, mod.Router).attach('__call__')
+    #ASGIInterceptor(agent, mod.Router).attach('app')
+
+    # Prevent the generic uvicorn.config hook from double-wrapping FastAPI/Starlette apps.
+    mod.Router._cav_asgi_patched = True
+    try:
+        import starlette.applications
+        starlette.applications.Starlette._cav_asgi_patched = True
+    except Exception:
+        pass
+
+

pythonagent/agent/probes/frameworks/flask.py

@@ -0,0 +1,30 @@
+
+"""Interceptor for Flask framework.
+
+"""
+
+from __future__ import unicode_literals
+import sys
+
+from pythonagent.agent.probes.frameworks.wsgi import WSGIInterceptor
+from pythonagent.agent.probes.base import BaseInterceptor
+
+
+class FlaskInterceptor(BaseInterceptor):
+    def _handle_user_exception(self, handle_user_exception, flask, e):
+        self.agent.logger.info('Modulename: FlaskInterceptor  class')
+        with self.log_exceptions():
+            bt = self.bt
+            self.agent.logger.info("Modulename: FlaskInterceptor  class || bt  value is {0} :".format(bt))
+            if bt:
+                #bt.add_exception(*sys.exc_info())
+                self.agent.logger.debug("Exception occured as  !!! {0}".format(sys.exc_info()))
+        #print('returning from _handle method !!')
+        return handle_user_exception(flask, e)
+
+
+def intercept_flask(agent, mod):
+    #print('=============inside flask instrumentation==========')
+    agent.logger.warning("Instrument module: flask{}".format(", mod: {}".format(mod) if mod else ""))
+    WSGIInterceptor(agent, mod.Flask).attach('wsgi_app')
+    FlaskInterceptor(agent, mod.Flask).attach('handle_user_exception')

pythonagent/agent/probes/frameworks/pyramid.py

@@ -0,0 +1,56 @@
+"""Interceptor for Pyramid.
+
+"""
+
+
+from __future__ import unicode_literals
+import sys
+
+from pythonagent.agent.probes.frameworks.wsgi import WSGIInterceptor
+from pythonagent.agent.probes.base import BaseInterceptor
+
+class PyramidRouterInterceptor(BaseInterceptor):
+    """
+    Pyramid's interceptor class
+    """
+    def _handle_request(self, handle_request, router_instance, req):
+        """
+
+        Parameters
+        ----------
+        handle_request: original method pyramid.router.Router.handle_request
+                        that is being overridden
+        router_instance: pyramid.router.Router instance
+        req: request object
+
+        Returns
+        -------
+        Whatever pyramid.router.Router.handle_request returns
+
+        """
+        try:
+            return handle_request(router_instance, req)
+        except Exception:
+            with self.log_exceptions():
+                bt = self.bt
+                if bt:
+                    bt.add_exception(*sys.exc_info())
+            raise
+
+
+def intercept_pyramid(agent, mod):
+    """
+
+    Parameters
+    ----------
+    
+    mod: pyramid.router module
+
+    Returns
+    -------
+    None
+    """
+    #mod = '/home/cavisson/shop/my-shop/env/env/lib/python3.7/site-packages/pyramid/router.py'
+    agent.logger.warning("Instrument module: pyramid{}".format(", mod: {}".format(mod) if mod else ""))
+    WSGIInterceptor(agent, mod.Router).attach('__call__')
+    PyramidRouterInterceptor(agent, mod.Router).attach('handle_request')