cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/probes/base.py

@@ -0,0 +1,303 @@
+
+
+"""Definition of base entry and exit point interceptors.
+
+"""
+
+
+import sys
+import types
+import inspect
+from functools import wraps
+from contextlib import contextmanager
+import time
+from pythonagent.utils import get_current_timestamp_in_us
+
+
+class BaseInterceptor(object):
+    def __init__(self, agent, cls):
+        self.agent = agent
+        self.cls = cls
+
+    @property
+    def bt(self):
+        # add a docstring here about what current bt means now.
+        return self.agent.get_current_bt()
+
+    def __setitem__(self, key, value):
+        bt = self.bt
+        if bt:
+            bt._properties[key] = value
+
+    def __getitem__(self, key):
+        bt = self.bt
+        if bt:
+            return bt._properties.get(key)
+
+    def __delitem__(self, key):
+        bt = self.bt
+        if bt:
+            bt._properties.pop(key, None)
+
+
+    @staticmethod
+    def _fix_dunder_method_name(method, class_name):
+        # If `method` starts with '__', then it will have been renamed by the lexer to '_SomeClass__some_method'
+        # (unless the method name ends with '__').
+        if method.startswith('__') and not method.endswith('__'):
+            method = '_' + class_name.lstrip('_') + method
+        return method
+
+    def _attach(self, method, wrapper_func, patched_method_name):
+        patched_method_name = patched_method_name or '_' + method
+
+        # Deal with reserved identifiers.
+        # https://docs.python.org/2/reference/lexical_analysis.html#reserved-classes-of-identifiers
+        # method = self._fix_dunder_method_name(method, self.cls.__name__)
+        # patched_method_name = self._fix_dunder_method_name(patched_method_name, self.__class__.__name__)
+
+        # Skip classmethods and staticmethods: replacing the descriptor with a
+        # plain function via setattr breaks subclass cls-binding for classmethods
+        # (the captured bound-to-base version is called instead of bound-to-subclass)
+        # and breaks staticmethods (they receive 'self' unexpectedly).
+        # Modules have no __mro__; skip the walk for module-level functions
+        # (module attrs can never be classmethod/staticmethod descriptors).
+        mro = getattr(self.cls, '__mro__', None)
+        method = self._fix_dunder_method_name(method, self.cls.__name__)
+        if mro is not None:
+            for klass in mro:
+                raw = vars(klass).get(method)
+                if raw is not None:
+                    if isinstance(raw, (classmethod, staticmethod)):
+                        return
+                    break  # found as a plain function/descriptor, safe to wrap
+
+        patched_method_name = self._fix_dunder_method_name(patched_method_name, self.__class__.__name__)
+
+        # Wrap the original method if required.
+        original_method = getattr(self.cls, method)
+
+        if not isinstance(original_method, types.FunctionType) and not isinstance(original_method, types.MethodType):
+            return
+
+        # Do not intercept the same method more than once.
+        if hasattr(original_method, '_pythonagent_intercepted'):
+            return
+
+        if wrapper_func:
+            @wraps(original_method)
+            def wrapped_method(*args, **kwargs):
+                return wrapper_func(original_method, *args, **kwargs)
+            real_method = wrapped_method
+        else:
+            real_method = original_method
+
+        # Replace `self.cls.method` with a call to the patched method.
+        patched_method = getattr(self, patched_method_name)
+
+        if inspect.iscoroutinefunction(patched_method):
+            @wraps(original_method)
+            async def call_patched_method(*args, **kwargs):
+                return await patched_method(real_method, *args, **kwargs)
+        else:
+            @wraps(original_method)
+            def call_patched_method(*args, **kwargs):
+                return patched_method(real_method, *args, **kwargs)
+
+        call_patched_method._pythonagent_intercepted = True
+
+        setattr(self.cls, method, call_patched_method)
+
+    def attach(self, method_or_methods, wrapper_func=None, patched_method_name=None):
+        if not isinstance(method_or_methods, list):
+            method_or_methods = [method_or_methods]
+        for method in method_or_methods:
+            self._attach(method, wrapper_func, patched_method_name)
+
+    def log_exception(self, level=1):
+        self.agent.logger.exception('Exception in {klass}.{function}.'.format(klass=self.__class__.__name__, function=level))
+
+    @contextmanager
+    def log_exceptions(self):
+        try:
+            yield
+        except Exception as e:
+            from pythonagent.agent.probes.havoc.havoc_manager import NDHavocException
+            if isinstance(e, NDHavocException):
+                raise e
+            self.log_exception(level=3)
+
+
+NO_WRAPPER = object()
+
+
+class ExitCallInterceptor(BaseInterceptor):
+    def attach(self, method_or_methods, wrapper_func=NO_WRAPPER, patched_method_name=None):
+        if wrapper_func is NO_WRAPPER:
+            wrapper_func = self.run
+        super(ExitCallInterceptor, self).attach(method_or_methods, wrapper_func=wrapper_func,
+                                                patched_method_name=patched_method_name)
+
+    def make_correlation_header(self, exit_call):
+        header = None
+        if exit_call and header is not None:
+            exit_call.optional_properties['CorrelationHeader'] = header[1]
+        return header
+
+    def http_call_begin(self, bt, http_host, url, method_name, start_time, backend_name=None, callout_id=0):
+        """Start an exit call."""
+
+        exit_call = None
+        backend_name = backend_name or http_host
+        with self.log_exceptions():
+            self.agent.logger.debug("http call begin bt {} http_host {} url {} method_name {} current_time {}".format(bt, http_host, url, method_name, start_time))
+            exit_call= self.agent.http_call_begin(bt, http_host, url, method_name, start_time) # Native
+        try:
+            from pythonagent.agent.probes.havoc.havoc_manager import NDHavocException
+            backend_name_value = self.agent.setting_backend_name_otel(backend_name, "HTTP")
+            if backend_name_value:
+                backend_name_value = backend_name_value.decode() if isinstance(backend_name_value, bytes) else backend_name_value
+            ctx = self.agent.get_transaction_context()
+            btname = ctx.btname if ctx else None
+            req_url = ctx.url_path if ctx else None
+            self.agent.havoc_monitor.apply_outbound_service_failure(backend_name, backend_name_value, req_url, btname)
+
+        except Exception as e:
+            if isinstance(e, NDHavocException):
+                self.agent.logger.info("Havoc Exception {}".format(e))
+                status = 503
+                self.agent.set_current_status_code(503)
+                self.agent.get_nd_header(bt, backend_name, callout_id)
+                self.agent.http_call_end(bt, exit_call, method_name, backend_name, status, 0, start_time, callout_id)
+                raise e
+            else:
+                self.agent.logger.info("Non-Havoc Exception {}".format(e))
+        return exit_call
+
+
+    def run(self, func, *args, **kwargs):
+        """Run the function.  If it raises an exception, end the exit call started from func
+           and raise the exception.
+
+           The exit call that needs to be managed should be passed as key word argument pythonagent_exit_call.
+
+        """
+        exit_call = kwargs.pop('pythonagent_exit_call', None)
+        with self.end_exit_call_and_reraise_on_exception(exit_call):
+            return func(*args, **kwargs)
+
+    def http_call_end(self, bt, exit_call, method_name, status=200, duration=0, start_time=0, backend_name=None, callout_id=0):
+        """End the exit call.
+        """
+        ctx = self.agent.get_transaction_context()
+        if not method_name:
+            method_name = ctx.entry_point_fqm if ctx else None
+
+        if not backend_name:
+            backend_name = ctx.backend_header if ctx else None
+
+        if start_time == 0:
+            start_time = ctx.tier_callout_start_time if ctx else 0
+
+        
+        with self.log_exceptions():
+            if not exit_call:
+                self.agent.logger.debug("http call end bt {} exit_call {} method_name {} backend_name {} status {} duration {} start_time {}".format(bt, exit_call, method_name, backend_name, status, duration, start_time))
+                self.agent.http_call_end(bt, exit_call, method_name, backend_name, status, duration, start_time, callout_id)
+
+    def db_call_begin(self, bt, db_host, db_query, query_parameters=None, db_start_time=0, method_name=None, host_str=None):
+        """Start an exit call.
+        """
+        ip_handle = None
+        ctx = self.agent.get_transaction_context()
+        if not host_str:
+            host_str = ctx.host_str if ctx else None
+        if not host_str:
+            host_str = db_host
+
+        with self.log_exceptions():
+            if not method_name:
+                method_name = ctx.entry_point_fqm if ctx else None
+            ip_handle = self.agent.db_call_begin(method_name, bt, db_host, db_query, query_parameters, db_start_time)
+        try:
+
+            from pythonagent.agent.probes.havoc.havoc_manager import NDHavocException
+            backend_name = None
+            backend_name_value = self.agent.setting_backend_name_otel(host_str, "DB")
+            if backend_name_value:
+                backend_name = backend_name_value.decode() if isinstance(backend_name_value, bytes) else backend_name_value
+            btname = ctx.btname if ctx else None
+            req_url = ctx.url_path if ctx else None
+            self.agent.havoc_monitor.apply_outbound_service_failure(host_str, backend_name, req_url, btname)
+
+
+            return ip_handle
+
+        except Exception as e:
+            from pythonagent.agent.probes.havoc.havoc_manager import NDHavocException
+            if isinstance(e, NDHavocException):
+                self.agent.logger.info("Havoc Exception {}".format(e))
+                status_code = 503
+                self.agent.set_current_status_code(status_code)
+                if ctx:
+                    ctx.status_code = status_code
+                self.agent.db_call_end(bt, ip_handle, 0, db_start_time, method_name, host_str, status_code)
+                raise e
+            else:
+                self.agent.logger.info("Non-Havoc Exception {}".format(e))
+                return ip_handle
+
+    def db_call_end(self, bt, ip_handle, duration=None, db_start_time=None, entry_point_fqm=None, host_str=None, status_code=None):
+        """End the exit call.
+        """
+        ctx = self.agent.get_transaction_context()
+        if not entry_point_fqm:
+            entry_point_fqm = ctx.entry_point_fqm if ctx else None
+
+        if not host_str:
+            host_str = ctx.host_str if ctx else None
+
+        if not status_code:
+            status_code = ctx.status_code if ctx else None
+
+        with self.log_exceptions():
+            if bt:
+                self.agent.db_call_end(bt, ip_handle, duration, db_start_time, entry_point_fqm, host_str, status_code)
+
+    @contextmanager
+    def end_exit_call_and_reraise_on_exception(self, exit_call, ignored_exceptions=()):
+        try:
+            yield
+        except ignored_exceptions:
+            raise
+        except:
+            self.agent.logger.exception("Exception raised in end exit call !!! {0}".format(sys.exc_info()))
+            raise
+
+
+class EntryPointInterceptor(BaseInterceptor):
+    HTTP_ERROR_DISPLAY_NAME = 'HTTP {code}'
+
+    def start_business_transaction(self, bt_name, correlation_header, nd_cookie=None, nv_cookie=None, bt_header_value=None, fp_instance=None):
+        with self.log_exceptions():
+            return self.agent.start_business_transaction(bt_name, correlation_header, nd_cookie, nv_cookie,bt_header_value, fp_instance)
+
+    def end_business_transaction(self, bt, cpu_time):
+        with self.log_exceptions():
+            self.agent.end_business_transaction(bt, cpu_time)
+
+    def handle_http_status_code(self, bt, status_code, msg):
+        """Add the status code to the BT and deal with error codes.
+
+        If the status code is in the error config and enabled, or the status
+        code is >= 400, create an ErrorInfo object and add it to the BT.
+
+        """
+        self.agent.set_current_status_code(status_code)
+        if status_code >= 400:
+            self.agent.logger.info('Message is '.format(msg))
+        else:
+            return
+
+
+

pythonagent/agent/probes/cache/__init__.py

@@ -0,0 +1,51 @@
+"""Base interceptor for distributed caches (typically, key-value stores).
+
+"""
+
+from __future__ import unicode_literals
+
+#from appdynamics.agent.models.exitcalls import EXIT_CACHE, EXIT_SUBTYPE_CACHE
+from ..base import ExitCallInterceptor
+
+EXIT_CACHE= 1
+EXIT_SUBTYPE_CACHE ='CACHE'
+class CacheInterceptor(ExitCallInterceptor):
+    """Base class for cache interceptors.
+
+    Extra Parameters
+    -----------------
+    vendor : string
+        The vendor name of this cache backend e.g. MEMCACHED.
+
+    """
+
+    backend_name_format_string = '{SERVER POOL} - {VENDOR}'
+
+    def __init__(self, agent, cls, vendor):
+        self.vendor = vendor
+        super(CacheInterceptor, self).__init__(agent, cls)
+
+    def get_backend(self, server_pool):
+        """
+
+        Parameters
+        ----------
+        server_pool : list of str
+
+        """
+        self.agent.logger.info('Modulenam CacheInterceptor class inside get_backend') 
+        backend_properties = {
+            'VENDOR': self.vendor,
+            'SERVER POOL': '\n'.join(server_pool),
+        }
+        self.agent.logger.info("Modulenam CacheInterceptor class inside get_backend backend_properties is {0}".format(backend_properties))
+        return self.agent.backend_registry.get_backend(EXIT_CACHE, EXIT_SUBTYPE_CACHE, backend_properties,self.backend_name_format_string)
+        # return None
+
+
+from .redis import intercept_redis
+from .redis_asyncio import intercept_redis_asyncio
+
+
+__all__ = ['intercept_redis', 'intercept_redis_asyncio']
+

pythonagent/agent/probes/cache/redis.py

@@ -0,0 +1,119 @@
+"""Interceptor for Redis.
+
+"""
+
+from __future__ import unicode_literals
+
+from pythonagent.agent.probes.cache import CacheInterceptor
+from pythonagent.utils import generate_flow_path_id, get_utf8_bytes, get_current_timestamp_in_us, get_validated_duration
+
+
+class RedisConnectionInterceptor(CacheInterceptor):
+
+    def __init__(self, agent, cls):
+        super(RedisConnectionInterceptor, self).__init__(agent, cls, 'REDIS')
+
+    def _send_packed_command(self, send_packed_command, connection, command, check_health=True):
+        exit_call = None
+        bt = None
+        db_start_time = 0
+        try:
+            # Extract command string early so we can guard on PING before touching context
+            command_str = ""
+            command_len = len(command)
+            if command_len != 0:
+                if command_len == 1:
+                    parts = command[0].decode('utf-8', errors='replace').split('\n')
+                    command_str = parts[2][:-1] if len(parts) > 2 else ""
+                else:
+                    for i in range(command_len):
+                        try:
+                            parts = command[i].decode('utf-8', errors='replace').split('\n')
+                            if len(parts) > 2:
+                                sep = ',' if i < command_len - 1 else ''
+                                command_str += parts[2][:-1] + sep
+                        except AttributeError:
+                            continue
+
+            # Skip internal health-check PINGs to prevent infinite recursion:
+            # Redis's check_health() sends a PING through the patched send_packed_command,
+            # which would re-enter this interceptor and loop indefinitely.
+            if command_str == "PING":
+                return send_packed_command(connection, command,
+                                           check_health=check_health,
+                                           pythonagent_exit_call=None)
+
+            # format :- "PROTOCOL|HOST|PORT|URL|DBPRODNAME|DBNAME|DBPRODVER|DRIVERNAME|DRIVERVER|USERNAME|SERVICENAME"
+            host_name_str = f"NA|{connection.host}|{connection.port}|NA|REDIS|{connection.db}|NA|NA|NA|{connection.username}|NA"
+            ctx = self.agent.get_transaction_context()
+            if ctx is not None:
+                ctx.host_str = host_name_str
+                ctx.entry_point_fqm = connection.__module__ + "." + send_packed_command.__qualname__
+
+            bt = self.bt or self.agent.get_current_bt()
+            self.agent.logger.info("Modulename: RedisConnectionInterceptor class || bt value is {0}".format(bt))
+
+            if bt:
+                try:
+                    server_pool = ['%s:%s' % (connection.host, connection.port)]
+                except AttributeError:
+                    # For UnixDomainSocketConnection objects.
+                    server_pool = [connection.path]
+                #backend = self.get_backend(server_pool)
+                backend = True
+                if backend:
+                    db_start_time = get_current_timestamp_in_us()
+                    if ctx is not None:
+                        ctx.db_callout_start_time = db_start_time
+                    self.agent.logger.debug("db_call_begin for redis bt {} host {} query {} query_params {} db_start_time {}".format(bt, connection.host, command_str, None, db_start_time))
+                    exit_call = self.db_call_begin(bt, connection.host, command_str, None, db_start_time, host_str=host_name_str)
+
+        except Exception as e:
+            from pythonagent.agent.probes.havoc.havoc_manager import NDHavocException
+            if isinstance(e, NDHavocException):
+                raise e
+            self.agent.logger.exception("Exception in DB begin for redis {}".format(e))
+
+        try:
+            # Forward check_health so the original receives check_health=False when the
+            # health-check retry path calls us, preventing another check_health() cycle.
+            result = send_packed_command(connection, command,
+                                         check_health=check_health,
+                                         pythonagent_exit_call=exit_call)
+        except Exception as e:
+            self.agent.logger.exception("Error in application: {}".format(e))
+            try:
+                db_end_time = get_current_timestamp_in_us()
+                ctx = self.agent.get_transaction_context()
+                db_start_time = ctx.db_callout_start_time if ctx else 0
+                duration = get_validated_duration(db_start_time, db_end_time, "Redis")
+                if ctx:
+                    ctx.status_code = 500
+                    ctx.db_callout_start_time = 0
+                self.agent.logger.debug("db_call_end for redis 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 redis {}".format(e))
+            raise
+
+        try:
+            db_end_time = get_current_timestamp_in_us()
+            ctx = self.agent.get_transaction_context()
+            db_start_time = ctx.db_callout_start_time if ctx else 0
+            duration = get_validated_duration(db_start_time, db_end_time, "Redis")
+            if ctx:
+                ctx.status_code = 200
+                ctx.db_callout_start_time = 0
+            self.agent.logger.debug("db_call_end for redis 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.debug("Exception in DB End for redis {}".format(e))
+
+        return result
+
+
+def intercept_redis(agent, mod):
+    agent.logger.warning("Instrument module: redis.connection{}".format(", mod: {}".format(mod) if mod else ""))
+    RedisConnectionInterceptor(agent, mod.Connection).attach('send_packed_command')
+

pythonagent/agent/probes/cache/redis_asyncio.py

@@ -0,0 +1,83 @@
+"""Interceptor for Async Redis.
+
+"""
+
+from __future__ import unicode_literals
+
+from pythonagent.agent.probes.cache import CacheInterceptor
+from pythonagent.utils import generate_flow_path_id, get_utf8_bytes, get_current_timestamp_in_us, get_validated_duration
+
+
+class RedisAsyncIOConnectionInterceptor(CacheInterceptor):
+
+    def __init__(self, agent, cls):
+        super(RedisAsyncIOConnectionInterceptor, self).__init__(agent, cls, 'RedisAsyncIO')
+
+    async def _send_packed_command(self, send_packed_command, *args, **kwargs):
+
+        bt = None
+        exit_call = None
+        db_start_time = 0
+        entry_point_fqm = ""
+        host_str = ""
+        status_code = 0
+
+        try:
+            connection = args[0]
+            command = args[1]
+
+            command_str = ""
+            command_len = len(command)
+            if command_len != 0:
+                if command_len == 1:
+                    command_str = command[0].decode().split('\n')[2][:-1]
+                else:
+                    for i in range(command_len):
+                        if i < command_len - 1:
+                            command_str += command[i].decode().split('\n')[2][:-1] + ','
+                        else:
+                            command_str += command[i].decode().split('\n')[2][:-1]
+
+            if command_str == "CLIENT":
+                return await send_packed_command(*args, **kwargs)
+
+
+            # format :- "PROTOCOL|HOST|PORT|URL|DBPRODNAME|DBNAME|DBPRODVER|DRIVERNAME|DRIVERVER|USERNAME|SERVICENAME"
+            host_str = f"NA|{connection.host}|{connection.port}|NA|REDIS|{connection.db}|NA|NA|NA|{connection.username}|NA"
+            entry_point_fqm = connection.__module__ + "." + send_packed_command.__qualname__
+
+            bt = self.bt
+            query_parameters = None
+            db_start_time = get_current_timestamp_in_us()
+            exit_call = self.db_call_begin(bt, connection.host, command_str, query_parameters, db_start_time, entry_point_fqm, host_str)
+        except Exception as e:
+            from pythonagent.agent.probes.havoc.havoc_manager import NDHavocException
+            if isinstance(e, NDHavocException):
+                raise e
+            self.agent.logger.exception("Error in DB Begin part of redis_asyncio: {}".format(e))
+
+        try:
+            result = await send_packed_command(*args, **kwargs)
+        except Exception as e:
+            db_end_time = get_current_timestamp_in_us()
+            duration = get_validated_duration(db_start_time, db_end_time, "redis_asyncio")
+            status_code = 500
+            self.db_call_end(bt, exit_call, duration, db_start_time, entry_point_fqm, host_str, status_code)
+            raise
+
+        try:
+            db_end_time = get_current_timestamp_in_us()
+            duration = get_validated_duration(db_start_time, db_end_time, "Redis")
+            status_code = 200
+            self.agent.logger.debug("db_call_end for redis 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, entry_point_fqm, host_str, status_code)
+
+        except Exception as e:
+            self.agent.logger.exception("Error in DB End part of redis_asyncio: {}".format(e))
+
+        return result
+
+
+def intercept_redis_asyncio(agent, mod):
+    agent.logger.warning("Instrument module: redis.asyncio.connection{}".format(", mod: {}".format(mod) if mod else ""))
+    RedisAsyncIOConnectionInterceptor(agent, mod.Connection).attach('send_packed_command')

pythonagent/agent/probes/coroutines/__init__.py

@@ -0,0 +1 @@
+from .asyncio import intercept_asyncio

pythonagent/agent/probes/coroutines/asyncio.py

@@ -0,0 +1,63 @@
+"""Interceptor for Asyncio
+
+"""
+
+from __future__ import unicode_literals
+from ..base import ExitCallInterceptor
+
+
+class AsyncioInterceptor(ExitCallInterceptor):
+
+    def _dd_create_task(self, create_task, *args, **kwargs):
+
+        coro = self.get_argument_value(args, kwargs, 1, "coro")
+
+        context = self.agent.get_transaction_context()
+
+        async def traced_coro(*args_c, **kwargs_c):
+
+            if context and context != self.agent.get_transaction_context():
+                self.agent.set_transaction_context(context)
+
+            return await coro
+
+        args, kwargs = self.set_argument_value(args, kwargs, 1, "coro", traced_coro())
+
+        call = create_task(*args, **kwargs)
+
+        return call
+
+    def _set_event_loop(self, set_event_loop, *args, **kwargs):
+        ss = set_event_loop(*args, **kwargs)
+        return ss
+
+    def _get_event_loop(self, get_event_loop, *args, **kwargs):
+        get = get_event_loop()
+
+    def get_argument_value(self, args, kwargs, pos, kw, optional=False):
+        try:
+            return kwargs[kw]
+        except KeyError:
+            try:
+                return args[pos]
+            except IndexError:
+                if optional:
+                    return None
+                raise Exception("%s (at position %d)" % (kw, pos))
+
+    def set_argument_value(self, args, kwargs, pos, kw, value, override_unset=False):
+        if len(args) > pos:
+            args = args[:pos] + (value,) + args[pos + 1:]
+        elif kw in kwargs or override_unset:
+            kwargs[kw] = value
+        else:
+            raise Exception("%s (at position %d) is invalid" % (kw, pos))
+
+        return args, kwargs
+
+
+def intercept_asyncio(agent, mod):
+    agent.logger.warning("Instrument module: asyncio{}".format(", mod: {}".format(mod) if mod else ""))
+    AsyncioInterceptor(agent, mod.base_events.BaseEventLoop).attach('create_task',
+                                                                    patched_method_name="_dd_create_task")
+    #AsyncioInterceptor(agent, mod.events.BaseDefaultEventLoopPolicy).attach("set_event_loop")

pythonagent/agent/probes/elasticdb/__init__.py

@@ -0,0 +1,7 @@
+
+from __future__ import unicode_literals
+
+from .aelastic import intercept_elastic
+
+__all__ = ['intercept_elastic']
+

pythonagent/agent/probes/elasticdb/aelastic.py

@@ -0,0 +1,54 @@
+from __future__ import unicode_literals
+from ..base import ExitCallInterceptor
+from pythonagent.lang import str
+
+
+def intercept_elastic(agent, mod):
+    class ExitCallListener(mod.monitoring.CommandListener):
+        backend_name_format_string = '{HOST}:{PORT} - {DATABASE}'
+    
+        def __init__(self):
+            self.interceptor = ExitCallInterceptor(agent, None)
+            self.exit_call_map = {}
+            
+    
+        def get_backend(self, connection_id):
+            #agent.logger.debug('Modulenameintercept_pymongo class inside get_backend function')
+            print("connection iddddddddddddddddddddddddddddddddd::::::::::::::::::", connection_id)
+            host, port = connection_id
+            backend_properties = {
+                'HOST': host,
+                'PORT': str(port)
+            }
+            return backend_properties
+        
+        def started(self, event):
+            agent.logger.info('Modulenameintercept_elastic  class inside started  function  is ')
+            with self.interceptor.log_exceptions():
+                agent.logger.info('Modulenameintercept_elastic  class inside started  function  is ')
+            with self.interceptor.log_exceptions():
+                agent.logger.info("inside _execute funciton")
+                agent.logger.info("event:{0} ".format(event))
+                bt = self.interceptor.bt
+
+                agent.logger.info("bt statment....{0}".format(bt))
+                if not bt:
+                    bt = agent.get_current_bt()
+                agent.logger.info("new bt value{0}".format(bt))
+                if bt:
+                    backend = self.get_backend(event.connection_id, event.database_name)
+                    agent.logger.info("backend..........{0}".format(backend))
+                    agent.logger.info("Modulenameintercept_pymongo class ||  backend is{0}".format(backend))
+                    if backend:
+                        agent.logger.info("host.....".format(backend["HOST"]))
+
+                        if backend and not hasattr(event, '_pythonagent_exit_call'):
+                            exit_call = self.interceptor.db_call_begin(bt, backend["HOST"], str(event.command))
+                        self.exit_call_map[event.operation_id] = exit_call
+
+        def succeeded(self, event):
+            self.interceptor.db_call_end(self.interceptor.bt,self.exit_call_map.pop(event.operation_id,None))
+        def failed(self, event):
+            self.interceptor.db_call_end(self.interceptor.bt,self.exit_call_map.pop(event.operation_id,None))
+
+    mod.monitoring.register(ExitCallListener())