cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/main/pytrace/commands/run.py

@@ -0,0 +1,401 @@
+import errno
+import os
+import sys
+#from agent.internal.proxy import Proxy
+from pythonagent.main.pytrace import CommandInvocationError, CommandExecutionError
+
+USAGE = "run <command> [args...]"
+
+ABOUT = """Run a program with the agent enabled.
+
+Use this command to instrument a Python application. If <command> is not the
+path to an executable, the command is looked for in your PATH. The command may
+be a Python interpreter or a supported server that embeds Python (like uwsgi
+and gunicorn).
+
+For example, if you normally run your application as below commands:
+
+   1) python manage.py runserver --norelaod 10:20.0.117:6062
+   2) gunicorn -w 4 -b unix:acme.sock acme.app:app
+
+You can run the same application instrumented by pythonagent with below commands:
+    
+   1) cavagent run python manage.py runserver --norelaod 10:20.0.117:6062 
+   2) cavagent run -- gunicorn -w 4 -b unix:acme.sock acme.app:app
+
+
+The agent requires the TestRun to be running. If it
+is not running, your application will not be start.
+
+"""
+
+OPTION = {
+    'cli': 'run in CLI mode',
+    
+    # 'no-watchdog': 'disable the watchdog when auto-starting proxy',
+    
+    'config-file': {
+        'short': 'c',
+        'help': 'the config file to use',
+        'value': True,
+        'value_help': '<file>',
+    },
+    
+    'app': {
+        'short': 'a',
+        'help': 'the name of the app',
+        'value': True,
+        'value_help': '<app>',
+    },
+    'tier': {
+        'short': 't',
+        'help': 'the name of the tier',
+        'value': True,
+        'value_help': '<tier>',
+    },
+    # 'node': {
+    #     'short': 'n',
+    #     'help': 'the name of the node',
+    #     'value': True,
+    #     'value_help': '<node>',
+    # },
+
+    # 'controller': {
+    #     'short': 'h',
+    #     'help': 'the host (and optionally port) of the controller',
+    #     'value': True,
+    #     'value_help': '<host>[:<port>]',
+    # },
+
+    # 'ssl': {
+    #     'help': 'pass to use SSL with the controller',
+    # },
+    #
+    # 'no-ssl': {
+    #     'help': 'pass to disable SSL with the controller (the default)',
+    # },
+
+    'proxyMode': {
+        'short': 'pmode',
+        'help': 'proxyMode',
+        'value': True,
+        'value_help': '<proxyMode>  value - [0/1]',
+    },
+
+    'proxyConType': {
+        'short': 'pctype',
+        'help': 'please enter proxy con type ',
+        'value': True,
+        'value_help': '<proxyConType> value - [0/1]',
+    },
+
+    'proxyIP': {
+        'short': 'pip',
+        'help': 'please enter proxy IP host address',
+        'value': True,
+        'value_help': '<proxyConType>',
+    },
+
+    'proxyPort': {
+        'short': 'pport',
+        'help': 'please enter proxy port number ',
+        'value': True,
+        'value_help': '<proxyPort>',
+    },
+
+    # Internal / undocumented options
+
+    # 'run-proxy-script': {
+    #     'help': False,     # "Path to runProxy script"
+    #     'value': True,
+    # },
+    #
+    # 'proxy-args': {
+    #     'help': False,  # "Command line arguments to pass to runProxy"
+    #     'value': True,
+    # },
+
+}
+
+
+# ---------------------------------------------------------------------------
+# uWSGI argument / config-file rewriting helpers (Approaches 1-6)
+# ---------------------------------------------------------------------------
+
+def _get_agent_wsgi_path():
+    """Return the absolute filesystem path to pythonagent/main/wsgi.py."""
+    import pythonagent.main.wsgi as _m
+    return os.path.abspath(_m.__file__.replace('.pyc', '.py'))
+
+
+def _parse_uwsgi_ini(path):
+    """Parse a uWSGI INI config file and return the [uwsgi] section as a dict."""
+    import configparser
+    parser = configparser.RawConfigParser()
+    parser.read(path)
+    section = 'uwsgi'
+    if not parser.has_section(section):
+        return {}
+    return dict(parser.items(section))
+
+
+def _parse_uwsgi_xml(path):
+    """Parse a uWSGI XML config file and return top-level tags as a dict."""
+    import xml.etree.ElementTree as ET
+    try:
+        root = ET.parse(path).getroot()
+        return {child.tag: (child.text or '') for child in root}
+    except Exception:
+        return {}
+
+
+def _parse_uwsgi_yaml(path):
+    """Parse a uWSGI YAML config file and return the 'uwsgi' key as a dict.
+    Returns an empty dict silently when PyYAML is not installed."""
+    try:
+        import yaml
+        with open(path) as f:
+            data = yaml.safe_load(f)
+        return data.get('uwsgi', {}) if isinstance(data, dict) else {}
+    except ImportError:
+        return {}
+    except Exception:
+        return {}
+
+
+def _parse_uwsgi_json(path):
+    """Parse a uWSGI JSON config file and return the 'uwsgi' key as a dict."""
+    import json
+    try:
+        with open(path) as f:
+            data = json.load(f)
+        return data.get('uwsgi', {}) if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _apply_uwsgi_config(cfg, args, environ):
+    """Given a dict parsed from a uWSGI config file, extract the WSGI app
+    location and inject it into environ as CAV_* vars.  Appends a
+    --wsgi-file override pointing at the agent entry point so uWSGI loads
+    the agent wrapper instead of the user app directly."""
+    agent_wsgi = _get_agent_wsgi_path()
+    if 'module' in cfg and 'CAV_WSGI_MODULE' not in environ:
+        environ['CAV_WSGI_MODULE'] = cfg['module']
+        args += ['--wsgi-file', agent_wsgi]
+    elif 'wsgi-file' in cfg and 'CAV_WSGI_SCRIPT_ALIAS' not in environ:
+        environ['CAV_WSGI_SCRIPT_ALIAS'] = cfg['wsgi-file']
+        args += ['--wsgi-file', agent_wsgi]
+    if 'callable' in cfg and 'CAV_WSGI_CALLABLE_OBJECT' not in environ:
+        environ['CAV_WSGI_CALLABLE_OBJECT'] = cfg['callable']
+
+
+def _rewrite_uwsgi_args(args, environ):
+    """Scan uWSGI command-line arguments and rewrite them so that:
+
+    * --wsgi-file  → value saved to CAV_WSGI_SCRIPT_ALIAS; replaced with the
+                     agent's pythonagent/main/wsgi.py entry point.
+    * --module/-w  → value saved to CAV_WSGI_MODULE; arg replaced with an
+                     equivalent --wsgi-file pointing at the agent entry point.
+    * --callable   → value saved to CAV_WSGI_CALLABLE_OBJECT (kept in args).
+    * --ini/--xml/--yaml/--json  → config file parsed; WSGI keys extracted and
+                     --wsgi-file override appended (Approaches 3-6).
+
+    All other uWSGI arguments (--processes, --socket, --master …) are left
+    untouched so uWSGI continues to function normally.
+
+    Returns (rewritten_args, updated_environ).
+    """
+    if not args or os.path.basename(args[0]) not in ('uwsgi', 'uwsgi3'):
+        return args, environ
+
+    args = list(args)
+    environ = dict(environ)   # work on a copy; caller replaces os.environ at the end
+    agent_wsgi = _get_agent_wsgi_path()
+    i = 1  # args[0] is the uwsgi binary itself
+
+    while i < len(args):
+        arg = args[i]
+
+        # ---- Approach 1: --wsgi-file ----------------------------------------
+        if arg in ('--wsgi-file', '--wsgi') and i + 1 < len(args):
+            environ.setdefault('CAV_WSGI_SCRIPT_ALIAS', args[i + 1])
+            args[i + 1] = agent_wsgi
+            i += 2
+
+        elif arg.startswith('--wsgi-file=') or arg.startswith('--wsgi='):
+            key, val = arg.split('=', 1)
+            environ.setdefault('CAV_WSGI_SCRIPT_ALIAS', val)
+            args[i] = key + '=' + agent_wsgi
+            i += 1
+
+        # ---- Approach 1: --callable -----------------------------------------
+        elif arg == '--callable' and i + 1 < len(args):
+            environ.setdefault('CAV_WSGI_CALLABLE_OBJECT', args[i + 1])
+            i += 2
+
+        elif arg.startswith('--callable='):
+            environ.setdefault('CAV_WSGI_CALLABLE_OBJECT', arg.split('=', 1)[1])
+            i += 1
+
+        # ---- Approach 2: --module / -w --------------------------------------
+        elif arg in ('--module', '-w') and i + 1 < len(args):
+            environ.setdefault('CAV_WSGI_MODULE', args[i + 1])
+            args[i]     = '--wsgi-file'
+            args[i + 1] = agent_wsgi
+            i += 2
+
+        elif arg.startswith('--module='):
+            environ.setdefault('CAV_WSGI_MODULE', arg.split('=', 1)[1])
+            args[i] = '--wsgi-file=' + agent_wsgi
+            i += 1
+
+        # ---- Approach 3: --ini ----------------------------------------------
+        elif arg == '--ini' and i + 1 < len(args):
+            _apply_uwsgi_config(_parse_uwsgi_ini(args[i + 1]), args, environ)
+            i += 2
+
+        elif arg.startswith('--ini='):
+            _apply_uwsgi_config(_parse_uwsgi_ini(arg.split('=', 1)[1]), args, environ)
+            i += 1
+
+        # ---- Approach 4: --xml ----------------------------------------------
+        elif arg == '--xml' and i + 1 < len(args):
+            _apply_uwsgi_config(_parse_uwsgi_xml(args[i + 1]), args, environ)
+            i += 2
+
+        elif arg.startswith('--xml='):
+            _apply_uwsgi_config(_parse_uwsgi_xml(arg.split('=', 1)[1]), args, environ)
+            i += 1
+
+        # ---- Approach 5: --yaml ---------------------------------------------
+        elif arg == '--yaml' and i + 1 < len(args):
+            _apply_uwsgi_config(_parse_uwsgi_yaml(args[i + 1]), args, environ)
+            i += 2
+
+        elif arg.startswith('--yaml='):
+            _apply_uwsgi_config(_parse_uwsgi_yaml(arg.split('=', 1)[1]), args, environ)
+            i += 1
+
+        # ---- Approach 6: --json ---------------------------------------------
+        elif arg == '--json' and i + 1 < len(args):
+            _apply_uwsgi_config(_parse_uwsgi_json(args[i + 1]), args, environ)
+            i += 2
+
+        elif arg.startswith('--json='):
+            _apply_uwsgi_config(_parse_uwsgi_json(arg.split('=', 1)[1]), args, environ)
+            i += 1
+
+        else:
+            i += 1
+
+    return args, environ
+
+
+# ---------------------------------------------------------------------------
+
+def command(options, args):
+
+    '''
+    processname = 'TestRun'
+    tmp = os.popen("nsu_show_netstorm").read()
+    proccount = tmp.count(processname)
+
+    if proccount > 0:
+        print("TestRun is running...")
+    else:
+        print("ERROR!! TestRun is not running on this machine !!!\nKindly start the TestRun and try again...")
+        sys.exit(1)
+    '''
+    import bootstrap
+    pythonpath = [os.path.dirname(bootstrap.__file__), '.']
+
+    if not args:
+        raise CommandInvocationError('missing command: run <options> -- <command> [args...]')
+
+    environ = os.environ
+
+    if 'PYTHONPATH' in environ:
+        pythonpath.append(environ['PYTHONPATH'])
+
+    environ['PYTHONPATH'] = ':'.join(pythonpath)
+    #environ['CAV_APP_AGENT_ENV']= "NATIVE"
+    #environ['LD_LIBRARY_PATH'] = "/usr/local/lib"
+    environ['LD_PRELOAD'] = "libcavapr-1.so.0 libwebsockets.so"
+    #print('NDHOME set as ',environ.get('NDHOME'))
+    print("NDHOME Environment variable :", environ.get('NDHOME'))
+    if environ.get('NDHOME') is None:
+        #environ['NDHOME'] = "/opt/cavisson/netdiagnostics"
+        environ['NDHOME'] = "/opt/cavisson/netdiagnostics"
+        print("Taking Default NDHOME path",environ.get('NDHOME'))
+    environ['CAV_RUNNING_MODE'] = '0'
+    
+    if 'config-file' in options:
+        environ['CAV_CONFIG_FILE'] = options['config-file']
+    if 'app' in options:
+        environ['CAV_APP_NAME'] = options['app']
+    if 'tier' in options:
+        environ['CAV_TIER_NAME'] = options['tier']
+    if 'node' in options:
+        environ['CAV_NODE_NAME'] = options['node']
+    if 'proxyMode' in options:
+        environ['CAV_APP_AGENT_PROXYMODE'] = options['proxyMode']
+        if logger.isEnabledFor(logging.INFO):
+            logger.info("Using proxy mode from env %s=%s", 'CAV_APP_AGENT_PROXYMODE', environ['CAV_APP_AGENT_PROXYMODE'])
+    if 'proxyConType' in options:
+        environ['CAV_proxyConType'] = options['proxyConType']
+    if 'proxyIP' in options:
+        environ['CAV_APP_AGENT_PROXYIP'] = options['proxyIP']
+        if logger.isEnabledFor(logging.INFO):
+            logger.info("Using proxy IP from env %s=%s", 'CAV_APP_AGENT_PROXYIP', environ['CAV_APP_AGENT_PROXYIP'])
+    if 'proxyPort' in options:
+        environ['CAV_APP_AGENT_PROXYPORT'] = options['proxyPort']
+        if logger.isEnabledFor(logging.INFO):
+            logger.info("Using proxy port from env %s=%s", 'CAV_APP_AGENT_PROXYPORT', environ['CAV_APP_AGENT_PROXYPORT'])
+    environ['nd_init_done'] = '0'
+
+    # if 'ssl' in options:
+    #     environ['APPD_SSL_ENABLED'] = 'on'
+    # elif 'no-ssl' in options:
+    #     environ['APPD_SSL_ENABLED'] = 'off'
+
+    # if 'controller' in options:
+    #     value = options['controller']
+    #
+    #     if ':' in value:
+    #         host, port = value.split(':', 1)
+    #         environ['APPD_CONTROLLER_HOST'] = host
+    #         environ['APPD_CONTROLLER_PORT'] = port
+    #     else:
+    #         environ['APPD_CONTROLLER_HOST'] = value
+
+    # if 'use-manual-proxy' not in options:
+    #     proxy_args = []
+    #
+    #     if 'no-watchdog' in options:
+    #         proxy_args.append('--no-watchdog')
+    #
+    #     if 'run-proxy-script' in options:
+    #         proxy_args.append('--run-proxy-script')
+    #         proxy_args.append(options['run-proxy-script'])
+    #
+    #     if 'proxy-args' in options:
+    #         proxy_args.extend(shlex.split(options['proxy-args']))
+
+       # proxy.start(proxy_args)
+
+    try:
+        # Approaches 1-6: rewrite uWSGI args so the agent's wsgi.py becomes the
+        # entry point and the real app location is saved to CAV_WSGI_* env vars.
+        args, environ = _rewrite_uwsgi_args(args, environ)
+
+        os.execvpe(args[0], args, environ)
+
+
+    except OSError as exc:
+        if exc.errno == errno.ENOENT:
+            raise CommandExecutionError('%s: no such file or directory' % args[0])
+        elif exc.errno == errno.EPERM:
+            raise CommandExecutionError('%s: permission denied' % args[0])
+        raise
+

pythonagent/main/pytrace/pytrace.py

@@ -0,0 +1,133 @@
+# Copyright (c) cavisson, Inc., and its affiliates
+# 2015
+# All Rights Reserved
+
+import os
+import sys
+
+import sys,os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname( __file__ ))))
+
+
+from lang import keys
+from pythonagent.main.pytrace import CommandInvocationError, CommandExecutionError, parse_options, HELP_OPTIONS
+from pythonagent.main.pytrace.commands import run,auto_discovery
+
+pytrace = os.path.basename(sys.argv[0])
+
+
+COMMANDS = {
+    'run': run,
+    'auto_discovery': auto_discovery,
+}
+COMMANDS_ORDER = ["run"]
+
+HELP_TEMPLATE = """\
+USAGE
+    {pytrace} {usage}
+
+ABOUT
+    {about}"""
+
+USAGE = """\
+USAGE
+    {pytrace} <command> <args...>
+
+ABOUT
+    Cavisson Python Agent management utility
+
+COMMANDS
+    help                Print this message
+    help <command>      Show detailed help for the given pytrace command
+"""
+
+
+def main():
+    if len(sys.argv) < 2:
+        print_usage()
+
+
+    command = sys.argv[1]
+    args = sys.argv[2:]
+
+    if command in HELP_OPTIONS or command == 'help':
+        if args:
+            print_usage(command=args[0])
+        else:
+            print_usage()
+
+    if command not in COMMANDS:
+        print_usage(error="%s: unrecognized command" % command)
+
+    mod = COMMANDS[command]
+
+    try:
+        options, args = parse_options(getattr(mod, 'OPTIONS', {}), args)
+
+        if 'help' in options:
+            print_usage(command=command)
+
+        mod.command(options, args)
+
+    except CommandInvocationError as exc:
+        print_usage(command=command, error=str(exc))
+        #print("wrong usage!")
+    except CommandExecutionError as exc:
+        print(str(exc))
+
+
+def indent(text, spaces=4):
+    indentation = ' ' * spaces
+    indented_text = ('\n%s' % indentation).join(text.split('\n'))
+    return indented_text
+
+def print_usage(command=None, error=None):
+    if command and command not in COMMANDS:
+        error = '%s: unrecognized command' % command
+        command = None
+
+    if command:
+        mod = COMMANDS[command]
+        about = indent(mod.ABOUT.format(pytrace=pytrace))
+
+        print(HELP_TEMPLATE.format(pytrace=pytrace, usage=mod.USAGE, about=about))
+
+        if getattr(mod, 'OPTIONS', None):
+            print('OPTIONS')
+            for opt in sorted(keys(mod.OPTIONS)):
+                opt_descr = mod.OPTIONS[opt]
+                if isinstance(opt_descr, dict):
+                    if 'short' in opt_descr:
+                        opt = '%s / -%s' % (opt, opt_descr['short'])
+                    if opt_descr.get('value', False):
+                        opt += ' %s' % (opt_descr.get('value_help', ' <value>'))
+
+                    opt_help = opt_descr.get('help', False)
+
+                    if opt_help is False:
+                        continue
+
+                    if opt_descr.get('required', False):
+                        opt_help = 'REQUIRED: %s' % opt_help
+                else:
+                    opt_help = opt_descr
+
+                print('    --%-28s  %s' % (opt, opt_help))
+    else:
+        print(USAGE.format(pytrace=pytrace))
+
+        for cmd in COMMANDS_ORDER:
+            mod = COMMANDS[cmd]
+            first_line = mod.ABOUT.splitlines()[0]
+            print("    %-18s  %s" % (cmd, first_line))
+
+    if error:
+        prefix = "{pytrace} {command}".format(pytrace=pytrace, command=command) if command else pytrace
+        print('')
+        print("ERROR: {prefix}: {error}".format(prefix=prefix, error=error))
+
+    sys.exit(1 if error else 0)
+
+
+if __name__ == '__main__':
+    main()

pythonagent/main/wsgi.py

@@ -0,0 +1,6 @@
+from __future__ import unicode_literals
+
+from pythonagent.agent.probes.frameworks.wsgi import WSGIMiddleware
+#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>') : ")
+application = WSGIMiddleware()

pythonagent/main.py

@@ -0,0 +1,27 @@
+""""
+Local Testing for Python Agent on AWS Lambda
+"""
+
+import sys
+import os
+
+python_agent_parent_dir = os.path.abspath(os.path.join(__file__, "../.."))
+sys.path.append(python_agent_parent_dir)
+
+from pythonagent.bootstrap.cavagent_lambda_wrapper import handler
+
+
+if __name__ == "__main__":
+
+    event = {"path": "test_local_application"}
+
+    class Context:
+        def __init__(self):
+            self.log_stream_name = "test_request_id_localapp"
+            self.aws_request_id = "test_request_id_localapp"
+            self.function_name = "test_function_localapp"
+
+    context = Context()
+
+    response = handler(event, context)
+

pythonagent/run.py

@@ -0,0 +1,46 @@
+import requests
+import boto3
+from flask import Flask
+
+
+def http_callout():
+    print("Client Lambda - HTTP Callout Begin")
+    x = requests.get('https://www.facebook.com/')
+    # x = requests.put('https://httpbin.org/put', data={'key': 'value'})
+    # x = requests.post('https://www.w3schools.com/python/demopage.php', data={'key': 'value'})
+    # x = requests.delete('https://httpbin.org/delete', data={'key': 'value'})
+    print("Client Lambda - HTTP Callout End")
+
+
+def first():
+    print("Client Lambda - First Function")
+
+
+def second():
+    print("Client Lambda - Second Function")
+
+
+def db_callout():
+    print("Client Lambda - DB Callout Begin")
+    client = boto3.client('dynamodb')
+    print("client METHODS FOR THIS SESSION::", dir(client))
+    data = client.scan(TableName='Person')
+    item = {
+        "id": {"N": "556"},
+        "address": {"S": "United States"},
+        "firstName": {"S": "John"},
+        "lastName": {"S": "Doe"},
+        "age": {"N": "30"}
+    }
+    response = client.put_item(TableName='Person', Item=item)
+    print("Client Lambda - DB Call out Begin")
+
+
+def flask_wsgi():
+    app = Flask(__name__)
+
+    @app.route("/")
+    def hello_world():
+        return "<p>Hello, World!</p>"
+
+    app.run(port=6063)

pythonagent/sqins.py

@@ -0,0 +1,8 @@
+import sqlite3
+con = sqlite3.connect('checklist.db')
+con.execute("CREATE TABLE checklist(id INTEGER PRIMARY KEY,task VARCHAR(100) NOT NULL,description VARCHAR(200) NOT NULL,status VARCHAR(3) NOT NULL)")
+con.execute("INSERT INTO checklist(id,task,description,status) VALUES (1,'Task number 1', 'This is a description about Task number 1', 'Yes')")
+con.execute("INSERT INTO checklist(id,task,description,status) VALUES (2,'Task number 2', 'This is a description about Task number 2', 'Yes')")
+con.execute("INSERT INTO checklist(id,task,description,status) VALUES (3,'Task number 3', 'This is a description about Task number 3', 'Yes')")
+con.commit() 
+