whatap-python 2.1.0__py3-none-any.whl

whatap/scripts/__init__.py

@@ -0,0 +1,208 @@
+import os
+import re
+import time
+from functools import wraps
+
+import sys, threading
+
+from whatap import check_whatap_home, ROOT_DIR, init_config, update_config, \
+    batch_agent, AGENT_NAME, go, configPort, configLlmPort, preview_whatap_conf
+
+
+def whatap_command(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if len(sys.argv) == 1:
+            print('WHATAP: INVALID ARGMENTS.')
+            print(func.__doc__)
+        else:
+            if check_whatap_home():
+                return func(*args, **kwargs)
+    
+    return wrapper
+
+def start_agent_batch():
+    batch_agent()
+
+def stop_agent():
+    try:
+        if sys.platform == 'win32':
+            # Windows: use taskkill command
+            os.system('taskkill /F /IM {}.exe'.format(AGENT_NAME))
+        else:
+            # Unix/Linux: use killall command
+            os.system('killall {}'.format(AGENT_NAME))
+    except Exception as e:
+        if sys.platform == 'win32':
+            print('Try to execute command: tasklist | findstr {}'.format(AGENT_NAME))
+            print('Next, taskkill /F /IM {}.exe'.format(AGENT_NAME))
+        else:
+            print(
+                'Try to execute command. \n  {}'.format(
+                    '`ps -ef | grep {}`'.format(AGENT_NAME)))
+            print(
+                'Next, `sudo killall {}`'.format(AGENT_NAME))
+    finally:
+        print('WHATAP: AGENT STOP.')
+    
+@whatap_command
+def start_agent():
+    """
+    Usage:
+         whatap-start-agent [YOUR_APPLICATION_START_COMMAND]
+    """
+    
+    args = sys.argv[1:]
+    root_directory = os.path.dirname(ROOT_DIR)
+    boot_directory = os.path.join(root_directory, 'bootstrap')
+    
+    python_path = boot_directory
+    
+    if 'PYTHONPATH' in os.environ:
+        path = os.environ['PYTHONPATH'].split(os.path.pathsep)
+        if not boot_directory in path:
+            python_path = "%s%s%s" % (boot_directory, os.path.pathsep,
+                                      os.environ['PYTHONPATH'])
+    
+    os.environ['PYTHONPATH'] = python_path
+    
+    program_exe_path = args[0]
+    if not os.path.dirname(program_exe_path):
+        program_search_path = os.environ.get('PATH', '').split(os.path.pathsep)
+        for path in program_search_path:
+            path = os.path.join(path, program_exe_path)
+            # On Windows, X_OK check is unreliable, so just check existence
+            if sys.platform == 'win32':
+                if os.path.exists(path):
+                    program_exe_path = path
+                    break
+            else:
+                if os.path.exists(path) and os.access(path, os.X_OK):
+                    program_exe_path = path
+                    break
+    
+    port = None
+    try:
+        port = configPort()
+    except Exception as e:
+        print('WHATAP: AGENT ERROR: {}'.format(e))
+        print('WHATAP: continue to start user application')
+
+    if port:
+        apm_enabled = preview_whatap_conf("apm_enabled")
+        llm_enabled = preview_whatap_conf("llm_enabled")
+
+        if apm_enabled == 'true':
+            try:
+                go(opts={'whatap.port': str(port)})
+                standalone_enabled = preview_whatap_conf("standalone_enabled")
+                if standalone_enabled == 'true':
+                    time.sleep(1)
+            except Exception as e:
+                print('WHATAP: AGENT ERROR: {}'.format(e))
+                print('WHATAP: continue to start user application')
+
+        if llm_enabled == 'true':
+            try:
+                llm_port = configLlmPort()
+                if llm_port:
+                    go(opts={'whatap.port': str(port)}, llm=True)
+                else:
+                    print('WHATAP: LLM port allocation failed')
+            except Exception as e:
+                print('WHATAP: LLM AGENT ERROR: {}'.format(e))
+
+    try:
+        if sys.platform == 'win32':
+            # Windows: use subprocess instead of execl
+            import subprocess
+            result = subprocess.call(args)
+            sys.exit(result)
+        else:
+            # Unix/Linux: use execl to replace current process
+            os.execl(program_exe_path, *args)
+    except Exception as e:
+        print('WHATAP: INVALID ARGMENTS.')
+        print(start_agent.__doc__)
+
+
+OPTIONS = ['--host', '--license', '--app_name', '--app_process_name']
+
+
+@whatap_command
+def setting_config():
+    """
+    Usage:
+        whatap-setting-config [--host HOST_ADDR]
+                              [--license LICENSE_KEY]
+                              [--app_name APPLICATION_NAME]
+                              [--app_process_name APPLICATION_PROCESS_NAME]
+    """
+    home = 'WHATAP_HOME'
+    if init_config(home):
+        print('WHATAP:')
+        args = ' '.join(sys.argv[1:])
+        is_success=False
+        for opt in OPTIONS:
+            key = opt.split('--')[1]
+            m = re.match(r"[\s\w\-\_\.\/]*" + key + " (?P<key>[\w\-\_\.\/]*)", args)
+            if m:
+                if key == 'host':
+                    key = 'whatap.server.{}'.format(key)
+                update_config(home, key, m.group('key'))
+                print('\t{}={}'.format(key, m.group('key')))
+                is_success = True
+
+        update_config(home, 'apm_enabled', 'true')
+        update_config(home, 'llm_enabled', 'false')
+        print('\tapm_enabled=true')
+        print('\tllm_enabled=false')
+
+        if is_success:
+            print('SUCCESS!')
+        else:
+            print(setting_config.__doc__)
+
+
+LLM_OPTIONS = ['--host', '--license', '--app_name', '--app_process_name']
+
+
+@whatap_command
+def llm_setting_config():
+    """
+    Usage:
+        whatap-llm-setting-config [--host HOST_ADDR]
+                                  [--license LICENSE_KEY]
+                                  [--app_name APPLICATION_NAME]
+                                  [--app_process_name APPLICATION_PROCESS_NAME]
+    """
+    home = 'WHATAP_HOME'
+    if init_config(home):
+        print('WHATAP:')
+        args = ' '.join(sys.argv[1:])
+        is_success=False
+        for opt in LLM_OPTIONS:
+            key = opt.split('--')[1]
+            m = re.match(r"[\s\w\-\_\.\/]*" + key + " (?P<key>[\w\-\_\.\/]*)", args)
+            if m:
+                if key == 'host':
+                    key = 'llm.whatap.server.{}'.format(key)
+                elif key == 'license':
+                    key = 'llm_accesskey'
+                update_config(home, key, m.group('key'))
+                print('\t{}={}'.format(key, m.group('key')))
+                is_success = True
+
+        update_config(home, 'apm_enabled', 'false')
+        update_config(home, 'llm_enabled', 'true')
+        update_config(home, 'counter_thread_enabled', 'true')
+        print('\tapm_enabled=false')
+        print('\tllm_enabled=true')
+        print('\tcounter_thread_enabled=true')
+
+        if is_success:
+            print('SUCCESS!')
+        else:
+            print(llm_setting_config.__doc__)
+    
+    

whatap/trace/__init__.py

@@ -0,0 +1,12 @@
+import ctypes
+
+from whatap.trace.trace_context_manager import TraceContextManager
+
+_get_dict = ctypes.pythonapi._PyObject_GetDictPtr
+_get_dict.restype = ctypes.POINTER(ctypes.py_object)
+_get_dict.argtypes = [ctypes.py_object]
+
+
+def get_dict(obj):
+    return _get_dict(obj).contents.value
+

whatap/trace/mod/amqp/kombu.py

@@ -0,0 +1,122 @@
+from whatap.trace import get_dict
+from whatap.trace.trace_handler import trace_handler
+from whatap.trace.trace_error import interceptor_step_error
+from whatap.trace.mod.application.wsgi import \
+    start_interceptor, end_interceptor
+from whatap.trace.trace_context import TraceContext
+from whatap.trace.trace_context_manager import TraceContextManager
+import whatap.net.async_sender as async_sender
+from whatap.net.packet_type_enum import PacketTypeEnum
+from whatap.util.date_util import DateUtil
+
+def parseCallbackName(args):
+    if args:
+        receiver = args[0]
+        callbackspan = []
+
+        if len(args) > 2:
+            message = args[2]
+            if hasattr(message, 'delivery_info'):
+                if 'exchange' in message.delivery_info:
+                    callbackspan.append(message.delivery_info['exchange'])
+                if 'routing_key' in message.delivery_info:
+                    callbackspan.append(message.delivery_info['routing_key'])
+
+        if not callbackspan:
+            callback = receiver.callbacks[0]
+            if isinstance(callback, partial):
+                callback = callback.func
+
+            if hasattr(callback, '__qualname__'):
+                callbackspan.append(callback.__qualname__)
+            else:
+                if hasattr(callback, '__module__'):
+                    callbackspan.append(callback.__module__)
+                if hasattr(callback, '__self__'):
+                    callbackspan.append(callback.__self__.__class__.__name__)
+                if hasattr(callback, '__name__'):
+                    callbackspan.append(callback.__name__)
+
+        return '.'.join(callbackspan)
+    return ''
+
+def intercept_receive(fn, *args, **kwargs):
+    ctx = TraceContext()
+    ctx.service_name = parseCallbackName(args)
+    start_interceptor(ctx)
+
+    try:
+        callback = fn(*args, **kwargs)
+        ctx = TraceContextManager.getLocalContext()
+        return callback
+    except Exception as e:
+        interceptor_step_error(e)
+    finally:
+        if ctx:
+            end_interceptor(ctx=ctx)
+
+def parseConnection(conn):
+    connstr = ''
+    if conn.host:
+        connstr += conn.host
+    if conn.virtual_host:
+        connstr += "/" + conn.virtual_host
+    return connstr
+
+def intercept_publish(fn, *args, **kwargs):
+    ctx = TraceContextManager.getLocalContext()
+
+    start_time = DateUtil.nowSystem()
+    ctx.start_time = start_time
+
+    text = 'rabbitmq://'
+    text += parseConnection(args[0].channel.connection)
+    text += '?exchage='
+    text += args[10]
+    text += '&routing='
+    text += args[7]
+    ctx.active_dbc = text
+    ctx.lctx['dbc'] = text
+
+    ctx.active_dbc = 0
+    ctx.db_opening = True
+    ctx.elapsed = DateUtil.nowSystem() - start_time
+
+    datas = [' ', ' ', 'MQ SESSION INFO: ' + text]
+    async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+
+
+    start_time = DateUtil.nowSystem()
+    ctx.start_time = start_time
+
+    try:
+        callback = fn( *args, **kwargs)
+        return callback
+    except Exception as e:
+        interceptor_step_error(e)
+    finally:
+        ctx.db_opening = False
+
+def instrument_kombu(module):
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            callback = intercept_publish(fn, *args, **kwargs)
+            return callback
+        
+        return trace
+
+    if hasattr(module, 'Producer') and hasattr(module.Producer, '_publish'):
+        module.Producer._publish = wrapper(module.Producer._publish)
+
+    def wrapper(fn):
+        @trace_handler(fn, start=True)
+        def trace(*args, **kwargs):
+            callback = intercept_receive(fn, *args, **kwargs)
+            return callback
+
+        return trace
+
+    if hasattr(module, 'Consumer') and hasattr(module.Consumer, 'receive'):
+        module.Consumer.receive = wrapper(module.Consumer.receive)
+

whatap/trace/mod/amqp/pika.py

@@ -0,0 +1,62 @@
+from whatap.trace import get_dict
+from whatap.trace.trace_handler import trace_handler
+from whatap.trace.trace_error import interceptor_step_error
+from whatap.trace.mod.application.wsgi import \
+    start_interceptor, end_interceptor
+from whatap.trace.trace_context import TraceContext
+from whatap.trace.trace_context_manager import TraceContextManager
+import whatap.net.async_sender as async_sender
+from whatap.net.packet_type_enum import PacketTypeEnum
+from whatap.util.date_util import DateUtil
+
+
+def parseConnection(conn):
+    connstr = ''
+    if conn.host:
+        connstr += conn.host
+    if conn.virtual_host:
+        connstr += "/" + conn.virtual_host
+    return connstr
+
+
+def intercept_publish(fn, *args, **kwargs):
+    ctx = TraceContextManager.getLocalContext()
+
+    start_time = DateUtil.nowSystem()
+    ctx.start_time = start_time
+    text = 'rabbitmq://'
+    text += parseConnection(args[0].connection.params)
+    text += '?exchage='
+    text += kwargs['exchange']
+    text += '&routing='
+    text += kwargs['routing_key']
+    ctx.active_dbc = text
+    ctx.lctx['dbc'] = text
+
+    try:
+        result = fn(*args, **kwargs)
+
+        ctx.active_dbc = 0
+        ctx.db_opening = True
+        ctx.elapsed = DateUtil.nowSystem() - start_time
+        datas = [' ', ' ', 'MQ SESSION INFO: ' + text]
+        async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+
+        return result
+    except Exception as e:
+        ctx.active_dbc = 0
+        ctx.db_opening = False
+        ctx.elapsed = DateUtil.nowSystem() - start_time
+        raise e
+
+
+def instrument_pika(module):
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            return intercept_publish(fn, *args, **kwargs)
+
+        return trace
+
+    if hasattr(module, 'Channel') and hasattr(module.Channel, 'basic_publish'):
+        module.Channel.basic_publish = wrapper(module.Channel.basic_publish)

whatap/trace/mod/application/bottle.py

@@ -0,0 +1,34 @@
+from whatap.trace.trace_handler import trace_handler
+from whatap.trace.trace_error import interceptor_error
+from whatap.trace.mod.application.wsgi import interceptor
+
+
+def instrument(module):
+    def wrapper(fn):
+        @trace_handler(fn, True)
+        def trace(*args, **kwargs):
+            callback = interceptor(fn, *args, **kwargs)
+            return callback
+        
+        return trace
+    
+    module.Bottle.__call__ = wrapper(module.Bottle.__call__)
+    
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            callback = fn(*args, **kwargs)
+            if len(args) > 3:
+                e = args[3]
+                status_code = args[1]
+            else:
+                e = args[0]
+                status_code = e._status_code
+            
+            errors = [e.__class__.__name__, str(e)]
+            interceptor_error(status_code, errors)
+            return callback
+        
+        return trace
+    
+    module.HTTPError.__init__ = wrapper(module.HTTPError.__init__)

whatap/trace/mod/application/celery.py

@@ -0,0 +1,81 @@
+from functools import wraps
+from whatap.trace.trace_context import TraceContext
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.trace.trace_error import interceptor_step_error
+from whatap.trace.mod.application.wsgi import start_interceptor, end_interceptor
+from whatap import logging
+from whatap.conf.configure import Configure as conf
+import time
+
+def interceptor(fn, task_name, *args, **kwargs):
+    now = time.time()
+    if now - conf.last_loaded > conf.init_load_interval/1000:
+        conf.init(False)
+    ctx = TraceContext()
+    ctx.service_name = task_name
+    start_interceptor(ctx)
+    try:
+        callback = fn(*args, **kwargs)
+        ctx = TraceContextManager.getLocalContext()
+        return callback
+    except Exception as e:
+        interceptor_step_error(e)
+        raise e
+    finally:
+        if ctx:
+            end_interceptor(ctx=ctx)
+
+def trace_handler(fn, start=False):
+    def handler(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+
+            ctx = TraceContextManager.getLocalContext()
+
+            if not start and not ctx:
+                return fn(*args, **kwargs)
+
+            try:
+                callback = func(*args, **kwargs)
+            except Exception as e:
+                ctx = TraceContextManager.getLocalContext()
+                if ctx and ctx.error_step == e:
+                    ctx.error_step = None
+                    raise e
+                raise
+            else:
+                ctx = TraceContextManager.getLocalContext()
+                if ctx and ctx.error_step:
+                    e = ctx.error_step
+                    ctx.error_step = None
+                    raise e
+                return callback
+
+        return wrapper
+
+    return handler
+
+celery_injection_processed = False
+def instrument_celery_execute_trace(module):
+    global celery_injection_processed
+    if celery_injection_processed:
+        return
+    def wrapper(fn, task_name):
+        @trace_handler(fn, start=True)
+        def trace(*args, **kwargs):
+            callback = interceptor(fn, task_name, *args, **kwargs)
+            return callback
+
+        return trace
+    if hasattr(module, 'build_tracer'):
+        _build_tracer = module.build_tracer
+        def build_tracer(name, task,*args, **kwargs):
+            task = task or module.tasks[name]
+            name = ''
+            if hasattr(task,'name'):
+                name = task.name
+            task.run = wrapper(task.run, name)
+            return _build_tracer(name, task,*args, **kwargs)
+
+        module.build_tracer = build_tracer
+        celery_injection_processed = True

whatap/trace/mod/application/cherrypy.py

@@ -0,0 +1,30 @@
+from whatap.trace.trace_handler import trace_handler
+from whatap.trace.trace_error import interceptor_error
+from whatap.trace.mod.application.wsgi import interceptor
+
+
+def instrument(module):
+    def wrapper(fn):
+        @trace_handler(fn, True)
+        def trace(*args, **kwargs):
+            callback = interceptor(fn, *args, **kwargs)
+            return callback
+        
+        return trace
+    
+    module.Application.__call__ = wrapper(module.Application.__call__)
+    
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            callback = fn(*args, **kwargs)
+            
+            e = args[0]
+            status_code = e.code
+            errors = [e.reason, e._message]
+            interceptor_error(status_code, errors)
+            return callback
+        
+        return trace
+    
+    module.HTTPError.set_response = wrapper(module.HTTPError.set_response)