cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/probes/Instrumentation/module_version_resolver.py

@@ -0,0 +1,155 @@
+# Purpose: given an absolute file path (as found in sys.modules - application files and
+# site-packages dependencies alike), resolve the installed distribution that file belongs to: its
+# name, its version, and whether it IS the monitored application itself rather than a dependency.
+#
+# Used by find.py to report a jar-name-equivalent field per discovered module/class, mirroring the
+# sibling NodeJS agent's moduleVersionResolver.js (itself mirroring the Java agent's per-class
+# origin-jar reporting). NodeJS resolves ownership by walking up from a file to the nearest
+# package.json - Python has no such per-directory manifest, so this instead builds a one-time
+# reverse index from every installed distribution's own file list (RECORD), then falls back to a
+# stdlib/site-packages boundary check to decide whether an unresolved file is the application's own
+# code. Both the index and the boundary set are memoized, so a lookup after the first is O(1).
+
+import os
+import sys
+import logging
+import sysconfig
+
+try:
+    from importlib.metadata import distributions  # Python 3.8+
+except ImportError:
+    try:
+        from importlib_metadata import distributions  # backport for older Python 3
+    except ImportError:
+        distributions = None
+
+logger = logging.getLogger('pythonagent.agent')
+
+_file_to_package = None
+_boundary_dirs = None
+
+
+def _normalize(path):
+    return os.path.normcase(os.path.abspath(path))
+
+
+def _build_file_to_package_index():
+    index = {}
+    if distributions is None:
+        return index
+    for dist in distributions():
+        try:
+            name = dist.metadata['Name'] if dist.metadata else None
+            version = dist.version
+            files = dist.files or []
+        except Exception:
+            continue
+        if not name or not version:
+            continue
+        for f in files:
+            try:
+                index[_normalize(str(dist.locate_file(f)))] = (name, version)
+            except Exception:
+                continue
+    return index
+
+
+def _get_file_to_package_index():
+    global _file_to_package
+    if _file_to_package is None:
+        try:
+            _file_to_package = _build_file_to_package_index()
+        except Exception as e:
+            logger.warning('module_version_resolver | Error building package file index : %s', e)
+            _file_to_package = {}
+    return _file_to_package
+
+
+def _build_boundary_dirs():
+    dirs = set()
+    try:
+        paths = sysconfig.get_paths()
+        for key in ('stdlib', 'platstdlib', 'purelib', 'platlib'):
+            p = paths.get(key)
+            if p:
+                dirs.add(_normalize(p))
+    except Exception:
+        pass
+    try:
+        import site
+        if hasattr(site, 'getsitepackages'):
+            for p in site.getsitepackages():
+                dirs.add(_normalize(p))
+        if hasattr(site, 'getusersitepackages'):
+            dirs.add(_normalize(site.getusersitepackages()))
+    except Exception:
+        pass
+    return dirs
+
+
+def _get_boundary_dirs():
+    global _boundary_dirs
+    if _boundary_dirs is None:
+        try:
+            _boundary_dirs = _build_boundary_dirs()
+        except Exception as e:
+            logger.warning('module_version_resolver | Error building stdlib/site-packages boundary : %s', e)
+            _boundary_dirs = set()
+    return _boundary_dirs
+
+
+def _is_under_boundary(abs_path):
+    for boundary_dir in _get_boundary_dirs():
+        if abs_path == boundary_dir or abs_path.startswith(boundary_dir + os.sep):
+            return True
+    return False
+
+
+def resolve(file_path):
+    """Resolve the installed distribution owning file_path.
+
+    @return dict with 'name', 'version', 'isApp' - name/version are None when the file is the
+    application's own code (isApp True) or when nothing could be resolved at all (isApp False,
+    e.g. a stdlib module or a distribution with no readable RECORD); returns None only when
+    file_path itself is unusable.
+    """
+    if not file_path:
+        return None
+    try:
+        abs_path = _normalize(file_path)
+    except Exception:
+        return None
+
+    match = _get_file_to_package_index().get(abs_path)
+    if match:
+        return {'name': match[0], 'version': match[1], 'isApp': False}
+
+    if _is_under_boundary(abs_path):
+        # Inside stdlib/site-packages but not owned by any distribution we could index (e.g. a
+        # namespace package, or an editable/legacy install with no RECORD) - not app code, but no
+        # name/version to report either.
+        return {'name': None, 'version': None, 'isApp': False}
+
+    # Outside stdlib and site-packages entirely: this is the monitored application's own code.
+    return {'name': None, 'version': None, 'isApp': True}
+
+
+def format_jar_field(pkg_info):
+    """Format a resolve() result into the auto-discovery jar-equivalent field, mirroring
+    autoDiscovery.js's pkgField: "<name>@<version>", suffixed "(app)" when the file belongs to the
+    monitored application itself, or '' when nothing could be resolved."""
+    if not pkg_info:
+        return ''
+    name = pkg_info.get('name') or ''
+    version = pkg_info.get('version') or ''
+    field = (name + '@' + version) if (name and version) else ''
+    if pkg_info.get('isApp'):
+        field += '(app)'
+    return field
+
+
+def clear_cache():
+    """Exposed for tests/diagnostics only - not used by production callers."""
+    global _file_to_package, _boundary_dirs
+    _file_to_package = None
+    _boundary_dirs = None

pythonagent/agent/probes/Instrumentation/new_parser.py

@@ -0,0 +1,64 @@
+import json
+
+
+def create_module_list(filePath):
+    try:
+        f = open(filePath, "r")
+    except:
+        return []
+    x = f.read()
+    if x[1] == "[" and x[-1] != "]":
+        x += "]"
+    obj2 = json.loads(x)
+    list_of_modules = []
+    for item in obj2:
+        module_name_value = item.get("modulename", None)
+        module_name_split = module_name_value.split("|")
+        module_name = module_name_split[0]
+
+        if module_name not in list_of_modules:
+            list_of_modules.append(module_name)
+    return list_of_modules
+
+
+def create_method_list(filePath):
+    print("filePath", filePath)
+    try:
+        f = open(filePath, "r")
+    except:
+        return []
+
+    x = f.read()
+
+    if x[1] == "[" and x[-1] != "]":
+        x += "]"
+
+    obj2 = json.loads(x)
+    LOM = []
+    for item in obj2:
+        module_name_value = item.get("modulename", None)
+        module_name_split = module_name_value.split("|")
+        module_name = module_name_split[0]
+
+        if item.get("classes", None) != "":
+            classes_split = item.get("classes").split("|")
+            class_name = classes_split[0]
+            class_level_methods_str = classes_split[1]
+            class_level_methods = class_level_methods_str.split(",")
+            for class_level_method in class_level_methods:
+                LOM.append(module_name + "." + class_name + "." + class_level_method)
+        else:
+            module_level_methods_str = module_name_split[1]
+            module_level_methods = module_level_methods_str.split(",")
+            for module_level_method in module_level_methods:
+                LOM.append(module_name + "." +  module_level_method)
+
+    list_of_methods = [str(r) for r in LOM]
+
+    return list_of_methods
+
+
+if __name__ == "__main__":
+    abc = create_method_list("k.json")
+    print(abc)
+

pythonagent/agent/probes/Instrumentation/parser.py

@@ -0,0 +1,129 @@
+import json
+import logging
+#import jsonpickle
+#from json import JSONEncoder
+
+_logger = logging.getLogger('pythonagent.agent')
+
+try:
+    from types import SimpleNamespace as Namespace
+except ImportError:
+    # Python 2.x fallback
+    from argparse import Namespace
+
+
+
+
+#print("Encode Object into JSON formatted Data using jsonpickle")
+def flatten_hook(obj):
+    for key, value in obj.items():
+        if isinstance(value, str):
+            try:
+                obj[key] = json.loads(value, object_hook=flatten_hook)
+            except ValueError:
+                pass
+    return obj
+
+
+def create_method_json(filePath):
+    try:
+        f = open(filePath, "r")
+    except:
+        return {}
+    x = f.read()
+    if x[1] == "[" and x[-1] != "]":
+        x += "]"
+    obj2 = json.loads(x)
+    #obj2 = json.loads(f.read(),object_hook=flatten_hook)
+
+    return obj2
+
+def create_method_array(filePath):
+    #print('reading the profile at path: ',filePath)
+    try:
+        f = open(filePath, "r")
+    except:
+        return []
+
+    x = f.read()
+    if x[1] == "[" and x[-1] != "]":
+        x += "]"
+    obj2 = json.loads(x)
+    #print('Exception occure to open profiler file')
+    #obj2 = json.loads(f.read(),object_hook=flatten_hook)
+
+#list of methods
+    LOM = []
+
+    for module in obj2["modules"]:
+        
+        #module = module.split("/")[-1].replace(".py","")
+       # print(module+"--------------------------------------------")
+        for MLM in module["moduleLevelMethod"]:
+            #print(module["moduleName"])
+            LOM.append(module["moduleName"]+"."+MLM["name"])
+        for each_class in module["classes"]:
+            for CLM in each_class["classLevelMethods"]:
+                LOM.append(module["moduleName"]+"."+each_class["className"]+"."+CLM["name"])
+
+   # print(LOM)
+
+    arr = [str(r) for r in LOM]
+
+    #print(arr)
+    return arr
+
+#abc = create_method_json("/home/cavisson/methodTest/instrumentationprofile.json")["modules"]
+
+#print(abc["moduleName"])
+
+def create_method_list(filePath):
+    print("filePath", filePath)
+    try:
+        f = open(filePath, "r")
+    except:
+        return []
+
+    LOM = set()
+
+    string_of_profiles = f.read()
+    list_of_profiles = string_of_profiles.split("\n\n\n")
+
+    for profile in list_of_profiles:
+        try:
+            obj2 = json.loads(profile)
+        except:
+            continue
+
+        for item in obj2:
+            try:
+                module_name_value = item.get("modulename", None)
+                module_name_split = module_name_value.split("|")
+                module_name = module_name_split[0]
+
+                if item.get("classes", None) != "":
+                    classes_split = item.get("classes").split("|")
+                    class_name = classes_split[0]
+                    class_level_methods_str = classes_split[1]
+                    class_level_methods = class_level_methods_str.split(",")
+                    for class_level_method in class_level_methods:
+                        LOM.add(module_name + "." + class_name + "." + class_level_method)
+                else:
+                    module_level_methods_str = module_name_split[1]
+                    module_level_methods = module_level_methods_str.split(",")
+                    for module_level_method in module_level_methods:
+                        LOM.add(module_name + "." + module_level_method)
+            except Exception:
+                # A single malformed profile entry (e.g. missing "modulename",
+                # or "classes" empty with no "|" in "modulename") must not abort
+                # parsing of the rest of the profile -- that previously dropped
+                # every remaining module (including app modules) from a large
+                # "complete" profile and silently fell back to the stale local
+                # instrumentationprofile.json.
+                _logger.warning("Skipping malformed instrumentation profile entry: %r", item)
+                continue
+
+    list_of_methods = [str(r) for r in LOM]
+
+    return list_of_methods
+

pythonagent/agent/probes/__init__.py

@@ -0,0 +1,219 @@
+from . import frameworks, logging, http, sql,Instrumentation
+import sys
+
+try:
+    from importlib.machinery import ModuleSpec
+except ImportError:
+    pass
+
+try:
+    from importlib import reload
+except ImportError:
+    from imp import reload
+
+
+URL_PROPERTY_MAX_LEN = 100
+HOST_PROPERTY_MAX_LEN = 50
+DB_NAME_PROPERTY_MAX_LEN = 50
+VENDOR_PROPERTY_MAX_LEN = 50
+
+
+#from pythonagent.agent.internal.intercept_module import BT
+#BT_INTERCEPTORS = BT
+
+
+
+
+# BT_INTERCEPTORS = (
+#     # Entry points
+#     ('flask', frameworks.intercept_flask),
+#     ('django.core.handlers.wsgi', frameworks.intercept_django_wsgi_handler),
+#     ('django.core.handlers.base', frameworks.intercept_django_base_handler),
+#
+#     # HTTP exit calls
+#     ('httplib', http.intercept_httplib),
+#     ('http.client', http.intercept_httplib),
+#     ('urllib3', http.intercept_urllib3),
+#     ('requests', http.intercept_requests),
+#
+#     # Logging
+#     ('logging', logging.intercept_logging),
+#
+#     # SQL exit calls
+#     ('psycopg2', sql.psycopg2.intercept_psycopg2_connection),
+#     ('pymysql.connections', sql.pymysql.intercept_pymysql_connections),
+#     ('mysql.connector.connection', sql.mysql_connector.intercept_mysql_connector_connection),
+#     ('MySQLdb.connections', sql.mysqldb.intercept_MySQLdb_connection),
+# )
+
+
+def add_hook(agent):
+    """Add the module interceptor hook for pythonagent, if it's not already registered.
+
+    Reuses the existing ModuleInterceptor for this agent when one is already present in
+    sys.meta_path. This prevents accumulating N interceptors after N re-bootstraps, which
+    would cause O(N) overhead on every module import and N-times callback execution.
+    """
+    for finder in sys.meta_path:
+        if isinstance(finder, ModuleInterceptor) and finder.agent is agent:
+            return finder  # reuse — prevents sys.meta_path accumulation
+    interceptor = ModuleInterceptor(agent)
+    sys.meta_path.insert(0, interceptor)
+    return interceptor
+
+
+class ModuleInterceptor(object):
+    """Intercepts finding and loading modules in order to monkey patch them on load.
+
+    """
+
+    def __init__(self, agent):
+        super(ModuleInterceptor, self).__init__()
+        self.agent = agent
+        self.module_hooks = {}
+        self.intercepted_modules = set()
+
+    def find_spec(self, full_name, path, target=None):
+        #print("FIND SPEC {} ".format(full_name))
+        if full_name in self.module_hooks:
+            top = full_name.split('.')[0]
+            stdlib_names = getattr(sys, 'stdlib_module_names', None) or Instrumentation._FALLBACK_STDLIB_NAMES
+            if top in stdlib_names:
+                self.module_hooks.pop(full_name, None)
+                return None
+            return ModuleSpec(full_name, self)
+        return None
+
+    def find_module(self, full_name, path=None):
+        #print("FIND MODULE", full_name)
+        #self.agent.logger.info("Finding module {0}".format(full_name))
+        self.agent.logger.info('Modulename: ModuleInterceptor class || full_name {0}'.format(full_name))
+        if full_name in self.module_hooks:
+            top = full_name.split('.')[0]
+            stdlib_names = getattr(sys, 'stdlib_module_names', None) or Instrumentation._FALLBACK_STDLIB_NAMES
+            if top in stdlib_names:
+                self.module_hooks.pop(full_name, None)
+                return None
+            return self
+        return None
+
+    def load_module(self, name):
+        #print("LOAD MODULE  {}".format(name))
+        # Remove the module from the list of hooks so that we never see it again.
+        #self.agent.logger.info('Modulename: ModuleInterceptor class || function name {0}'.format(name))
+        #self.agent.logger.info("Loader loading load module {0}".format(name))
+        # for module in custom_methods_to_instrument_json["modules"]:
+        #   if name == module["moduleName"]:
+        #       hooks = Instrumentation.intercept_instrumented_method
+
+        # hooks = self.module_hooks.pop(name, [])
+        # print("hooks for module: ",name," ->",hooks)
+
+        #if name in all_module_names:
+         #   hooks = Instrumentation.intercept_instrumented_method
+         #   all_module_names.remove(name)
+        #else:
+        #    hooks = self.module_hooks.pop(name, [])
+
+
+
+
+        hooks = self.module_hooks.pop(name, [])
+
+
+
+
+
+        #self.agent.logger.info("hooks for module: {0} and hook {1}".format(name,hooks))
+        #self.agent.logger.info('Modulename: ModuleInterceptor class || hooks for module {0}'.format(hooks))
+        """
+        if name in sys.modules:
+            # Already been loaded. Return it as is.
+            return sys.modules[name]
+        """
+        #self.agent.logger.debug('Intercepting import %s', name)
+        #self.agent.logger.info(("Intercepting import {0}".format(name)))
+        #self.agent.logger.info('Modulename: ModuleInterceptor class || intercepting import {0}'.format(name))
+        try:
+            __import__(name)  # __import__('a.b.c') returns <module a>, not <module a.b.c>
+        except ImportError:
+            raise  # propagate missing-module errors as-is
+        except Exception as e:
+            # A non-ImportError from module initialisation (e.g. AttributeError from
+            # a version mismatch in dns/query.py when httpcore._backends is absent).
+            # Callers such as mysql.connector.pooling use "except ImportError" guards —
+            # wrapping here lets those guards work correctly instead of crashing the app.
+            raise ImportError(
+                "pythonagent: {!r} raised {} during load: {}".format(
+                    name, type(e).__name__, e)
+            ) from e
+        module = sys.modules.get(name)  # ...so get <module a.b.c> from sys.modules
+        if module is None:
+            return None
+
+        self._intercept_module(module, hooks)
+
+        return module
+
+    def call_on_import(self, module_name, cb):
+        # Never intercept stdlib module imports — adding them to module_hooks causes
+        # load_module to call __import__ re-entrantly, which corrupts Python 3.12
+        # per-module import locks (_bootstrap._weakref = None → AttributeError).
+        top = module_name.split('.')[0]
+        stdlib_names = getattr(sys, 'stdlib_module_names', None) or Instrumentation._FALLBACK_STDLIB_NAMES
+        if top in stdlib_names and top not in {"http", "urllib"}:
+            return
+
+        #print("agent/probes/init.call_on_import() ...")
+        #self.agent.logger.info('Modulename: ModuleInterceptor class || module_name is {0} and callback is {1}'.format(module_name,cb))
+        #self.agent.logger.info("modulename: %s", module_name, " callback: %s", cb)
+        #self.agent.logger.info('Modulename: ModuleInterceptor class inside call_on_import  function callback is {0}'.format(cb))
+
+        # print(custom_methods_to_instrument_json["modules"])
+        # print("hooks for module: ",name," ->",hooks)
+        
+        #if module_name in all_module_names:
+        #    hooks = Instrumentation.intercept_instrumented_method
+        #    self._intercept_module(sys.modules[module_name], [hooks])
+        
+        if module_name in sys.modules:
+            #print("FOUND IN SYS MODULES")
+            #print("module" ,module_name, " found in sys.modules. Calling intercept module")
+            self._intercept_module(sys.modules[module_name], [cb])
+            self.module_hooks.setdefault(module_name, [])
+            if cb not in self.module_hooks[module_name]:
+                self.module_hooks[module_name].append(cb)
+        else:
+            #print("NOT FOUND IN SYS MODULES")
+            #print("module" ,module_name, " not found in sys.modules. Will be called from load modules")
+            self.module_hooks.setdefault(module_name, [])
+            if cb not in self.module_hooks[module_name]:
+                self.module_hooks[module_name].append(cb)
+
+
+        #print('self.module_hooks value',self.module_hooks)
+        #if module_name in all_module_names:
+         #   hooks = Instrumentation.intercept_instrumented_method
+         #   __import__(module_name)
+         #   self._intercept_module(sys.modules[module_name], [hooks])
+
+    def _intercept_module(self, module, hooks):
+        #print("intercept module : {} hooks {}".format(module, hooks))
+        try:
+            for hook in hooks:
+                #self.agent.logger.debug("Running {0} hook {1}".format(module.__name__, hook))
+                hook(self.agent, module)
+            self.intercepted_modules.add(module)
+            #print("self.intercepted_modules", self.intercepted_modules)
+            #print("HOOK CALLED")
+        except:
+            #print("exception in _intercept_module")
+            self.agent.logger.exception("Exception in {0} hook.".format(module.__name__))
+
+            # Re-import to ensure the module hasn't been partially patched.
+            self.agent.logger.debug("Re-importing {0} after error in module hook".format( module.__name__))
+            reload(module)
+
+
+
+