whatap-python 1.6.9__tar.gz → 1.7.0__tar.gz

{whatap_python-1.6.9 → whatap_python-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: whatap-python
-Version: 1.6.9
+Version: 1.7.0
 Summary: Monitoring and Profiling Service
 Home-page: https://www.whatap.io
 Author: whatap

whatap_python-1.7.0/whatap/build.py

@@ -0,0 +1,4 @@
+app = 'Python'
+name = 'whatap-python'
+version = '1.7.0'
+release_date = '20240924'

{whatap_python-1.6.9 → whatap_python-1.7.0}/whatap/trace/mod/application_django.py

@@ -130,7 +130,6 @@ def instrument_handlers_base(module):
             return callback
         
         return trace
-
     if hasattr(module.BaseHandler, 'apply_response_fixes'):
         module.BaseHandler.apply_response_fixes = wrapper(
             module.BaseHandler.apply_response_fixes)
@@ -152,7 +151,6 @@ def instrument_handlers_base(module):
             return callback
         
         return trace
-
     if hasattr(module.BaseHandler, 'handle_uncaught_exception'):
         module.BaseHandler.handle_uncaught_exception = wrapper(
             module.BaseHandler.handle_uncaught_exception)
@@ -183,6 +181,24 @@ def instrument_handlers_base(module):
     module.BaseHandler.get_response = get_response_wrapper(
         module.BaseHandler.get_response)
 
+    def wrapper_async(fn):
+        @trace_handler_async(fn)
+        async def trace(*args, **kwargs):
+            ## asgi applicaiton 에서 threading.local()을 사용할 경우 데이터가 침해 될 수 있다.
+            ## contextvars 를 이용하여 현재 실행중인 코루틴 콘텍스트를 유지한다.
+            request = args[1]
+            scope = request.scope
+            ctx = scope.get(WHATAP_CTX)
+            callback = await fn(*args, **kwargs)
+            ctx.asgi_response = callback
+            if ctx and conf.trace_user_enabled:
+                if not conf.trace_user_using_ip:
+                    userid_util.setUserId(request, callback, ctx._rawuserid)
+
+            return callback
+        return trace
+    if hasattr(module, 'BaseHandler') and hasattr(module.BaseHandler, 'get_response_async'):
+        module.BaseHandler.get_response_async = wrapper_async(module.BaseHandler.get_response_async)
     # if django_py3_loaded:
     #     instrument_handlers_async(module)
 

whatap_python-1.7.0/whatap/trace/mod/application_django_asgi.py

@@ -0,0 +1,263 @@
+import logging as logging_module
+import traceback
+from whatap.conf.configure import Configure as conf
+from whatap.net import async_sender
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.trace.trace_context import TraceContext
+from whatap.trace.mod.application_wsgi import isIgnore, start_interceptor, end_interceptor
+from whatap.util.hash_util import HashUtil as hash_util
+from whatap.util.userid_util import UseridUtil
+from whatap.util.date_util import DateUtil
+from whatap.util.hexa32 import Hexa32 as hexa32
+from whatap.util.keygen import KeyGen
+import whatap.util.throttle_util as throttle_util
+from whatap.net.packet_type_enum import PacketTypeEnum
+from whatap import logging
+import sys
+
+SCOPE_ARGS_LENGTH = 2
+HEADER = 'headers'
+PATH = 'path'
+USER_AGENT = 'user-agent'
+REFERER = 'referer'
+CLIENT = 'client'
+COOKIE = 'cookie'
+HOST = 'host'
+QUERY_STRING = 'query_string'
+WHATAP_CTX = '__whatap__ctx'
+logger = logging_module.getLogger(__name__)
+
+def blocking_handler_asgi():
+    def handler(func):
+        from django.http import HttpResponse, HttpResponseRedirect
+        async def wrapper(instance, scope, receive, send):
+            args = (instance, scope, receive, send)
+            scope, headers = parseHeaders(args)
+            assert scope, headers
+            if conf.throttle_enabled:
+                remote_ip = parseRemoteAddr(scope, headers)
+                path = scope.get(PATH)
+                if throttle_util.isblocking(remote_ip, path):
+                    if conf.reject_event_enabled:
+                        ctx = TraceContextManager.getLocalContext()
+                        if not ctx:
+                            ctx = TraceContext()
+                        throttle_util.sendrejectevent(ctx, path, remote_ip)
+
+                    if conf.throttle_blocked_forward:
+                        response = HttpResponseRedirect(status=302, redirect_to=conf.throttle_blocked_forward)
+
+                        if path == conf.throttle_blocked_forward:
+                            response = HttpResponse(content=conf.throttle_blocked_message, status=200)
+
+                        return await instance.send_response(response, send)
+
+                    response = HttpResponse(content=conf.throttle_blocked_message, status=403)
+                    return await instance.send_response(response, send)
+            return await func(instance, scope, receive, send)
+        return wrapper
+    return handler
+
+def trace_handler_asgi(fn):
+    def handler(func):
+        async def wrapper(instance, scope, receive, send):
+            if scope["type"] != "http":
+                await fn(instance, scope, receive, send)
+            try:
+                await func(instance, scope, receive, send)
+            except Exception as e:
+                logging.debug(e, extra={'id': 'WA917'}, exc_info=True)
+                print(e, dict(extra={'id': 'WA917'}, exc_info=True))
+                import traceback
+                traceback.print_exc()
+        return wrapper
+    return handler
+
+def trace_handler_async(fn):
+    def handler(func):
+        async def wrapper(*args, **kwargs):
+            try:
+                response = await func(*args, **kwargs)
+            except Exception as e:
+                logging.debug(e, extra={'id': 'WA917'}, exc_info=True)
+                print(e, dict(extra={'id': 'WA917'}, exc_info=True))
+                import traceback
+                traceback.print_exc()
+                return await fn(*args, **kwargs)
+            else:
+                return response
+        return wrapper
+    return handler
+
+def parseServiceName(environ):
+    return environ.get('PATH_INFO', '')
+
+def parseHeaders(args):
+    headers = {}
+    if len(args) > SCOPE_ARGS_LENGTH:
+        scope = args[1]
+        if HEADER in scope:
+            for arg in scope[HEADER]:
+                headers[str(arg[0].decode()).lower()] = str(arg[1].decode())
+
+        return scope, headers
+    return None, None
+
+def parseRemoteAddr(scope, headers):
+    remoteIp = ''
+    if CLIENT in scope:
+        remoteIp = scope.get(CLIENT)[0]
+        if conf.trace_http_client_ip_header_key:
+            header_val = headers.get(conf.trace_http_client_ip_header_key, '')
+            remoteIp = header_val.split(',')[0].strip()
+
+    return remoteIp
+
+def getUserId(scope, headers, defValue):
+    try:
+        if conf.user_header_ticket:
+            ticket = headers.get(conf.user_header_ticket, "")
+            if ticket:
+                return hash_util.hashFromString(ticket), ticket
+            return 0, ""
+        cookie = headers.get(COOKIE, "")
+        if cookie:
+            if len(cookie) >= conf.trace_user_cookie_limit:
+                return defValue
+
+            x1 = cookie.find(UseridUtil.WHATAP_R)
+            if x1 >= 0:
+                x2 = cookie.find(';', x1)
+                if x2 > 0:
+                    value = cookie[x1 + len(UseridUtil.WHATAP_R) + 1: x2]
+                else:
+                    value = cookie[x1 + len(UseridUtil.WHATAP_R) + 1:]
+                return hexa32.toLong32(value), value
+        userid = KeyGen.next()
+        return userid, hexa32.toString32(userid)
+    except Exception:
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        logger.debug("A502", 10, str(exc_value))
+
+def interceptor_error_asgi(ctx, status_code, errors):
+    ctx.status = int(status_code/ 100)
+    if ctx.status >= 4:
+        ctx.error = 1
+
+        error = ''
+        frame = sys._current_frames().get(ctx.thread.ident)
+        if not frame:
+            return
+
+        for stack in traceback.extract_stack(frame):
+            line = stack[0]
+            line_num = stack[1]
+            method_name = stack[2]
+
+            if line.find('/whatap/trace') > -1 or line.find(
+                    '/threading.py') > -1:
+                continue
+            error += '{} ({}:{})\n'.format(method_name, line, line_num)
+
+        errors.append(error)
+
+        # errors.append(''.join(traceback.format_list(traceback.extract_stack(sys._current_frames()[ctx.thread.ident]))))
+        async_sender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors)
+
+async def interceptor_asgi(fn, *args, **kwargs):
+    scope, headers = parseHeaders(args)
+    if scope == None and headers == None:
+        return await fn(*args, **kwargs)
+
+    ctx = TraceContext()
+    ctx.host = headers.get(HOST, '').split(':')[0]
+    ctx.service_name = scope.get(PATH)
+
+    ctx.remoteIp = parseRemoteAddr(scope, headers)
+
+    ctx.userAgentString = headers.get(USER_AGENT, '')
+    ctx.referer = headers.get(REFERER, '')
+
+    if conf.trace_user_enabled:
+        if conf.trace_user_using_ip:
+            ctx.userid = parseRemoteAddr(scope, headers)
+        else:
+            ctx.userid, ctx._rawuserid = getUserId(scope, headers, ctx.remoteIp)
+
+    mstt = headers.get(
+        conf._trace_mtrace_caller_key.lower().replace('-', '_'), '')
+
+    if mstt:
+        ctx.setTransfer(mstt)
+        if conf.stat_mtrace_enabled:
+            val = headers.get(
+                conf._trace_mtrace_info_key.lower().replace('-', '_'), '')
+            if val and len(val):
+                ctx.setTransferInfo(val)
+            pass
+
+        myid = headers.get(
+            conf._trace_mtrace_callee_key.lower().replace('-', '_'), '')
+        if myid:
+            ctx.setTxid(myid)
+    caller_poid = headers.get(
+        conf._trace_mtrace_caller_poid_key.upper().replace('-', '_'), '')
+
+    if caller_poid:
+        ctx.mcaller_poid = caller_poid
+
+    try:
+        if isIgnore(ctx.service_name):
+            ctx.is_ignored = True
+            return fn(*args, **kwargs)
+    except Exception as e:
+        pass
+
+    start_interceptor(ctx)
+    try:
+        scope[WHATAP_CTX] = ctx
+        await fn(*args, **kwargs)
+        response = ctx.asgi_response
+
+        query_string = str(scope.get(QUERY_STRING, ''))
+        if query_string:
+            ctx.service_name += '?{}'.format(query_string)
+
+        if ctx.service_name.find('.') > -1 and ctx.service_name.split('.')[
+            1] in conf.web_static_content_extensions:
+            ctx.isStaticContents = 'true'
+
+        if response:
+            status_code = response.status_code
+            errors = [response.__class__.__name__, response.reason_phrase]
+            interceptor_error_asgi(ctx, status_code, errors)
+
+
+        if conf.profile_http_header_enabled:
+            keys = []
+            for key, value in headers.items():
+                keys.append(key)
+            keys.sort()
+
+            text = ''
+            for key in keys:
+                text += '{}={}\n'.format(key.lower(),
+                                         headers[key])
+
+            datas = ['HTTP-HEADERS', 'HTTP-HEADERS', text]
+            ctx.start_time = DateUtil.nowSystem()
+            async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+    finally:
+        if ctx:
+            end_interceptor(ctx=ctx)
+
+def instrument_asgi(module):
+    def wrapper(fn):
+        @trace_handler_asgi(fn)
+        @blocking_handler_asgi()
+        async def trace(instance, scope, receive, send):
+            await interceptor_asgi(fn, instance, scope, receive, send)
+        return trace
+
+    ### module 있는지 체크 하고 파일을 분리해야함.
+    module.ASGIHandler.__call__ = wrapper(module.ASGIHandler.__call__)

{whatap_python-1.6.9 → whatap_python-1.7.0}/whatap/trace/mod/application_fastapi.py

@@ -241,7 +241,7 @@ def interceptor(fn, dependant, *args, **kwargs):
 async def interceptor_async(fn, dependant, *args, **kwargs):
     if not hasattr(dependant, _WHATAP_DICT):
         return await fn(*args, **kwargs)
-
+    
     ctx = TraceContextManager.getLocalContext()
     
     ctx.service_name = dependant.path
@@ -288,7 +288,7 @@ async def interceptor_async(fn, dependant, *args, **kwargs):
             return await fn(*args, **kwargs)
     except Exception as e:
         pass
-
+    
     start_interceptor(ctx)
     
     try:
@@ -391,7 +391,7 @@ def instrument_util(module):
                             'query_params': copy(request.query_params),
                         })
             ret = await fn(*args, **kwargs)            
-            if len(ret) >= 4:
+            if hasattr(ret, '__len__') and len(ret) >= 4:
                 response = ret[3]
                 whatap_dict[_RESPONSE] = response
             

{whatap_python-1.6.9 → whatap_python-1.7.0}/whatap/trace/trace_context.py

@@ -32,7 +32,7 @@ class TraceContext(object):
         self.start_malloc = 0
 
         self.status = 0
-
+        self.asgi_response= None
         self.service_hash = 0
         self.service_name = ''
         self.remoteIp = ''

{whatap_python-1.6.9 → whatap_python-1.7.0}/whatap/trace/trace_module_definition.py

@@ -17,7 +17,6 @@ DEFINITION = {
     ],
     'httpc_urllib3': [
         ('urllib3.request', 'instrument_urllib3'),
-        # ('requests.packages.urllib3.request', 'instrument_urllib3'),
     ],
     'httpc_django': [
         ('revproxy.views', 'instrument_revproxy_views'),
@@ -50,8 +49,6 @@ DEFINITION = {
     ],
     'application_django': [
         ('django.core.handlers.wsgi', 'instrument'),
-        ('django.core.handlers.asgi', 'instrument_asgi'),
-        
         ('django.core.handlers.base', 'instrument_handlers_base'),
         ('django.views.generic.base', 'instrument_generic_base'),
         ('django.contrib.staticfiles.handlers', 'instrument_handlers_static'),
@@ -64,6 +61,9 @@ DEFINITION = {
          False),
 
     ],
+    'application_django_asgi': [
+        ('django.core.handlers.asgi', 'instrument_asgi'),
+    ],
     'application_flask': [
         ('flask', 'instrument'),
     ],
@@ -71,15 +71,9 @@ DEFINITION = {
         ('tornado.web', 'instrument'),
     ],
     'application_celery': [
-        # ('celery.task.base', 'instrument_task_base'),
-        #('celery.app.task', 'instrument_app_task'),
-        #('celery.worker', 'instrument_celery_worker'),
-        #('celery.concurrency.processes', 'instrument_celery_worker'),
-        #('celery.concurrency.prefork', 'instrument_celery_worker'),
         ('celery.execute.trace', 'instrument_celery_execute_trace'),
         ('celery.task.trace', 'instrument_celery_execute_trace'),
         ('celery.app.trace', 'instrument_celery_execute_trace'),
-        #('billiard.pool', 'instrument_billiard_pool'),
     ],
     'database_redis':[
         ('redis','instrument_redis_connection'),
@@ -87,9 +81,6 @@ DEFINITION = {
     'email_smtp':[
         ('smtplib','instrument_smtp'),
     ],
-    # 'amqp_kombu':[
-    #     ('kombu','instrument_kombu'),
-    # ],
     'amqp_pika':[
         ('pika.channel','instrument_pika'),
     ],
@@ -98,8 +89,6 @@ DEFINITION = {
         ('spsengine.containers', 'instrument_nameko_spawn_worker'),
     ],
     'application_graphql':[
-        #('graphql','instrument_graphql'),
-
         #graphen-core 3.x~
         ('graphql.execution.execute','instrument_graphql'),
 

{whatap_python-1.6.9 → whatap_python-1.7.0}/whatap_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: whatap-python
-Version: 1.6.9
+Version: 1.7.0
 Summary: Monitoring and Profiling Service
 Home-page: https://www.whatap.io
 Author: whatap

{whatap_python-1.6.9 → whatap_python-1.7.0}/whatap_python.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ whatap/trace/mod/application_bottle.py
 whatap/trace/mod/application_celery.py
 whatap/trace/mod/application_cherrypy.py
 whatap/trace/mod/application_django.py
+whatap/trace/mod/application_django_asgi.py
 whatap/trace/mod/application_django_py3.py
 whatap/trace/mod/application_fastapi.py
 whatap/trace/mod/application_flask.py

whatap_python-1.6.9/whatap/build.py

@@ -1,4 +0,0 @@
-app = 'Python'
-name = 'whatap-python'
-version = '1.6.9'
-release_date = '20240903'