cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/find.py

@@ -0,0 +1,72 @@
+import os
+import ast
+import json
+
+import sys
+py_ver = sys.version_info[0]
+
+local = False
+
+def find(path):
+    modules = []
+    default_path = []
+    for root, dirs, files in os.walk(path):
+        for file in files:
+            # print(file)
+            if file.endswith(".py"):
+                default_path.append(os.path.join(root, file))
+                file = file[:-3]  # Remove .py extension
+                modules.append(file)
+
+    # print("modules", modules)
+    # print("\n\n")
+    # print("default_path", default_path)
+    # print("\n\n")
+
+    path_module_dict = dict(zip(default_path, modules))
+
+    data = {
+        "modules": [
+            {
+                "moduleName": path_module_dict[filename],
+                "moduleLevelMethod": [
+                    {
+                        "name": f_name.name,
+                        "signature": [a.arg if py_ver == 3 else a.id for a in f_name.args.args]
+                        # "signature": [[a.arg for a in f_name.args.args],[f_name.returns]]
+
+                    }
+                    for f_name in [n for n in ast.parse(open(filename).read()).body if isinstance(n, ast.FunctionDef)]
+                ],
+                "classes": [
+                    {
+                        "className": cname.name,
+                        "classLevelMethods": [
+                            {
+                                "name": clm_name.name,
+                                "signature": [a.arg if py_ver == 3 else a.id for a in clm_name.args.args]
+                                # "signature": [[a.arg for a in clm_name.args.args], [clm_name.returns]]
+
+                            }
+                            for clm_name in [n for n in cname.body if isinstance(n, ast.FunctionDef)]
+                        ]
+                    }
+                    for cname in [n for n in ast.parse(open(filename).read()).body if isinstance(n, ast.ClassDef)]
+                ]
+            }
+            for filename in default_path
+        ]
+    }
+
+    json_object = json.dumps(data, indent=2)
+    # print("\n\n\n\n")
+    # print(json_object)
+    # return str(json_object)
+
+    with open(os.environ.get('NDHOME') + "/python/CavAgent/instrumentationprofile.json", "w") as outfile:
+        outfile.write(json_object)
+        #print(outfile)
+
+if local:
+    path = "/home/cavisson/shop/my-shop/pythonagent/"
+    find(path)

pythonagent/find_mod_cls_name.py

@@ -0,0 +1,54 @@
+import sys
+import os
+import ast
+import json
+
+#path ="C:/Users/garima.singh/PycharmProjects/django_redis_demo"
+path ="/home/cavisson/shop/my-shop/pythonagent_garima"
+
+modules = []
+default_path = []
+
+for root, dirs, files  in os.walk(path):
+    for file in files:
+        if(file.endswith(".py")):
+            modules.append(file)
+            default_path.append(os.path.join(root,file))
+           
+print("modules",modules)
+print("default_path",default_path)
+
+
+data = {
+  "modules": [
+    {
+      "moduleName": filename,
+      "moduleLevelMethod": [
+      {
+        "name":fname.name ,
+        "signature":"NA"
+      }
+      for fname in [n for n in ast.parse(open(filename).read()).body if isinstance(n, ast.FunctionDef)]
+      ],
+      "classes": [
+        {
+          "className": cname.name,
+          "classLevelMethods": [
+      {
+        "name":clmname.name,
+        "signature":"NA"
+     
+      } 
+        for clmname in [n for n in cname.body if isinstance(n, ast.FunctionDef)]      
+      ]
+        }
+        for cname in [n for n in ast.parse(open(filename).read()).body if isinstance(n, ast.ClassDef)]
+      ]
+    }
+    for filename in default_path
+   ]
+   }
+
+json_object = json.dumps(data, indent = 2) 
+with open("sample_json.json", "w") as outfile: 
+    outfile.write(json_object)

pythonagent/lang.py

@@ -0,0 +1,131 @@
+from __future__ import unicode_literals
+import functools
+import inspect
+import itertools
+import os
+import sys
+
+# The aim here is make Python 2 behave like Python 3.
+# This means we write code in modern Python 3 style, where everything is an
+# iterator, everything is unicode etc.
+
+# pylint: disable=import-error,no-name-in-module,no-member,undefined-variable
+
+SUPER_FUN_HAPPY_PYTHON = sys.version_info[0] > 2
+
+if SUPER_FUN_HAPPY_PYTHON:
+    # Imports
+    # from configparser import SafeConfigParser
+    # from http.client import HTTPConnection, HTTPSConnection
+    # from http.cookies import SimpleCookie
+    try:
+        from importlib import reload
+    except ImportError:
+        from imp import reload
+    import queue
+    import _thread as thread
+    from urllib.request import urlopen
+    from urllib.parse import parse_qs, parse_qsl, urlparse
+
+    # Types
+    bytes_t = bytes
+    long_t = int
+    str_t = str
+
+    # Functions
+    filter = filter
+    getcwd = os.getcwd
+    items = lambda d: d.items()
+    keys = lambda d: d.keys()
+    long = int
+    map = map
+    range = range
+    wraps = functools.wraps
+    values = lambda d: d.values()
+    zip = zip
+
+    def get_args(callable):
+        return inspect.signature(callable).parameters
+
+    import importlib
+
+    def import_module(name):
+        return importlib.import_module(name)
+else:
+    # Imports
+    from __builtin__ import reload
+    from ConfigParser import SafeConfigParser
+    from Cookie import SimpleCookie
+    from httplib import HTTPConnection, HTTPSConnection
+    import Queue as queue
+    import thread
+    from urllib import urlopen
+    from urlparse import parse_qs, parse_qsl, urlparse
+
+    # Types
+    bytes_t = bytes
+    long_t = long
+    str_t = unicode
+
+    # Functions
+    filter = lambda f, it: itertools.ifilter(f, it)
+    getcwd = os.getcwdu
+    items = lambda d: d.iteritems()
+    keys = lambda d: d.iterkeys()
+    long = long
+    map = lambda f, *it: itertools.imap(f, *it)
+    range = xrange
+    values = lambda d: d.itervalues()
+    zip = lambda *it: itertools.izip(*it)
+
+    def get_args(callable):
+        return inspect.getargspec(callable).args
+
+    import imp
+
+    def import_module(name):
+        file, pathname, desc = imp.find_module(name)
+        try:
+            return imp.load_module(name, file, pathname, desc)
+        finally:
+            if file is not None:
+                file.close()
+
+    # modified from https://github.com/michilu/python-functools32/blob/master/functools32/functools32.py
+    def _update_wrapper(wrapper, wrapped, assigned=functools.WRAPPER_ASSIGNMENTS, updated=functools.WRAPPER_UPDATES):
+        wrapper.__wrapped__ = wrapped
+        for attr in assigned:
+            try:
+                value = getattr(wrapped, attr)
+            except AttributeError:
+                pass
+            else:
+                setattr(wrapper, attr, value)
+        for attr in updated:
+            getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
+        return wrapper
+
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS, updated=functools.WRAPPER_UPDATES):
+        return functools.partial(_update_wrapper, wrapped=wrapped, assigned=assigned, updated=updated)
+
+# Common Stuff
+native_str = str
+reduce = functools.reduce
+
+
+def bytes(s, encoding='utf-8'):
+    # Encode all bytes strings as utf-8.
+    if isinstance(s, bytes_t):
+        return s
+    else:
+        # This None thing isn't ideal, but since we use this function mainly
+        # for making byte strings for protobufs, we want None to stay None.
+        return None if s is None else s.encode(encoding)
+
+
+def str(s, encoding='utf-8'):
+    # Assume all bytes strings are utf-8 encoded.
+    if isinstance(s, bytes_t):
+        return s.decode(encoding)
+    else:
+        return str_t(s)

pythonagent/lib.py

@@ -0,0 +1,91 @@
+
+"""Utilities for Cavisson Python Agent code.
+
+"""
+
+from __future__ import unicode_literals
+import errno
+
+from logging import Formatter
+import os
+
+#mport _thread as thread
+from .lang import thread
+
+get_ident = lambda: thread.get_native_id()
+
+items = lambda d: d.items()
+
+
+default_log_formatter = Formatter('%(asctime)s [%(levelname)s] %(funcName)s(%(lineno)d) <%(process)d>: %(message)s')
+
+class LazyWsgiRequest(object):
+    """Lazily read request line and headers from a WSGI environ.
+
+    This matches enough of the Werkzeug Request API for the agent's needs: it
+    only provides access to the information in the request line and the
+    headers that is needed for the agent. (Since the agent doesn't inspect
+    the request body, we don't touch any of that.)
+
+    Parameters
+    ----------
+    environ : dict
+        A WSGI environment.
+
+    Attributes
+    ----------
+    headers : dict
+        A dictionary of the HTTP headers. The headers are lowercase with
+        dashes separating words.
+    method : str
+        The request method (e.g., GET).
+    url : str
+        The URL of the request (reconstructed according to PEP 333).
+    cookies : dict
+        The cookies passed in the request header (if any).
+    path : str
+        The path part of the request. Note that unlike raw WSGI, this will be
+        just '/' if it would otherwise be empty.
+    args : dict
+        The query parameters. This is not a multi-dict: if a parameter is
+        repeated multiple times, one of them wins.
+    referer : str
+        The HTTP Referer string.
+    user_agent : str
+        The HTTP User-Agent string.
+    is_ajax : bool
+        True if this request is AJAX.
+    is_mobile : bool
+        True if this request is from mobile.
+
+    """
+    DEFAULT_PORTS = {
+        'http': 80,
+        'https': 443,
+    }
+
+    def __init__(self, environ):
+        super(LazyWsgiRequest, self).__init__()
+        self.environ = environ.copy()
+
+        self._headers = None
+        self._host = None
+        self._port = None
+        self._http_host = None
+        self._url = None
+        self._path = None
+        self._args = None
+        self._cookies = None
+
+def mkdir(path):
+    """Create the directory in path, creating any intermediate directories.
+
+    Does not complain if the directory already exists.
+
+    """
+    try:
+        os.makedirs(path)
+        #print("Logging path: ",path)
+    except OSError as exc:
+        if exc.errno != errno.EEXIST:
+            raise

pythonagent/main/pytrace/__init__.py

@@ -0,0 +1,79 @@
+
+
+HELP_OPTIONS = ('--help', '-h', '-?')
+
+items = lambda d: d.items()
+keys = lambda d: d.keys()
+
+class CommandInvocationError(Exception):
+    pass
+
+
+class CommandExecutionError(Exception):
+    pass
+
+
+def parse_options(option_descrs, args):
+    options = {}
+
+    required = set()
+    short_flags = {}
+    for opt, opt_descr in items(option_descrs):
+        if isinstance(opt_descr, dict):
+            if 'short' in opt_descr:
+            # short_flags[opt_descr['short'][0]] = opt
+                short_flags[opt_descr['short']] = opt
+            if opt_descr.get('required', False):
+                required.add(opt)
+
+    i = 0
+    argc = len(args)
+
+    while i < argc and args[i][:1] == '-':  # While there's an arg and it's an option...
+        arg = args[i]
+
+        if arg == '--' or arg == '-':       # The option to end all options.
+            i += 1                          # Skip the dash.
+            break
+
+        if arg in HELP_OPTIONS:             # Help options short circuit everything.
+            return {'help': True}, []
+
+        if arg[1] == '-':                   # Long option.
+            opt = arg[2:]
+        else:                               # Short option.
+            #             opt = short_flags.get(arg[1:])
+            opt = short_flags.get(arg[1:])
+
+        if opt not in option_descrs:
+            raise CommandInvocationError('unrecognized option: %s' % arg)
+
+        option_descr = option_descrs[opt]
+
+        if isinstance(option_descr, dict) and option_descr.get('value'):
+            value_label = option_descr.get('value_help', '<value>')
+            i += 1
+
+            if i >= argc:
+                raise CommandInvocationError('missing value for option: %s %s' % (arg, value_label))
+
+            options[opt] = args[i]
+        else:
+            options[opt] = True
+
+        i += 1
+
+    missing = ['--%s' % r for r in required - set(keys(options))]
+
+    if missing:
+        plural = 's' if len(missing) != 1 else ''
+        missing = ', '.join(missing)
+        raise CommandInvocationError('missing required option%s: %s' % (plural, missing))
+
+    return options, args[i:]
+
+
+
+
+
+

pythonagent/main/pytrace/commands/auto_discovery.py

@@ -0,0 +1,25 @@
+from pythonagent.find import find
+import traceback
+import sys
+
+py_ver = sys.version_info[0]
+
+USAGE = "auto discovery to generate instrumentation profile"
+ABOUT = "Command to push auto discovery feature of Python Agent"
+
+
+def command(options, args):
+    # Calling auto discovery method to discover and create instrumentation profile
+    #print(args[0])
+    #if args[0] is None:
+    #    raise TypeError("'None' value provided for application path !!")   
+    try: 
+        find(args[0])
+        print('auto discovery called, Instrumentation profile has been generated !!')
+    except:
+        if py_ver == 3: 
+            traceback.print_exc(limit=None, file=None, chain=True)
+        else:
+            print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file)
+            print('No path provided for application !!\nPlease provide application path along with commond.')
+