whatap-python 2.1.0__py3-none-any.whl

whatap/trace/mod/application/django.py

@@ -0,0 +1,287 @@
+from whatap.conf.configure import Configure as conf
+from whatap.net.packet_type_enum import PacketTypeEnum
+import whatap.net.async_sender as async_sender
+from whatap.trace.trace_handler import trace_handler
+from whatap.trace.trace_error import interceptor_error, interceptor_step_error
+from whatap.trace.mod.application.wsgi import interceptor
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.trace.trace_context import TraceContext
+from whatap.util.date_util import DateUtil
+from whatap.util.userid_util import UseridUtil as userid_util
+import whatap.util.throttle_util as throttle_util
+import time
+
+def blocking_handler():
+    def handler(func):
+        from django.http import HttpResponse
+        def wrapper(*args, **kwargs):
+            if conf.throttle_enabled and args and len(args) > 2:
+                remote_ip = userid_util.getRemoteAddr(args)
+                req = args[1]
+                path = req['PATH_INFO']
+                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 = HttpResponse(status=302)
+                        response['Location'] = conf.throttle_blocked_forward
+                        return response
+                    status = '403 Forbidden'
+                    start_response= args[2]
+                    start_response(status, [])
+                    response = HttpResponse(content=conf.throttle_blocked_message, status=403)
+                    return response
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return handler
+
+def instrument(module):
+    def wrapper(fn):
+        @trace_handler(fn, True)
+        @blocking_handler()
+        def trace(*args, **kwargs):
+            django_instance = args[0]
+            environ = args[1]
+            original_start_response = args[2]
+
+            def custom_start_response(status, response_headers, exc_info=None):
+                ctx = TraceContextManager.getLocalContext()
+                ctx.status = status[:3]
+                return original_start_response(status, response_headers, exc_info)
+
+            new_args = (django_instance, environ, custom_start_response)
+            callback = interceptor(fn, *new_args, **kwargs)
+            return callback
+        
+        return trace
+    
+    module.WSGIHandler.__call__ = wrapper(module.WSGIHandler.__call__)
+
+def instrument_asgi(module):
+    def wrapper(fn):
+        @trace_handler(fn, True)
+        @blocking_handler()
+        def trace(*args, **kwargs):
+            callback = interceptor(fn, *args, **kwargs)
+
+            return callback
+        
+        return trace
+
+    module.ASGIHandler.__call__ = wrapper(module.ASGIHandler.__call__)
+
+try:
+    from whatap.trace.mod.application.django_py3 import \
+        instrument_handlers_async, interceptor_async,\
+        trace_handler_async, blocking_handler_async,\
+        parseHeaders as parseHeadersAsync,\
+        WHATAP_CTX
+    
+    django_py3_loaded = True
+except Exception as e:
+    print("application.django error:",e)
+    django_py3_loaded = False
+
+def instrument_handlers_channels(module):
+    def wrapper(fn):
+        @trace_handler_async(fn, True)
+        @blocking_handler_async()
+        async def trace(*args, **kwargs):
+            if django_py3_loaded:
+                callback = await interceptor_async(fn, *args, **kwargs)
+            else:
+                callback = await fn(*args, **kwargs)
+
+            return callback
+        
+        return trace
+    
+    module.AsgiHandler.__call__ = wrapper(module.AsgiHandler.__call__)
+    
+
+def instrument_handlers_base(module):
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            request = args[1]
+            ctx = TraceContextManager.getLocalContext()
+            callback = fn(*args, **kwargs)
+            
+            if conf.trace_auto_normalize_enabled:
+                resolver_match = request.resolver_match
+                if resolver_match:
+                    
+                    path = request.path
+                    for key, value in resolver_match.kwargs.items():
+                        path = path.replace(resolver_match.kwargs[key],
+                                            '{' + key + '}')
+                    
+                    start_time = DateUtil.nowSystem()
+                    ctx.start_time = start_time
+                    ctx.service_name = path
+                    
+                    if hasattr(resolver_match, 'view_name'):
+                        type_name = 'View' \
+                            if resolver_match._func_path != resolver_match.view_name \
+                            else 'Function'
+                        desc = '{0}: {1}'.format(type_name,
+                                                 resolver_match._func_path)
+                        datas = [' ', ' ', desc]
+                        ctx.elapsed = DateUtil.nowSystem() - start_time
+                        async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx,
+                                               datas)
+
+            return callback
+        
+        return trace
+    if hasattr(module.BaseHandler, 'apply_response_fixes'):
+        module.BaseHandler.apply_response_fixes = wrapper(
+            module.BaseHandler.apply_response_fixes)
+
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            callback = fn(*args, **kwargs)
+            
+            e = args[3]
+            status_code = callback.status_code
+            errors = [e[0].__name__,
+                      e[1].args[1] if len(
+                          e[1].args) > 1 \
+                          else repr(e[1].args[0])]
+
+            interceptor_error(status_code, errors)
+            
+            return callback
+        
+        return trace
+    if hasattr(module.BaseHandler, 'handle_uncaught_exception'):
+        module.BaseHandler.handle_uncaught_exception = wrapper(
+            module.BaseHandler.handle_uncaught_exception)
+
+    def populateLocalContextAsync(*args, **kwargs):
+        if len(args) < 2:
+            return
+        request = args[1]
+        if hasattr(request, 'scope') and WHATAP_CTX in request.scope:
+            ctx = request.scope[WHATAP_CTX]
+            ctx.thread_id = TraceContextManager.getCurrentThreadId()
+            TraceContextManager.setLocalContext(ctx)
+
+    def get_response_wrapper(fn):
+        @trace_handler(fn, preload=populateLocalContextAsync)
+        def trace(*args, **kwargs):
+            request = args[1]
+            ctx = TraceContextManager.getLocalContext()
+            callback = fn(*args, **kwargs)
+            
+            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
+    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)
+
+def instrument_generic_base(module):
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            self = args[0]
+            ctx = TraceContextManager.getLocalContext()
+            start_time = DateUtil.nowSystem()
+            ctx.start_time = start_time
+            desc = '{0}.{1}'.format(self.__module__, type(self).__name__)
+            datas = [' ', ' ', desc]
+            
+            ctx.elapsed = DateUtil.nowSystem() - start_time
+            async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+            
+            try:
+                callback = fn(*args, **kwargs)
+            except Exception as e:
+                interceptor_step_error(e, ctx = ctx)
+                raise e
+            return callback
+        
+        return trace
+    
+    module.View.dispatch = wrapper(module.View.dispatch)
+
+
+
+
+# Django==1.10
+
+def instrument_urls_base(module):
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            callback = fn(*args, **kwargs)
+            return callback
+        
+        return trace
+    
+    module.reverse = wrapper(module.reverse)
+
+
+def instrument_handlers_exception(module):
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            print("exception handler called ", args, kwargs)
+            callback = fn(*args, **kwargs)
+            return callback
+        
+        return trace
+    
+    module.convert_exception_to_response.convert_exception_to_response = wrapper(
+        module.convert_exception_to_response.convert_exception_to_response)
+
+def instrument_handlers_static(module):
+    def get_response_wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            callback = fn(*args, **kwargs)
+
+            ctx = TraceContextManager.getLocalContext()
+            if ctx:
+                ctx.userid = 0
+
+            return callback
+
+        return trace
+
+    module.StaticFilesHandler.get_response = get_response_wrapper(
+        module.StaticFilesHandler.get_response)
+
+

whatap/trace/mod/application/django_asgi.py

@@ -0,0 +1,266 @@
+import logging as logging_module
+import os
+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
+
+from whatap.util.frame_util import get_current_frame
+
+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 hash_util.hashFromString(defValue) if defValue else 0, defValue or ""
+
+            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))
+        return hash_util.hashFromString(defValue) if defValue else 0, defValue or ""
+
+def interceptor_error_asgi(ctx, status_code, errors):
+    ctx.status = int(status_code/ 100)
+    if ctx.status >= 4:
+        ctx.error = 1
+
+        error = ''
+        frame = get_current_frame(ctx)
+        if not frame:
+            return
+
+        for stack in traceback.extract_stack(frame):
+            line = stack[0]
+            line_num = stack[1]
+            method_name = stack[2]
+
+            if 'whatap' + os.sep + 'trace' in line or 'threading.py' in line:
+                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__)