cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/bootstrap/sitecustomize.py

@@ -0,0 +1,287 @@
+"""Trick Python into loading the agent.
+"""
+from __future__ import unicode_literals
+
+# ---------------------------------------------------------------------------
+# sitecustomize chaining
+# ---------------------------------------------------------------------------
+# WHY THIS EXISTS
+#
+# The install script puts the agent's site-packages directory on PYTHONPATH:
+#
+#     export PYTHONPATH=${NDHOME}/python/site-packages:${PYTHONPATH}
+#
+# At interpreter startup, sys.path is built as:
+#     [script's own dir] + [PYTHONPATH entries, in order] + [stdlib / venv site-packages]
+#
+# That puts our directory at sys.path[1] — right after the script's own dir,
+# and ahead of the application's virtualenv, ahead of any co-tool's install
+# location, ahead of basically everything else on the machine.
+#
+# Python auto-imports a module named `sitecustomize` on every interpreter
+# startup if one exists anywhere on sys.path — and it imports ONLY THE FIRST
+# ONE IT FINDS. That auto-load is exactly what lets this agent instrument an
+# application with zero code changes: no import statement, no app code
+# edited, just install + set PYTHONPATH and the agent wires itself in before
+# the app even starts running.
+#
+# But that same "found first, wins, no error if others are skipped" behavior
+# is also what breaks other tools. Because our directory sits ahead of
+# everything else, OUR sitecustomize.py wins the search every time — even on
+# a machine where the monitored application (or a co-tool: Sentry,
+# coverage.py, pytest-cov, virtualenv bootstrapping, etc.) ships its own
+# sitecustomize.py for its own startup logic. Python does not merge them,
+# does not warn, and does not fall through to the next one. Whichever
+# sitecustomize loses the race is just silently never imported — its setup
+# never runs. From the customer's point of view, installing this agent would
+# look like it broke coverage reporting or killed Sentry init, with no error
+# anywhere to explain why.
+#
+# So this agent cannot just let auto-load do its thing — it has to actively
+# go find whatever sitecustomize.py *would* have been loaded if we weren't
+# here, and run it ourselves, in full, before continuing with our own
+# bootstrap. That's the chaining below.
+#
+# HOW IT WORKS
+#   1. CPython adds the module to sys.modules BEFORE executing its body, so
+#      sys.modules['sitecustomize'] already points to our (partially-
+#      initialised) module object when this code runs.
+#   2. We temporarily remove our bootstrap directory from sys.path so the
+#      next import search skips us and is forced to look further down
+#      sys.path — i.e. at wherever the app's or co-tool's own
+#      sitecustomize.py actually lives.
+#   3. We drop 'sitecustomize' from sys.modules so `import sitecustomize`
+#      triggers a fresh file search instead of returning a cache hit (which
+#      would just hand back ourselves again).
+#   4. We import the next sitecustomize — it runs in full, doing whatever
+#      setup it was originally supposed to do.
+#   5. In `finally` we restore our directory in sys.path at its original
+#      position and re-register ourselves in sys.modules so the rest of this
+#      file (the agent bootstrap) completes normally, and so that for the
+#      rest of the process's lifetime, `sys.modules['sitecustomize']`
+#      resolves back to us, not the chained module.
+import sys as _sys
+import os as _os
+
+_sc_this_dir = _os.path.dirname(_os.path.abspath(__file__))
+_sc_this_dir_norm = _os.path.normcase(_sc_this_dir)
+
+# Step 1 — keep a reference to ourselves (the partially-initialised module)
+_sc_our_module = _sys.modules.get('sitecustomize')
+
+# Step 2 — remove our directory from sys.path in-place so that any
+# modifications the chained sitecustomize makes to sys.path are preserved.
+_sc_our_idx = next(
+    (i for i, p in enumerate(_sys.path)
+     if _os.path.normcase(_os.path.abspath(p)) == _sc_this_dir_norm),
+    -1,
+)
+if _sc_our_idx >= 0:
+    _sys.path.pop(_sc_our_idx)
+
+# Steps 3-4 — import the next sitecustomize (if any)
+_sys.modules.pop('sitecustomize', None)
+try:
+    import sitecustomize as _sc_chained  # noqa: F401
+except Exception:
+    pass  # no other sitecustomize exists, or it raised — do not break the agent
+finally:
+    # Step 5 — restore our directory and re-register ourselves
+    if _sc_our_idx >= 0:
+        _sys.path.insert(_sc_our_idx, _sc_this_dir)
+    if _sc_our_module is not None:
+        _sys.modules['sitecustomize'] = _sc_our_module
+
+del _sys, _os, _sc_this_dir, _sc_this_dir_norm, _sc_our_module, _sc_our_idx
+# ---------------------------------------------------------------------------
+# End sitecustomize chaining
+# ---------------------------------------------------------------------------
+
+import logging
+import os
+import sys
+
+sitecustomize_dir = os.path.dirname(__file__)
+pythonagent_dir = os.path.join(sitecustomize_dir, "pythonagent")
+
+_bootstrapped_pid = None
+
+# ---------------------------------------------------------------------------
+# /proc-based process helpers (no psutil)
+# ---------------------------------------------------------------------------
+
+def _read_proc_cmdline(pid="self"):
+    """Return the argv list for *pid* by reading /proc/<pid>/cmdline.
+    Returns an empty list if the file cannot be read (non-Linux, no permission).
+    """
+    try:
+        with open("/proc/{}/cmdline".format(pid), "rb") as fh:
+            data = fh.read()
+        if not data:
+            return []
+        # argv entries are NUL-separated; strip trailing NUL before splitting
+        return data.rstrip(b"\x00").split(b"\x00")
+    except (IOError, OSError):
+        return []
+
+def _read_proc_comm(pid="self"):
+    """Return the short process name from /proc/<pid>/comm (Linux only)."""
+    try:
+        with open("/proc/{}/comm".format(pid), "r") as fh:
+            return fh.read().strip().lower()
+    except (IOError, OSError):
+        return ""
+
+def _cmdline_args():
+    """Best-effort argv list (bytes decoded to str, lower-cased preserved separately)."""
+    raw = _read_proc_cmdline()
+    if raw:
+        try:
+            return [a.decode("utf-8", errors="replace") for a in raw]
+        except Exception:
+            return []
+    # Fallback: sys.argv (may differ from the real cmdline on some platforms)
+    return list(sys.argv)
+
+def _cmdline_text(args):
+    return " ".join(args).lower()
+
+def _process_name():
+    """Short process name, lower-cased."""
+    comm = _read_proc_comm()
+    if comm:
+        return comm
+    # Fallback: basename of argv[0]
+    if sys.argv:
+        return os.path.basename(sys.argv[0]).lower()
+    return ""
+
+# ---------------------------------------------------------------------------
+# uWSGI helpers
+# ---------------------------------------------------------------------------
+
+def _is_uwsgi_master():
+    """Return True when running inside a uWSGI master process.
+    uwsgi.worker_id() returns 0 in the master and 1..N in workers.
+    """
+    try:
+        import uwsgi
+        return uwsgi.worker_id() == 0
+    except (ImportError, AttributeError):
+        return False
+
+# ---------------------------------------------------------------------------
+# Uvicorn helpers
+# ---------------------------------------------------------------------------
+
+def _is_uvicorn_command(args, proc_name):
+    if proc_name == "uvicorn":
+        return True
+    lowered = [a.lower() for a in args]
+    if "uvicorn" in lowered:
+        return True
+    for i, arg in enumerate(lowered):
+        if arg == "-m" and i + 1 < len(lowered) and lowered[i + 1] == "uvicorn":
+            return True
+    return False
+
+def _has_uvicorn_supervisor_options(args):
+    for i, arg in enumerate(args):
+        lo = arg.lower()
+        if lo == "--reload":
+            return True
+        if lo in ("--workers",) or lo.startswith("--workers="):
+            return True
+    return False
+
+def _is_uvicorn_supervisor(args, proc_name):
+    return _is_uvicorn_command(args, proc_name) and _has_uvicorn_supervisor_options(args)
+
+# ---------------------------------------------------------------------------
+# One-shot bootstrap guard
+# ---------------------------------------------------------------------------
+
+def _bootstrap_agent_once(agent, cfg):
+    global _bootstrapped_pid
+    pid = os.getpid()
+    if _bootstrapped_pid == pid:
+        return
+    cfg.map_uwsgi_environ()
+    agent.configure()
+    agent.bootstrap()
+    _bootstrapped_pid = pid
+
+# ---------------------------------------------------------------------------
+# sys.path cleanup for old split-bootstrap layout
+# ---------------------------------------------------------------------------
+
+if not os.path.isdir(pythonagent_dir):
+    try:
+        sys.path.remove(sitecustomize_dir)
+    except ValueError:
+        pass
+
+# ---------------------------------------------------------------------------
+# Main bootstrap
+# ---------------------------------------------------------------------------
+
+try:
+    import pythonagent.agent as agent
+    from pythonagent import config as _config
+
+    args        = _cmdline_args()
+    proc_name   = _process_name()
+    cmd_text    = _cmdline_text(args)
+
+    # --- gunicorn master: workers bootstrap via post_fork() in gunicorn cfg ---
+    gunicorn = "gunicorn" in cmd_text or proc_name == "gunicorn"
+
+    # --- uvicorn supervisor: child workers re-run sitecustomize via spawn ---
+    uvicorn_supervisor = _is_uvicorn_supervisor(args, proc_name)
+
+    # --- uWSGI master: workers bootstrap via @postfork below ---
+    uwsgi_master = _is_uwsgi_master()
+
+    if gunicorn or uvicorn_supervisor or uwsgi_master:
+        if gunicorn:
+            # Auto-bootstrap the agent in each gunicorn worker process after fork.
+            # Patch Worker.init_process at the class level in the master so every
+            # forked worker inherits the patch and runs bootstrap() before serving.
+            # This eliminates the need for a manual post_fork hook in gunicorn.conf.
+            try:
+                import gunicorn.workers.base as _gwb
+
+                _cav_orig_init_process = _gwb.Worker.init_process
+
+                def _cav_worker_init_process(self):
+                    _bootstrap_agent_once(agent, _config)
+                    return _cav_orig_init_process(self)
+
+                _gwb.Worker.init_process = _cav_worker_init_process
+            except Exception:
+                pass  # gunicorn not installed or incompatible version — no-op
+
+    else:
+        _bootstrap_agent_once(agent, _config)
+
+    # Register uWSGI postfork hook so each worker bootstraps after fork.
+    # uwsgidecorators is only importable inside a uWSGI process.
+    try:
+        from uwsgidecorators import postfork as _uwsgi_postfork
+
+        @_uwsgi_postfork
+        def _cavisson_uwsgi_postfork():
+            try:
+                _bootstrap_agent_once(agent, _config)
+            except Exception:
+                pass
+    except (ImportError, AttributeError):
+        pass
+
+except Exception:
+    logger = logging.getLogger("pythonagent.agent")
+    logger.exception("Exception in agent startup.")
+finally:
+    pass
+    # appdynamics.agent.load_sitecustomize()
+

pythonagent/cavisson/netdiagnostics/CavAgent/instrumentationprofile.json

@@ -0,0 +1,26 @@
+{
+	"modules": [
+		{
+			"moduleName": "run",
+			"moduleLevelMethod": [
+				{
+					"name": "http_callout",
+					"signature": "NA"
+				},
+				{
+					"name": "first",
+					"signature": "NA"
+				},
+				{
+					"name": "second",
+					"signature": "NA"
+				},
+				{
+					"name": "db_callout",
+					"signature": "NA"
+				}
+			],
+			"classes": []
+		}
+	]
+}

pythonagent/cavisson/netdiagnostics/CavAgent/interceptor_points.txt

@@ -0,0 +1,29 @@
+# Entry points
+flask
+django.core.handlers.wsgi
+django.core.handlers.base
+bottle
+tornado.web
+
+# HTTP exit calls
+httplib
+http.client
+urllib3
+requests
+tornado.httpclient
+boto.https_connection
+
+# Logging
+logging
+
+# SQL exit calls
+psycopg2
+pymysql.connections
+mysql.connector.connection
+MySQLdb.connections
+
+# MongoDB
+pymongo
+
+#REDIS
+redis.connection

pythonagent/cavisson/netdiagnostics/python/CavAgent/instrumentationprofile.json

@@ -0,0 +1,42 @@
+{
+	"modules": [
+		{
+			"moduleName": "run",
+			"moduleLevelMethod": [
+				{
+					"name": "http_callout",
+					"signature": "NA"
+				},
+				{
+					"name": "first",
+					"signature": "NA"
+				},
+				{
+					"name": "second",
+					"signature": "NA"
+				}
+			],
+			"classes": []
+		},
+		{
+			"moduleName": "dynamodb",
+			"moduleLevelMethod": [
+				{
+					"name": "dynamodb_callout",
+					"signature": "NA"
+				}
+			],
+			"classes": []
+		},
+		{
+			"moduleName": "s3",
+			"moduleLevelMethod": [
+				{
+					"name": "s3_callout",
+					"signature": "NA"
+				}
+			],
+			"classes": []
+		}
+	]
+}

pythonagent/cavisson/netdiagnostics/python/CavAgent/interceptor_points.txt

@@ -0,0 +1,29 @@
+# Entry points
+flask
+django.core.handlers.wsgi
+django.core.handlers.base
+bottle
+tornado.web
+
+# HTTP exit calls
+httplib
+http.client
+urllib3
+requests
+tornado.httpclient
+boto.https_connection
+
+# Logging
+logging
+
+# SQL exit calls
+psycopg2
+pymysql.connections
+mysql.connector.connection
+MySQLdb.connections
+
+# MongoDB
+pymongo
+
+#REDIS
+redis.connection

pythonagent/cavisson/netdiagnostics/python/config/ndsettings.conf

@@ -0,0 +1,6 @@
+tier=phpyii
+server=10.10.60.225
+Instance=PythonInstance
+ndcHost=10.10.60.226
+ndcPort=443
+NDC_COMM_PROTOCOL=TCP

pythonagent/config.py

@@ -0,0 +1,279 @@
+
+from __future__ import unicode_literals
+import logging
+import os
+import configparser
+cofig= configparser.RawConfigParser()
+import sys
+
+from configparser import ConfigParser
+
+try:
+    ospath = os.environ.get('NDHOME')
+    path = ospath + '/python/config/ndsettings.conf'
+except Exception as e:
+    print("ND HOME NOT SET")
+    raise e
+
+#print("path of  NDC config : ", path)
+
+#configParser.read(path)
+#path_for_insProfile = configParser.get('PYTHON_AGENT', 'path_profile')
+
+myvars = {}
+with open(path) as myfile:
+    for line in myfile:
+        name, var = line.partition("=")[::2]
+        myvars[name.strip()] = var
+        #print("myvars----------------------->",myvars)
+#TIER = myvars['tier'].strip('\n')
+#SERVER = myvars['server'].strip('\n')
+
+
+
+
+int_or_none = lambda v: int(v) if v != '' else None
+on_off = lambda v: v.lower() in ('on', 'true', 'yes', 'y', 't', '1')
+comma_seperated_list = lambda v: v.replace(' ', '').split(',')
+
+keys = lambda d: d.keys()
+values = lambda d: d.values()
+# Configuration Options
+
+_CONFIG_OPTIONS_BY_SECTION = {
+
+    'agent': {
+        'app': ('APP_NAME', None),
+        'tier': ('TIER_NAME', None),
+        'node': ('NODE_NAME', None),
+        'dir': ('DIR', None),
+    },
+
+    'wsgi': {
+        'script': ('WSGI_SCRIPT_ALIAS', None),
+        'callable': ('WSGI_CALLABLE_OBJECT', None),
+        'module': ('WSGI_MODULE', None),
+    },
+
+    'asgi': {
+        'module': ('ASGI_MODULE', None),
+        'callable': ('ASGI_CALLABLE_OBJECT', None),
+    },
+
+    'log': {
+        'dir': ('LOGS_DIR', None),
+        'level': ('LOGGING_LEVEL', None),
+        'debugging': ('DEBUG_LOG', on_off)
+    },
+
+    'proxy': {
+        'proxymode': ('PROXY_MODE', None),
+        'proxycontype': ('PROXY_CON_TYPE', None),
+        'proxyip': ('PROXY_IP', None),
+        'proxyport': ('PROXY_PORT', None),
+        'sopath': ('SO_PATH', None),
+       },
+}
+
+
+# Defaults ###########
+
+
+CONFIG_FILE = ''
+
+# Agent
+APP_NAME = 'CavAgent'
+#TIER_NAME = 'test_tier'
+#NODE_NAME = 'test'
+DIR = ospath + '/python/hooksettings'
+try:
+    TIER = myvars['tier'].strip('\n')
+    SERVER = myvars['server'].strip('\n')
+except:
+    TIER = "Default"
+    SERVER = "Default"
+
+# Logging
+LOGS_DIR = ospath+'/python/logs'
+print("LOGS_DIR", LOGS_DIR)
+
+if "CAV_APP_AGENT_LOGGINGLEVEL" in os.environ:
+    LOGGING_LEVEL = os.environ.get('CAV_APP_AGENT_LOGGINGLEVEL')
+else:
+    LOGGING_LEVEL = "WARNING"
+
+DEBUG_LOG = False
+
+
+# WSGI
+WSGI_MODULE = ''
+#WSGI_SCRIPT_ALIAS = '/home/cavisson/shop/my-shop/wsgi_example_app.py'
+#WSGI_SCRIPT_ALIAS = input("Enter the absolute path of WSGI application script. (command to get 'readlink -f <script_path.py>') : ")
+WSGI_SCRIPT_ALIAS = ''
+WSGI_CALLABLE_OBJECT = ''
+
+# ASGI
+ASGI_MODULE = ''
+ASGI_CALLABLE_OBJECT = ''
+
+# Controller
+CONTROLLER_HOST = '10.20.0.85'
+CONTROLLER_PORT = '7892'
+SSL_ENABLED = False
+ACCOUNT_NAME = ''
+ACCOUNT_ACCESS_KEY = ''
+HTTP_PROXY_HOST = '10.20.0.79'
+HTTP_PROXY_PORT = '1112'
+HTTP_PROXY_USER = ''
+HTTP_PROXY_PASSWORD_FILE = ''
+'''
+# Proxy Runtime
+PROXY_RUN_DIR = ''
+
+# Proxy Control Service
+PROXY_CONTROL_PATH = ''
+PROXY_STARTUP_READ_TIMEOUT_MS = 2000
+PROXY_STARTUP_INITIAL_RETRY_DELAY_MS = 5000
+PROXY_STARTUP_MAX_RETRY_DELAY_MS = 300000
+
+# Config Service
+PROXY_CONFIG_SOCKET_NAME = '0'
+CONFIG_SERVICE_RELOAD_INTERVAL_MS = 5000
+CONFIG_SERVICE_MAX_RETRIES = 3
+
+# Transaction Service
+PROXY_INFO_SOCKET_NAME = '0'
+PROXY_REPORTING_SOCKET_NAME = '1'
+BT_INFO_REQUEST_TIMEOUT_MS = 100
+
+# Snapshot Service
+INCLUDE_AGENT_FRAMES = False
+SNAPSHOT_PROFILER_INTERVAL_MS = 10
+EXIT_CALL_DETAILS_LENGTH = 100
+FORCED_SNAPSHOT_INTERVAL = 10
+
+# Transaction Monitor Service
+BT_MAX_DURATION_MS = 30 * 60 * 1000
+BT_ABANDON_THRESHOLD_MULTIPLIER = 6
+
+# EUM
+EUM_DISABLE_COOKIE = False
+EUM_USER_AGENT_WHITELIST = ['Mozilla', 'Opera', 'WebKit', 'Nokia']
+'''
+#RUNNING_MODE = 0
+
+# Approach 7: mapping from uWSGI native env vars to Cavisson CAV_* equivalents.
+# uWSGI exposes its own config as UWSGI_* env vars when started via env vars.
+# UWSGI_WSGI maps to --wsgi-file; UWSGI_MODULE maps to --module; UWSGI_CALLABLE to --callable.
+_UWSGI_ENV_MAP = {
+    'UWSGI_MODULE':   'CAV_WSGI_MODULE',
+    'UWSGI_WSGI':     'CAV_WSGI_SCRIPT_ALIAS',
+    'UWSGI_CALLABLE': 'CAV_WSGI_CALLABLE_OBJECT',
+}
+
+
+def map_uwsgi_environ():
+    """Translate UWSGI_* env vars into CAV_* equivalents, without overwriting
+    values the operator has already set explicitly via CAV_* vars."""
+    for uwsgi_var, cav_var in _UWSGI_ENV_MAP.items():
+        if uwsgi_var in os.environ and cav_var not in os.environ:
+            os.environ[cav_var] = os.environ[uwsgi_var]
+
+
+def validate_config(config):
+
+    return True
+
+
+def parse_environ(environ=None, prefix='CAV_'):
+
+    logger = logging.getLogger('pythonagent.agent')
+    environ = environ if environ is not None else os.environ
+
+    config = {}
+    config_file = environ.get('CAV_CONFIG_FILE')
+
+    if config_file:
+        config = parse_config_file(config_file)
+
+    #environ['SO_PATH'] = config['SO_PATH']
+    option_descrs = {}
+
+    for options in values(_CONFIG_OPTIONS_BY_SECTION):
+        for name, handler in values(options):
+            option_descrs[prefix + name] = (name, handler)
+
+    for option in keys(environ):
+        if option not in option_descrs:
+            continue
+
+        name, handler = option_descrs[option]
+
+        try:
+            value = environ[option]
+            if handler:
+                value = handler(value)
+            config[name] = value
+        except:
+            logger.exception('ignoring %s from environment, parsing value caused exception', option)
+
+    return config
+
+
+def parse_config_file(filename):
+    return None
+    logger = logging.getLogger('pythonagent.agent')
+
+    try:
+        config = {}
+        parser = ConfigParser()
+
+        with open(filename) as fp:
+            parser.read_file(fp)
+
+        for section_name in parser.sections():
+            try:
+                options_map = _CONFIG_OPTIONS_BY_SECTION[section_name]
+            except KeyError:  # Unknown section
+                logger.warning('%s: skipping unrecognized section [%s]', filename, section_name)
+                continue
+
+            for option_name in parser.options(section_name):
+                try:
+                    env_name, handler = options_map[option_name]
+
+                    value = parser.get(section_name, option_name)
+                    if handler:
+                        value = handler(value)
+
+                    config[env_name] = value
+                except KeyError:  # Unknown option
+                    logger.warning('%s: skipping unrecognized option %r of section [%s]',
+                                   filename, option_name, section_name)
+                except:  # Other errors
+                    logger.exception('%s: parsing value for option %r of section [%s] raised exception',
+                                     filename, option_name, section_name)
+
+        return config
+    except:
+        logger.exception('Parsing config file failed.')
+
+
+def merge(config):
+
+    #mod = globals()
+    #mod.update(config)
+    update_computed_defaults()
+
+
+def update_computed_defaults():
+    global LOGS_DIR, PROXY_CONTROL_PATH, PROXY_RUN_DIR
+
+    PROXY_RUN_DIR = os.path.join(DIR, 'run')
+
+    #if not PROXY_CONTROL_PATH:
+    #    PROXY_CONTROL_PATH = os.path.join(PROXY_RUN_DIR, 'comm')
+
+    if not LOGS_DIR:
+        LOGS_DIR = os.path.join(DIR, 'logs')
+