cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/probes/sql/psycopg2.py

@@ -0,0 +1,174 @@
+
+
+"""Intercept the psycopg2 package.
+
+The interceptors in here are more complex than for other packages because the
+classes are defined in C extension code.  We have to wrap the connection and
+cursor classes with our own, which allows us to attach to the relevant methods.
+
+"""
+
+# pylint: disable=no-self-argument
+
+from __future__ import unicode_literals
+import re
+
+from pythonagent.lang import parse_qs, str, urlparse
+from ..base import BaseInterceptor
+from .dbapi import DbAPIConnectionInterceptor, DbAPICursorInterceptor
+
+# For format of PostgreSQL connection strings, see:
+# http://www.postgresql.org/docs/current/static/libpq-connect.html#LIBPQ-CONNSTRING
+
+KV_RE = re.compile(r'\s*(?P<key>[a-zA-Z_]+)\s*=\s*(?P<remainder>.+)')
+
+
+def parse_postgresql_url_dsn(dsn):
+    url = urlparse(dsn, allow_fragments=False)
+
+    if '?' in url.path:
+        parts = url.path.split('?', 1)
+        path, params = parts[0], parse_qs(parts[1])
+    else:
+        path = url.path
+        params = parse_qs(url.query) if url.query else {}
+
+    if 'host' in params:
+        host = params['host'][0]
+    else:
+        host = url.hostname or 'localhost'
+
+    if 'port' in params:
+        port = params['port'][0]
+    elif url.port:
+        port = str(url.port)
+    else:
+        port = '5432'
+
+    path = path.strip('/')
+
+    if 'dbname' in params:
+        dbname = params['dbname'][0]
+    elif path:
+        dbname = path
+    elif 'user' in params:
+        dbname = params['user'][0]
+    else:
+        dbname = url.username or 'postgres'
+
+    return host, port, dbname
+
+
+def parse_quoted_value(remainder):
+    length = len(remainder)
+    idx = 1
+
+    start_idx = idx
+    val = []
+
+    while idx < length and remainder[idx] != "'":
+        if remainder[idx:idx + 2] in ("\\\\", "\\'"):
+            # Valid escape sequence: collect the current run with the
+            # escaped character, move past the escape sequence, and start a
+            # new run.
+            val.append(remainder[start_idx:idx] + remainder[idx + 1])
+            idx += 2
+            start_idx = idx
+        else:
+            idx += 1
+
+    val.append(remainder[start_idx:idx])
+    return ''.join(val), remainder[idx + 1:]
+
+
+def parse_postgresql_kv_dsn(dsn):
+    if "'" not in dsn:  # Fast path when there are no quoted strings.
+        dsn = re.sub(r'(\s*=\s+|\s+=\s*)', '=', dsn).split()
+        parts = dict(pair.split('=', 1) for pair in dsn)
+    else:
+        parts = {}
+        m = KV_RE.match(dsn)
+
+        while m:
+            key, remainder = m.group('key'), m.group('remainder')
+
+            if remainder[0] == "'":
+                value, remainder = parse_quoted_value(remainder)
+            else:
+                split = remainder.split(None, 1)
+                if len(split) == 1:
+                    value, remainder = split[0], ''
+                elif split:
+                    value, remainder = split
+                else:
+                    break
+
+            parts[key] = value
+            m = KV_RE.match(remainder)
+
+    return parse_postgresql_keyword_args(parts)
+
+
+def parse_postgresql_keyword_args(parts):
+    host = parts.get('host', 'localhost')
+    port = parts.get('port', '5432')
+    dbname = parts.get('dbname', parts.get('user', 'postgres'))
+    user = parts.get('user', 'postgres')
+    return host, port, dbname, user
+
+
+def parse_postgresql_dsn(dsn=None, *args, **kwargs):
+    if dsn:
+        if dsn.startswith('postgresql://'):
+            return parse_postgresql_url_dsn(dsn)
+        else:
+            return parse_postgresql_kv_dsn(dsn)
+    else:
+        return parse_postgresql_keyword_args(kwargs)
+
+
+class Psycopg2ConnectionInterceptor(DbAPIConnectionInterceptor):
+    def get_backend_properties(self, conn, *args, **kwargs):
+        return parse_postgresql_dsn(*args, **kwargs) + ('POSTGRES',)
+
+
+class Psycopg2CursorInterceptor(DbAPICursorInterceptor):
+    def get_connection(self, cursor):
+        return cursor.connection
+
+
+class Psycopg2Interceptor(BaseInterceptor):
+    cursor_classes = {}
+
+    def _connect(self, connect, *args, **kwargs):
+        connection_factory = kwargs.pop('connection_factory', None) or self.cls.extensions.connection
+
+        class Connection(connection_factory):
+            def __init__(conn, *args, **kwargs):
+                super(Connection, conn).__init__(*args, **kwargs)
+
+            def cursor(conn, *args, **kwargs):
+                cursor_factory = kwargs.pop('cursor_factory', None) or conn.cursor_factory or self.cls.extensions.cursor
+                try:
+                    # we store these wrapper classes to avoid 're-instrumenting' each time
+                    cursor_class = self.cursor_classes[cursor_factory]
+                except KeyError:
+                    class Cursor(cursor_factory):
+                        def execute(curs, *args, **kwargs):
+                            return super(Cursor, curs).execute(*args, **kwargs)
+
+                        def executemany(curs, *args, **kwargs):
+                            return super(Cursor, curs).executemany(*args, **kwargs)
+                    self.cursor_classes[cursor_factory] = Cursor
+                    cursor_class = Cursor
+                return super(Connection, conn).cursor(cursor_factory=cursor_class, *args, **kwargs)
+
+        Psycopg2ConnectionInterceptor(
+            self.agent, Connection, Psycopg2CursorInterceptor).attach('__init__')
+
+        return connect(connection_factory=Connection, *args, **kwargs)
+
+
+def intercept_psycopg2_connection(agent, mod):
+    agent.logger.warning("Instrument module: psycopg2{}".format(", mod: {}".format(mod) if mod else ""))
+    Psycopg2Interceptor(agent, mod).attach('connect')

pythonagent/agent/probes/sql/pymysql.py

@@ -0,0 +1,25 @@
+
+"""Intercept the pymysql package.
+
+"""
+
+from __future__ import unicode_literals
+
+from .dbapi import DbAPIConnectionInterceptor, DbAPICursorInterceptor
+
+
+class PymysqlConnectionInterceptor(DbAPIConnectionInterceptor):
+    def get_backend_properties(self, conn, *args, **kwargs):
+        conn.db_type = "MYSQL"
+        # self.agent.get_transaction_context().dbhost = conn.host
+        return conn.host, conn.port, conn.db, conn.user, conn.db_type
+
+
+class PymysqlCursorInterceptor(DbAPICursorInterceptor):
+    def get_connection(self, cursor):
+        return cursor.connection
+
+
+def intercept_pymysql_connections(agent, mod):
+    agent.logger.warning("Instrument module: pymysql.connections{}".format(", mod: {}".format(mod) if mod else ""))
+    PymysqlConnectionInterceptor(agent, mod.Connection, PymysqlCursorInterceptor).attach('connect')

pythonagent/bootstrap/cav_gunicorn.py

@@ -0,0 +1,26 @@
+# Cavisson Python Agent — gunicorn integration config
+#
+# This file is a ready-to-use gunicorn config that bootstraps the Cavisson agent
+# in each worker process without requiring changes to your own gunicorn.conf.
+#
+# Usage (add to gunicorn command):
+#   gunicorn -c $NDHOME/python/config/cav_gunicorn.py myapp:application
+#
+# If you already have a gunicorn config file, place cav_gunicorn.py FIRST:
+#   gunicorn -c $NDHOME/python/config/cav_gunicorn.py -c your_gunicorn.conf myapp:application
+#
+# Note: When multiple -c files define the same function (e.g. post_fork), the
+# LAST config wins. Place your own config after cav_gunicorn.py so your post_fork
+# takes precedence; ensure your post_fork also calls agent.bootstrap() if needed.
+#
+# This file is a fallback for environments where sitecustomize.py is not on
+# PYTHONPATH. When sitecustomize.py is active, auto-patching via Worker.init_process
+# handles gunicorn worker bootstrap automatically without this file.
+
+def post_fork(server, worker):
+    try:
+        import pythonagent.agent as _agent
+        _agent.configure()
+        _agent.bootstrap()
+    except Exception:
+        pass

pythonagent/bootstrap/cavagent_lambda_wrapper.py

@@ -0,0 +1,291 @@
+from __future__ import unicode_literals
+import imp
+import os
+import warnings
+import logging
+import sys
+from subprocess import call
+import subprocess
+import uuid
+import datetime
+import time
+
+is_lambda = True
+
+if is_lambda:
+    os.environ.setdefault("NDHOME", "/opt/python/pythonagent/cavisson/netdiagnostics")
+    sys.path.insert(1, '/opt')
+
+os.environ.setdefault("CAVISSON_APP_NAME", os.getenv("AWS_LAMBDA_FUNCTION_NAME", ""))
+os.environ.setdefault("CAVISSON_NO_CONFIG_FILE", "true")
+os.environ.setdefault("CAVISSON_DISTRIBUTED_TRACING_ENABLED", "true")
+os.environ.setdefault("CAVISSON_SERVERLESS_MODE_ENABLED", "true")
+os.environ.setdefault("CAVISSON_TRUSTED_ACCOUNT_KEY", os.getenv("CAVISSON_ACCOUNT_ID", ""))
+
+_agent = None
+logger = None
+
+try:
+    import pythonagent.agent as agent
+    agent.configure()
+    #_agent = agent.bootstrap()
+    _agent = agent.get_agent_instance()
+    #_agent.init_sent = True
+
+except:
+    print("import error in Agent")
+    logger = logging.getLogger('pythonagent.agent')
+    logger.exception('Exception in agent startup.')
+finally:
+    pass
+
+if _agent is None:
+    raise ValueError("Failed to initialize agent")
+
+from pythonagent.agent.internal.agent import TransactionContext
+
+# from pythonagent.agent.probes.havoc.havoc_manager import NDNetHavocMonitor, NDHavocException
+
+
+def get_handler():
+    print("inside get_handler function first", sys.executable)
+    modandpackage = os.path.abspath('.')
+    mod = sys.modules[__name__]
+    print("inside get_handler function mod", mod)
+    try:
+        sys.path.remove(os.path.dirname(__file__))
+    except ValueError:  # directory not in sys.path
+        pass
+
+
+    if (
+            "CAVISSON_LAMBDA_HANDLER" not in os.environ
+            or not os.environ["CAVISSON_LAMBDA_HANDLER"]
+    ):
+        raise ValueError(
+            "No value specified in CAVISSON_LAMBDA_HANDLER environment variable"
+        )
+
+    try:
+        module_path, handler_name = os.environ["CAVISSON_LAMBDA_HANDLER"].rsplit(
+            ".", 1
+        )
+        print("inside get_handler function module_path, handler name: ", module_path, handler_name)
+
+    except ValueError:
+        raise ValueError(
+            "Improperly formated handler value: %s"
+            % os.environ["CAVISSON_LAMBDA_HANDLER"]
+        )
+
+    file_handle, pathname, desc = None, None, None
+
+    try:
+        for segment in module_path.split("."):
+            if pathname is not None:
+                pathname = [pathname]
+
+            file_handle, pathname, desc = imp.find_module(segment, pathname)
+
+        if file_handle is None:
+            module_type = desc[2]
+            if module_type == imp.C_BUILTIN:
+                raise ImportError(
+                    "Cannot use built-in module %s as a handler module" % module_path
+                )
+
+        print("inside get_handler function module_path, file_handle, pathname, desc", module_path, file_handle, pathname, desc)
+
+        module = imp.load_module(module_path, file_handle, pathname, desc)
+        print("inside get_handler function module in cavagent_lambda_wrapper ", module)
+        
+
+    except Exception as e:
+        print("Module not found")
+        raise ImportError("Failed to import module '%s': %s" % (module_path, e))
+    finally:
+        if file_handle is not None:
+            file_handle.close()
+
+    try:
+        handler = getattr(module, handler_name)
+        print("inside get_handler function handler", handler)
+    except AttributeError:
+        print("NO HANDLER FOUND")
+        raise AttributeError(
+            "No handler '%s' in module '%s'" % (handler_name, module_path)
+        )
+
+    return handler, handler_name, modandpackage
+
+
+def local_customer_application(event, context):
+    from .run import db_callout, flask_wsgi, http_callout, first
+    print("inside local_customer_application function Lambda Handler Function")
+
+    first()
+    # second()
+    # http_callout()
+    # db_callout()
+    # flask_wsgi()
+
+    return "Nothing"
+
+
+def local_lambda_handler():
+    #for i in range(100):
+    #    print(1)
+    class TestObj:
+        def __init__(self):
+            self.__module__ = "test"
+
+    t = TestObj()
+    return t , "test", "test"
+
+# Greedily load the handler during cold start, so we don't pay for it on first invoke
+
+
+def wrapped_handler(event, context, is_lambda):
+    if is_lambda:
+        a, b, c = get_handler()
+    else:
+        a, b, c = local_lambda_handler()
+    return a, b, c
+
+
+def handler(event, context):
+    context_obj = TransactionContext()
+    start_time = datetime.datetime.now()
+
+    if context.aws_request_id is not None:
+        context_obj.aws_request_id = context.aws_request_id
+    else:
+        context_obj.aws_request_id = "default_aws_request_id"
+
+    if context.function_name is not None:
+        context_obj.function_name = context.function_name
+    else:
+        context_obj.function_name = "default"
+    print("function name inside context object in cavwrapper handler", context_obj.function_name)
+
+
+    try:
+        # context_obj.function_name = event['requestContext']['path']
+        context_obj.url_path = event['requestContext']['path']
+
+    except:
+        if "path" in event:
+            context_obj.url_path = event["path"]
+        else:
+            context_obj.url_path = context.function_name
+
+    if context.log_stream_name is not None:
+        context_obj.api_request_id = context.log_stream_name
+    else:
+        new_id = uuid.uuid4()
+        id_int = new_id.int
+        context_obj.api_request_id = id_int
+
+    _agent.set_transaction_context(context_obj)
+
+    from pythonagent.agent.probes.havoc.havoc_manager import NDNetHavocMonitor, NDHavocException
+    havoc_monitor = NDNetHavocMonitor.get_instance()
+
+    bt = None
+
+    try:
+        bt = _agent.start_business_transaction(context_obj.url_path, "")
+    except Exception as e:
+        print("Error occurred in Start Business transaction Call {}".format(e))
+
+    # import time
+    # print("Start fp done, sleep 30")
+    # time.sleep(30)
+
+    try:
+        handle, handler_name, modandpackage = wrapped_handler(event, context, is_lambda)
+    except Exception as e:
+        print("Error occurred in Calling Wrapped Handler {}".format(e))
+
+
+    print("inside handler function handle, handler_name, modandpackage IN CAVAGENT_LAMBDA_WRAPPER", handle, handler_name, modandpackage)
+    #fqmmethodentry = str(modandpackage) + "." + str(handler_name)
+    fqmmethodentry = str(handle.__module__) + "." + str(handler_name)
+
+    _agent.method_entry(bt, fqmmethodentry)
+
+    if is_lambda:
+        try:
+            response = handle(event, context)  # Client Lambda Function
+            print("inside handler function RESPONSE IN LAMBDA IN CAVAGENT_LAMBDA_WRAPPER", response)
+        except Exception as e:
+            print("Error while invoking handler {}".format(e))
+            _agent.method_exit(bt, fqmmethodentry, 503)
+            _agent.set_current_status_code(503)
+            rc = _agent.end_business_transaction(bt)
+            havoc_monitor.refresh_configs(_agent)
+            raise e
+    else:
+        response = local_customer_application(event, context)
+        print("inside handler function RESPONSE IN LAMBDA IN CAVAGENT_LAMBDA_WRAPPER", response)
+
+    status_code = 200
+    try:
+        if "statusCode" in response:
+            status_code = response["statusCode"]
+
+        print("Inside handler function: response inside get_handler function firststatus code ", status_code)
+
+    except Exception as e:
+        print("Error occurred in get status code {}".format(e))
+
+
+
+    ###############################
+    # HAVOC
+    ###############################
+
+    # Apply Inbound Delay --> agent/start_business_transaction
+
+    # Apply Inbound Failure
+
+    try:
+        print("Url request: ", context_obj.url_path)
+        btname = _agent.get_transaction_context().btname if _agent.get_transaction_context() else None
+        havoc_monitor.apply_inbound_service_failure(context_obj.url_path, btname)
+
+    except Exception as e:
+        if isinstance(e, NDHavocException):
+            print("Havoc Exception {}".format(e))
+            _agent.method_exit(bt, fqmmethodentry, 503)
+            _agent.set_current_status_code(503)
+            rc = _agent.end_business_transaction(bt)
+            havoc_monitor.refresh_configs(_agent)
+            raise e
+        else:
+            print("Non-Havoc Exception {}".format(e))
+
+    # Apply Outbound Delay --> agent/method_entry_http_callout
+
+    # Apply Outbound Failure --> agent/probes/base.py/http_call_end
+    #                        --> agent/probes/sql/dynamodb.py/_cav_boto_api_method
+
+    # Apply Method Delay --> Instrumentation/__init__
+
+    # Apply Method Failure --> Instrumentation/__init__
+
+    ####################################################################################
+
+    # havoc_monitor.apply_outbound_service_failure("sample_hostname")
+
+    havoc_monitor.refresh_configs(_agent)
+
+    try:
+        _agent.method_exit(bt, fqmmethodentry, status_code)
+        _agent.set_current_status_code(status_code)
+        rc = _agent.end_business_transaction(bt)
+
+    except Exception as e:
+        print("Error occurred in End Business transaction Call {}".format(e))
+
+    return response

pythonagent/bootstrap/run.py

@@ -0,0 +1,47 @@
+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)
+