cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/probes/span.py

@@ -0,0 +1,101 @@
+import json
+
+class BaseSpan(object):
+    def __init__(self, name, start_us, duration, status, meta, test_run, fpi, entry_fpi, nd_session_id, nv_session_id, page_id, full_fp):
+
+        self.trace_id = None
+        self.span_id = None
+        self.parent_id = None
+        self.name = name
+        self.start_us = start_us
+        self.duration = duration
+        self.status = status
+        self.meta = meta
+        """
+        self.meta = {
+            "span_kind": None,
+            "input": None,
+            "output": None,
+            "metadata": None
+        }
+        """
+        self.metrics = {}
+        self.test_run = test_run
+        self.fpi = fpi
+        self.entry_fpi =entry_fpi
+        self.nd_session_id = nd_session_id
+        self.nv_session_id = nv_session_id
+        self.page_id = page_id
+        self.full_fp = full_fp
+
+    def create_span_json(self):
+        span = {
+            "trace_id": self.trace_id,
+            "span_id": self.span_id,
+            "parent_id": self.parent_id,
+            "name": self.name,
+            "start_us": self.start_us,
+            "duration": self.duration,
+            "status": self.status,
+            "meta": self.meta,
+            "metrics": self.metrics,
+            "test_run":self.test_run,
+            "fpi":self.fpi,
+            "entry_fpi":self.entry_fpi,
+            "nd_session_id":self.nd_session_id,
+            "nv_session_id":self.nv_session_id,
+            "page_id":self.page_id,
+            "fp": self.full_fp
+        }
+
+        return json.dumps(span)
+
+
+
+class ToolSpan(BaseSpan):
+    pass
+
+class EmbeddingSpan(BaseSpan):
+    pass
+
+class RetrievalSpan(BaseSpan):
+    pass
+
+
+class LLMSpan(BaseSpan):
+
+    def __init__(self, fqm, start_time, duration, status, meta, metrics, test_run, fpi, entry_fpi, nd_session_id, nv_session_id, page_id, full_fp):
+        super().__init__(fqm, start_time, duration, status, meta, test_run, fpi, entry_fpi, nd_session_id, nv_session_id, page_id, full_fp)
+        self.metrics = metrics
+        """
+        self.metrics = {
+            "prompt_tokens": None,
+            "completion_tokens": None,
+            "total_tokens": None,
+            "prompt_tokens_details": {
+                "prompt_audio_tokens": None,
+                "prompt_cached_tokens": None
+            },
+            "completion_tokens_details": {
+                "completion_accepted_prediction_tokens": None,
+                "completion_rejected_prediction_tokens": None,
+                "completion_audio_tokens": None,
+                "completion_reasoning_tokens": None
+            }
+        }
+        """
+
+
+
+"""
+class WorkFlowSpan(BaseSpan):
+    pass
+
+class AgentSpan(BaseSpan):
+    pass
+
+class TaskSpan(BaseSpan):
+    pass
+"""
+
+

pythonagent/agent/probes/sql/__init__.py

@@ -0,0 +1,13 @@
+
+
+
+"""Interceptors for SQL databases.
+
+"""
+
+from __future__ import unicode_literals
+
+from . import mysql_connector, mysql_connector_cext, mysqldb, pymysql, psycopg2, dynamodb, botocores3
+
+__all__ = ['pymysql', 'mysql_connector', 'mysql_connector_cext', 'mysqldb', 'psycopg2', 'dynamodb', 'botocores3']
+

pythonagent/agent/probes/sql/botocores3.py

@@ -0,0 +1,51 @@
+
+"""Interceptor for httplib/http.client.
+
+"""
+
+from __future__ import unicode_literals
+from ..base import ExitCallInterceptor
+import time
+#from functools import wraps
+# from agent.internal.proxy import *
+from pythonagent.utils import get_current_timestamp_in_ms
+
+
+class BotocoreS3Interceptor(ExitCallInterceptor):
+
+    def _cav_s3_make_request(self, make_request, Endpoint, operation_model, request_dict):#, _agent):
+        try:
+            if operation_model.name != "GetObject":  # PutItem and Scan in DynamoDB use the same function
+                return make_request(Endpoint, operation_model, request_dict)
+
+            method_name = "botocore.endpoint.Endpoint.make_request"
+            ctx = self.agent.get_transaction_context()
+            if ctx:
+                ctx.entry_point_fqm = method_name
+            query_string = operation_model.name
+            start_time = get_current_timestamp_in_ms()
+            url = request_dict["url"]
+            ip_handle = self.db_call_begin(0, None, query_string, url, start_time)
+
+        except Exception as e:
+            self.agent.logger.exception('Exception in S3 db_call_begin {}'.format(e))
+
+        endpiont_method = make_request(Endpoint, operation_model, request_dict)
+
+        try:
+            end_time = get_current_timestamp_in_ms()
+            duration = end_time - start_time
+            ctx = self.agent.get_transaction_context()
+            if ctx:
+                ctx.host_str = "s3"
+                ctx.status_code = 200
+            self.db_call_end(0, ip_handle, duration, start_time)
+        except Exception as e:
+            self.agent.logger.exception("Exception in S3 db_call_end {}".format(e))
+        
+        return endpiont_method
+
+def intercept_s3(agent, mod):
+    agent.logger.warning("Instrument module: botocore.endpoint{}".format(", mod: {}".format(mod) if mod else ""))
+    interceptor = BotocoreS3Interceptor(agent, mod.Endpoint)
+    interceptor.attach('make_request', patched_method_name='_cav_s3_make_request')

pythonagent/agent/probes/sql/dbapi.py

@@ -0,0 +1,285 @@
+
+"""Interceptors for dealing with DB-API 2.0 compatible libraries.
+
+"""
+
+from __future__ import unicode_literals
+import abc
+import re
+#import agent
+#from agent.internal.proxy import *
+from pythonagent.lang import str
+#from pythonagentynamics.agent.core.registries import MissingConfigException
+#from pythonagentynamics.agent.models.exitcalls import EXIT_DB, EXIT_SUBTYPE_DB
+#from .. import HOST_PROPERTY_MAX_LEN, DB_NAME_PROPERTY_MAX_LEN, VENDOR_PROPERTY_MAX_LEN
+from ..base import ExitCallInterceptor
+from pythonagent.utils import generate_flow_path_id, get_utf8_bytes, get_current_timestamp_in_us, get_validated_duration
+
+EXIT_DB = 1
+EXIT_SUBTYPE_DB = 'DB'
+
+HOST_PROPERTY_MAX_LEN = 50
+DB_NAME_PROPERTY_MAX_LEN = 50
+VENDOR_PROPERTY_MAX_LEN = 50
+
+class MissingConfigException(Exception):
+    pass
+
+
+#def get_db_backend(agent, host, port, dbname, vendor):
+    # if agent.backend_registry is None:
+    #     raise MissingConfigException
+
+#    naming_format_string = '{HOST}:{PORT} - {DATABASE} - {VENDOR} - {VERSION}'
+#    host = host[:HOST_PROPERTY_MAX_LEN]
+#    dbname = dbname[:DB_NAME_PROPERTY_MAX_LEN]
+#    vendor = vendor[:VENDOR_PROPERTY_MAX_LEN]
+
+#    backend_properties = {
+#        'VENDOR': vendor,
+#        'HOST': host,
+#        'PORT': str(port),
+#        'DATABASE': dbname,
+#        'VERSION': 'unknown',
+#    }
+
+    #return agent.backend_registry.get_backend(EXIT_DB, EXIT_SUBTYPE_DB, backend_properties, naming_format_string)
+#    return None
+
+
+class DbAPICursorInterceptor(ExitCallInterceptor):
+
+    def __init__(self, agent, cls):
+        super(DbAPICursorInterceptor, self).__init__(agent, cls)
+        self.connection_properties = None
+    
+    #print("going to get proxy instance (DbAPICursor Interceptor)")
+    #proxy = Proxy.getInstance()
+    #print("proxy handle = ",proxy )
+
+    def db_call_end(self, bt, exit_call, duration, start_time):
+        #self.agent.logger.info('Modulename: DbAPICursorInterceptor class inside db_call_end function') 
+        # execute_result is intentionally not used here.  Its purpose is to
+        # allow subclasses to override this method and use the value.
+        super(DbAPICursorInterceptor, self).db_call_end(bt, exit_call, duration, start_time)
+
+    def _execute(self, execute, cursor, operation, *args, **kwargs):
+        if self.agent.get_transaction_context() is None:
+            return execute(cursor, operation, *args, **kwargs)
+        exit_call = None
+        with self.log_exceptions():
+            self.agent.get_transaction_context().entry_point_fqm = str(execute.__module__ + "." + execute.__qualname__)
+            host, port, db_name, user, db_type = self.connection_properties
+            # format :- "PROTOCOL|HOST|PORT|URL|DBPRODNAME|DBNAME|DBPRODVER|DRIVERNAME|DRIVERVER|USERNAME|SERVICENAME"
+            self.agent.get_transaction_context().host_str = f"NA|{host}|{port}|NA|{db_type}|{db_name}|NA|NA|NA|{user}|NA"
+            db_start_time = 0
+
+            query_params = args
+            token_string = ""
+            if query_params:
+                if len(query_params) != 0:
+                    for parameters in query_params:
+                        counter = 0
+                        if parameters:
+                            for tokens in parameters:
+                                token_string += "{}:{}\n".format(counter, tokens)
+                                counter += 1
+            else:
+                token_string = None
+
+
+            #print("operation in  db query in dbapi.py\n\n", operation)
+            backend = True
+
+           # host = None
+            #self.agent.logger.info("inside _execute funciton")
+            #self.agent.logger.info('Modulename: DbAPICursorInterceptor class inside _execute function')
+            self.agent.logger.info("Modulename: DbAPICursorInterceptor class || execute value is : {0}".format(execute))
+            self.agent.logger.info("Modulename: DbAPICursorInterceptor class || operation value is :{0}".format(str(operation)))
+            #self.agent.logger.info("execute: {}",execute,"cursor: {}",cursor,"operation:{} ",operation)
+            #print("cursor host: ", cursor.host)
+           
+            #bt = self.agent.bt
+            bt = self.bt
+            if bt:
+                #print("bt value is ------------------",bt)
+                #connection = self.get_connection(cursor)
+                module = self.cls.__module__.lower()
+
+                if "psycopg2" in module:
+                    mName = "psycopg2.connect"
+                    self.agent.get_transaction_context().entry_point_fqm = mName
+
+                if backend and not hasattr(cursor, '_pythonagent_exit_call'):
+                    db_start_time = get_current_timestamp_in_us()
+                    self.agent.logger.debug("db_call_begin for _execute bt {} host {} query {} query_params {} db_start_time {}".format(bt, host, operation, token_string, db_start_time))
+                    host_str = self.agent.get_transaction_context().host_str
+                    exit_call = self.db_call_begin(bt, host, operation, token_string, db_start_time, host_str=host_str)
+                    cursor._pythonagent_exit_call = exit_call
+                    self.agent.get_transaction_context().db_callout_start_time = db_start_time
+
+
+        try:
+            result = execute(cursor, operation, pythonagent_exit_call=exit_call, *args, **kwargs)
+        except Exception as e:
+            self.agent.logger.exception("Error in application: {}".format(e))
+            try:
+                db_end_time = get_current_timestamp_in_us()
+                db_start_time = self.agent.get_transaction_context().db_callout_start_time
+                duration = get_validated_duration(db_start_time, db_end_time, "_execute")
+                self.agent.get_transaction_context().status_code = 500
+                self.agent.get_transaction_context().db_callout_start_time = 0
+                self.agent.logger.debug("db_call_end for _execute with exception bt {} ip_handle {} duration {} db_start_time {}".format(bt, exit_call, duration, db_start_time))
+                self.db_call_end(bt, exit_call, duration, db_start_time)
+            except Exception as e:
+                self.agent.logger.exception("Exception in Original Method DB Call End for dbapi execute {}".format(e))
+
+            try:
+                delattr(cursor, '_pythonagent_exit_call')
+            except AttributeError:
+                pass
+
+            raise
+
+        try:
+
+            db_end_time = get_current_timestamp_in_us()
+            db_start_time = self.agent.get_transaction_context().db_callout_start_time
+            duration = get_validated_duration(db_start_time, db_end_time, "_execute")
+
+            # Normally it's fine to just try to end the exit call even if we
+            # aren't sure it actually started.  However for cases where we have
+            # several `execute` calls nested inside an `executemany` call, we do
+            # not want to end the exit call until the outer call is over.
+
+            if not exit_call:
+                self.agent.get_transaction_context().status_code = 200
+                self.agent.get_transaction_context().db_callout_start_time = 0
+                self.agent.logger.debug("db_call_end for _execute bt {} ip_handle {} duration {} db_start_time {}".format(bt, exit_call, duration, db_start_time))
+                self.db_call_end(bt, exit_call, duration, db_start_time)
+                try:
+                    delattr(cursor, '_pythonagent_exit_call')
+                except AttributeError:
+                    pass
+
+        except Exception as e:
+            self.agent.logger.exception("Exception in dbapi execute end{}".format(e))
+
+        return result
+
+    @abc.abstractmethod
+    def get_connection(self, cursor):
+        """Return the `Connection` object used to create this `Cursor`.
+
+        """
+        pass
+
+
+class DbAPIConnectionInterceptor(ExitCallInterceptor):
+
+    def __init__(self, agent, cls, cursor_interceptor):
+        super(DbAPIConnectionInterceptor, self).__init__(agent, cls)
+        self.cursor_interceptor = cursor_interceptor
+        self.backend_properties = None
+
+    def attach(self, connect_func):
+        super(DbAPIConnectionInterceptor, self).attach(connect_func, patched_method_name='_connect')
+        super(DbAPIConnectionInterceptor, self).attach('cursor')
+
+    def db_call_end(self, bt, exit_call, duration, db_start_time):
+        # maybe_connection is intentionally not used here.  Its purpose is to
+        # allow subclasses to override this method and use the value.
+        super(DbAPIConnectionInterceptor, self).db_call_end(bt, exit_call, duration, db_start_time)
+
+    def _connect(self, connect, connection, *args, **kwargs):
+        exit_call = None
+
+        with self.log_exceptions():
+
+            backend_properties = self.get_backend_properties(connection, *args, **kwargs)
+            self.backend_properties = backend_properties
+            if self.agent.get_transaction_context() is None:
+                maybe_connection = connect(connection, pythonagent_exit_call=None, *args, **kwargs)
+                return maybe_connection
+
+            mName = str(connect.__module__ + "." + connect.__qualname__)
+            self.agent.get_transaction_context().entry_point_fqm = mName
+            bt = self.bt
+            db_start_time = 0
+
+            backend = True
+
+            try:
+                connection._pythonagent_backend = backend
+            except MissingConfigException:
+                # If the agent has just started and doesn't have config yet,
+                # we cannot create and store a backend on the connection object.
+                # We store the backend properties instead so that the cursor
+                # interceptor can try again later.
+                connection._pythonagent_backend_properties = backend_properties
+            if bt:
+                db_start_time = get_current_timestamp_in_us()
+                self.agent.logger.debug("db_call_begin for _connect bt {} host {} query {} query_params {} db_start_time {}".format(bt, backend_properties[0], '', None, db_start_time))
+                #exit_call = self.db_call_begin(bt, backend_properties[0], '', None, db_start_time)
+                self.agent.get_transaction_context().db_callout_start_time = db_start_time
+
+        # The reason this is called `maybe_connection` is that different
+        # interceptors will return different values here.  `connect` could
+        # be an __init__ method on a class, returning None, it could be a
+        # function which returns an initialized connection object, or even a
+        # method returning an async future object.  The only reason we capture
+        # this value and pass it to `end_exit_call` is to allow subclasses to
+        # override the behaviour of `end_exit_call` (for example in the async
+        # case, to only end the exit call when the future is completed).
+
+        try:
+            maybe_connection = connect(connection, pythonagent_exit_call=exit_call, *args, **kwargs)
+        except Exception as e:
+            self.agent.logger.exception("Error in application: {}".format(e))
+            try:
+                db_end_time = get_current_timestamp_in_us()
+                db_start_time = self.agent.get_transaction_context().db_callout_start_time
+                duration = get_validated_duration(db_start_time, db_end_time, "_connect")
+                self.agent.get_transaction_context().status_code = 500
+                self.agent.get_transaction_context().db_callout_start_time = 0
+                self.agent.logger.debug("db_call_end for _connect with exception bt {} ip_handle {} duration {} db_start_time {}".format(bt, exit_call, duration, db_start_time))
+                #self.db_call_end(bt, exit_call, duration, db_start_time)
+            except Exception as e:
+                self.agent.logger.exception("Exception in Original Method DB Call End for dbapi connect {}".format(e))
+                
+            raise
+
+        try:
+            db_end_time = get_current_timestamp_in_us()
+            db_start_time = self.agent.get_transaction_context().db_callout_start_time
+            duration = get_validated_duration(db_start_time, db_end_time, "_connect")
+            self.agent.get_transaction_context().status_code = 200
+            self.agent.get_transaction_context().db_callout_start_time = 0
+            self.agent.logger.debug("db_call_end for _connect bt {} ip_handle {} duration {} db_start_time {}".format(bt, exit_call, duration, db_start_time))
+            #self.db_call_end(bt, exit_call, duration, db_start_time)
+
+        except Exception as e:
+            self.agent.logger.exception("Exception in dbapi connect end{}".format(e))
+
+        return maybe_connection
+
+    def _cursor(self, cursor, connection, *args, **kwargs):
+        cursor_instance = cursor(connection, pythonagent_exit_call=None, *args, **kwargs)
+        with (self.log_exceptions()):
+            cursor_obj = self.cursor_interceptor(self.agent, type(cursor_instance))
+            cursor_obj.attach('execute',patched_method_name='_execute')
+            cursor_obj.connection_properties = self.backend_properties
+        return cursor_instance
+
+    @abc.abstractmethod
+    def get_backend_properties(self, connection, *args, **kwargs):
+        """Return a tuple of (host, port, database, vendor) for this connection.
+
+        The parameters passed to this function are the same as those passed to
+        the intercepted `connect` function.
+
+        WARNING: `connection` may not have been initialized when this
+        function is called; be careful.
+
+        """
+        pass

pythonagent/agent/probes/sql/dynamodb.py

@@ -0,0 +1,90 @@
+
+"""Interceptor for httplib/http.client.
+
+"""
+
+from __future__ import unicode_literals
+from ..base import ExitCallInterceptor
+import time
+#from functools import wraps
+# from agent.internal.proxy import *
+from pythonagent.utils import get_current_timestamp_in_ms
+
+# import agent
+class BotocoreClientInterceptor(ExitCallInterceptor):
+    #print("INSIDE dynamodb.py BotocoreClientInterceptor class")
+
+    def bind__create_api_method(py_operation_name, operation_name, service_model,
+                                *args, **kwargs):
+        return py_operation_name
+
+    def _cav_boto_api_method(self, _create_api_method, ClientCreator,py_operation_name, operation_name, service_mode, *args, **kwargs):
+
+        def _cav_wrapped_api_method(func, py_operation_name, _agent):
+            # operation_name = py_operation_name
+            agent = _agent
+            def wrapper(*args, **kwargs):
+                start_time = None
+                query_string = None
+                method_name = None
+                ip_handle = None
+
+                try:
+                    if "TableName" in kwargs:
+                        table_name = kwargs["TableName"]
+                    else:
+                        table_name = "default"
+
+                    operation_name = py_operation_name
+                    if operation_name is None:
+                        operation_name = "default"
+
+                    method_name = "botocore.client.ClientCreator._create_api_method"
+
+                    query_string = str(table_name)+"."+str(operation_name)
+                    start_time = get_current_timestamp_in_ms()
+                    ctx = self.agent.get_transaction_context()
+                    if ctx:
+                        ctx.entry_point_fqm = method_name
+                    bt = 0
+                    db_host = None
+                    ip_handle = self.db_call_begin(bt, db_host, query_string, "dynamodb", start_time)
+
+                except Exception as e:
+                    self.agent.logger.exception("Some error occurred inside wrapper in method entry call {}".format(e))
+
+                results = func(*args, **kwargs)
+
+                try:
+                    end_time = get_current_timestamp_in_ms()
+                    duration = end_time - start_time
+                    ctx = self.agent.get_transaction_context()
+                    if ctx:
+                        ctx.host_str = "dynamodb"
+                        ctx.status_code = 200
+                    self.db_call_end(0, ip_handle, duration, start_time)
+
+                except Exception as e:
+                    self.agent.logger.exception("Some error occurred inside wrapper in method exit call {}".format(e))
+
+                return results
+
+            return wrapper
+
+        service_name = None
+        try:
+            service_name = service_mode.service_name.lower()
+        except Exception as e:
+            self.agent.logger.exception("Some error occurred inside _cav_boto_api_method {}".format(e))
+
+        api_method = _create_api_method(ClientCreator, py_operation_name, operation_name, service_mode, *args, **kwargs)
+
+        if service_name == "dynamodb":
+            return _cav_wrapped_api_method(api_method, py_operation_name, self.agent)
+        else:
+            return api_method
+
+def intercept_dynamodb(agent, mod):
+    agent.logger.warning("Instrument module: botocore.client{}".format(", mod: {}".format(mod) if mod else ""))
+    interceptor = BotocoreClientInterceptor(agent, mod.ClientCreator)
+    interceptor.attach('_create_api_method', patched_method_name="_cav_boto_api_method")  

pythonagent/agent/probes/sql/mysql_connector.py

@@ -0,0 +1,24 @@
+
+
+"""Intercept the mysql-connector-python package.
+
+"""
+
+from __future__ import unicode_literals
+
+from .dbapi import DbAPIConnectionInterceptor, DbAPICursorInterceptor
+
+
+class MySQLConnectionInterceptor(DbAPIConnectionInterceptor):
+    def get_backend_properties(self, conn, *args, **kwargs):
+        return conn._host, conn._port, conn._database, conn._user, 'MYSQL'
+
+
+class MySQLCursorInterceptor(DbAPICursorInterceptor):
+    def get_connection(self, cursor):
+        return cursor._connection
+
+
+def intercept_mysql_connector_connection(agent, mod):
+    agent.logger.warning("Instrument module: mysql.connector.connection{}".format(", mod: {}".format(mod) if mod else ""))
+    MySQLConnectionInterceptor(agent, mod.MySQLConnection, MySQLCursorInterceptor).attach('_open_connection')

pythonagent/agent/probes/sql/mysql_connector_cext.py

@@ -0,0 +1,24 @@
+
+
+"""Intercept the mysql-connector-python package.
+
+"""
+
+from __future__ import unicode_literals
+
+from .dbapi import DbAPIConnectionInterceptor, DbAPICursorInterceptor
+
+
+class CMySQLConnectionInterceptor(DbAPIConnectionInterceptor):
+    def get_backend_properties(self, conn, *args, **kwargs):
+        return conn._host, conn._port, conn._database, conn._user, 'MYSQL'
+
+
+class CMySQLCursorInterceptor(DbAPICursorInterceptor):
+    def get_connection(self, cursor):
+        return cursor._cnx
+
+
+def intercept_mysql_connector_cext_connection(agent, mod):
+    agent.logger.warning("Instrument module: mysql.connector.connection_cext{}".format(", mod: {}".format(mod) if mod else ""))
+    CMySQLConnectionInterceptor(agent, mod.CMySQLConnection, CMySQLCursorInterceptor).attach('_open_connection')

pythonagent/agent/probes/sql/mysqldb.py

@@ -0,0 +1,43 @@
+
+
+"""Intercept the MySQLdb package.
+
+"""
+
+from __future__ import unicode_literals
+import weakref
+
+from .dbapi import DbAPIConnectionInterceptor, DbAPICursorInterceptor
+
+
+class MySQLdbConnectionInterceptor(DbAPIConnectionInterceptor):
+    def get_backend_properties(self, conn, *args, **kwargs):
+        self.agent.logger.info('Modulename: MySQLdbCursorInterceptor  class inside get_backend_properties function')
+        host = kwargs.get('host', 'localhost')
+        #self.agent.get_transaction_context().dbhost = host
+        port = kwargs.get('port', '3306')
+        db = kwargs.get('database', kwargs.get('db', ''))
+        user = kwargs.get('user', "mysqldb_user")
+        db_type = "MYSQL"
+        #format :- "PROTOCOL|HOST|PORT|URL|DBPRODNAME|DBNAME|DBPRODVER|DRIVERNAME|DRIVERVER|USERNAME|SERVICENAME"
+        # host_name_str = f"NA|{host}|{port}|NA|MYSQL|{db}|NA|NA|NA|{kwargs['user']}|NA"
+        # print("host_name_str", host_name_str)
+        # self.agent.get_transaction_context().host_str = host_name_str
+        # print("self.agent.get_transaction_context().host_str", self.agent.get_transaction_context().host_str)
+        return host, port, db, user, db_type
+
+
+class MySQLdbCursorInterceptor(DbAPICursorInterceptor):
+    def get_connection(self, cursor):
+        self.agent.logger.info('Modulename: MySQLdbCursorInterceptor  class inside get_connection function ') 
+        conn = cursor.connection
+        self.agent.logger.info("Modulename: MySQLdbCursorInterceptor  class inside get_connection function connection is {0} ".format(conn))
+
+        if isinstance(conn, weakref.ReferenceType):
+            conn = conn()
+        return conn
+
+
+def intercept_MySQLdb_connection(agent, mod):
+    agent.logger.warning("Instrument module: MySQLdb.connections{}".format(", mod: {}".format(mod) if mod else ""))
+    MySQLdbConnectionInterceptor(agent, mod.Connection, MySQLdbCursorInterceptor).attach('__init__')