whatap-python 2.1.0__py3-none-any.whl

whatap/trace/mod/application/fastapi/scope.py

@@ -0,0 +1,115 @@
+"""FastAPI 계측 — ASGI scope/headers 파싱 + TraceContext 주입.
+
+TX 패킷을 발사하지 않는다. scope 에서 값을 꺼내 ctx 필드에 옮기기만 한다.
+"""
+import logging as logging_module
+import sys
+
+from whatap.conf.configure import Configure as conf
+from whatap.util.hash_util import HashUtil
+from whatap.util.hexa32 import Hexa32
+from whatap.util.keygen import KeyGen
+from whatap.util.userid_util import UseridUtil
+
+logger = logging_module.getLogger(__name__)
+
+
+def parse_headers(scope):
+    """ASGI raw headers(list of [bytes, bytes]) → lowercase str dict."""
+    headers = {}
+    for item in scope.get('headers') or ():
+        if not item or len(item) < 2:
+            continue
+        name, value = item[0], item[1]
+        try:
+            k = (name.decode('latin-1').lower()
+                 if isinstance(name, (bytes, bytearray))
+                 else str(name).lower())
+            v = (value.decode('latin-1')
+                 if isinstance(value, (bytes, bytearray))
+                 else str(value))
+        except Exception:
+            continue
+        headers[k] = v
+    return headers
+
+
+def client_ip(scope, headers):
+    """trace_http_client_ip_header_key → x-forwarded-for → scope['client']."""
+    configured = conf.trace_http_client_ip_header_key
+    if configured:
+        v = headers.get(configured.lower())
+        if v:
+            return v.split(',')[0].strip()
+    xff = headers.get('x-forwarded-for')
+    if xff:
+        return xff.split(',')[0].strip()
+    client = scope.get('client')
+    if client:
+        return client[0]
+    return ''
+
+
+def resolve_user_id(headers, fallback_ip):
+    """user_header_ticket → WhaTap 쿠키 → 신규발급. (userid, raw_value)."""
+    try:
+        if conf.user_header_ticket:
+            ticket = headers.get(conf.user_header_ticket)
+            if ticket:
+                return HashUtil.hashFromString(ticket), ticket
+            return 0, ''
+
+        cookie = headers.get('cookie')
+        if cookie:
+            if len(cookie) >= conf.trace_user_cookie_limit:
+                return _fallback_userid(fallback_ip)
+            idx = cookie.find(UseridUtil.WHATAP_R)
+            if idx >= 0:
+                end = cookie.find(';', idx)
+                start = idx + len(UseridUtil.WHATAP_R) + 1
+                value = cookie[start:end] if end > 0 else cookie[start:]
+                return Hexa32.toLong32(value), value
+
+        fresh = KeyGen.next()
+        return fresh, Hexa32.toString32(fresh)
+    except Exception:
+        _, exc, _ = sys.exc_info()
+        logger.debug('A057', 10, str(exc))
+        return _fallback_userid(fallback_ip)
+
+
+def _fallback_userid(fallback_ip):
+    if fallback_ip:
+        return HashUtil.hashFromString(fallback_ip), fallback_ip
+    return 0, ''
+
+
+def populate_ctx(ctx, scope, headers):
+    """ctx 의 요청 메타 / 유저 / mtrace 필드 일괄 주입."""
+    ctx.host = (headers.get('host') or '').split(':')[0]
+    ctx.service_name = scope.get('path') or ''
+    ctx.http_method = scope.get('method') or ''
+    ctx.remoteIp = client_ip(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 = ctx.remoteIp
+        else:
+            ctx.userid, ctx._rawuserid = resolve_user_id(headers, ctx.remoteIp)
+
+    caller = headers.get(conf._trace_mtrace_caller_key.lower(), '')
+    if caller:
+        ctx.setTransfer(caller)
+        if conf.stat_mtrace_enabled:
+            info = headers.get(conf._trace_mtrace_info_key.lower(), '')
+            if info:
+                ctx.setTransferInfo(info)
+        callee = headers.get(conf._trace_mtrace_callee_key.lower(), '')
+        if callee:
+            ctx.setTxid(callee)
+
+    poid = headers.get(conf._trace_mtrace_caller_poid_key.lower(), '')
+    if poid:
+        ctx.mcaller_poid = poid

whatap/trace/mod/application/fastapi/transaction.py

@@ -0,0 +1,67 @@
+"""FastAPI TX 라이프사이클 — TX_START / TX_END 발사 전담.
+
+`start_interceptor` / `end_interceptor` 직접 호출은 이 모듈 두 함수
+(`begin`, `finish`) 안에만 존재한다. 패키지 전체에서 이 두 함수 외로
+라이프사이클 패킷을 발사하지 않는다.
+"""
+from whatap.conf.configure import Configure as conf
+from whatap.net import async_sender
+from whatap.net.packet_type_enum import PacketTypeEnum
+from whatap.trace.mod.application.wsgi import (
+    end_interceptor,
+    isIgnore,
+    start_interceptor,
+)
+from whatap.trace.trace_error import interceptor_error
+from whatap.util.date_util import DateUtil
+
+
+def is_ignored(service_name):
+    try:
+        return isIgnore(service_name)
+    except Exception:
+        return False
+
+
+def begin(ctx):
+    """TX_START 발사."""
+    start_interceptor(ctx)
+
+
+def finish(ctx, scope, headers, status_code):
+    """query_string 반영 / 정적 마킹 / status 에러 / 헤더 프로파일 / TX_END."""
+    qs = scope.get('query_string') or b''
+    if qs:
+        try:
+            qs_str = (qs.decode('latin-1')
+                      if isinstance(qs, (bytes, bytearray))
+                      else str(qs))
+        except Exception:
+            qs_str = ''
+        if qs_str and '?' not in (ctx.service_name or ''):
+            ctx.service_name = (ctx.service_name or '') + '?' + qs_str
+
+    name = ctx.service_name or ''
+    if '.' in name:
+        ext = name.rsplit('.', 1)[-1].split('?')[0]
+        if ext in conf.web_static_content_extensions:
+            ctx.isStaticContents = 'true'
+
+    if status_code and status_code >= 400:
+        interceptor_error(
+            status_code,
+            ['HTTPResponse', 'Status {}'.format(status_code)],
+            ctx=ctx,
+        )
+
+    if conf.profile_http_header_enabled and headers:
+        text = ''.join(
+            '{}={}\n'.format(k, headers[k]) for k in sorted(headers.keys())
+        )
+        ctx.start_time = DateUtil.nowSystem()
+        async_sender.send_packet(
+            PacketTypeEnum.TX_MSG, ctx,
+            ['HTTP-HEADERS', 'HTTP-HEADERS', text],
+        )
+
+    end_interceptor(ctx=ctx)

whatap/trace/mod/application/flask.py

@@ -0,0 +1,52 @@
+from whatap.trace.trace_handler import trace_handler
+from whatap.trace.trace_error import interceptor_error
+from whatap.trace.mod.application.wsgi import interceptor
+from whatap.trace.trace_context_manager import TraceContextManager
+
+def instrument(module):
+    def wrapper(fn):
+        @trace_handler(fn, True)
+        def trace(*args, **kwargs):
+            flask_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 = (flask_instance, environ, custom_start_response)
+            callback = interceptor(fn, *new_args, **kwargs)
+            return callback
+        
+        return trace
+    
+    module.Flask.wsgi_app = wrapper(module.Flask.wsgi_app)
+    
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            from werkzeug.exceptions import HTTPException
+            callback = fn(*args, **kwargs)
+            if callback is None:
+                e = args[1]
+                errors = [e.__class__.__name__]
+                status_code = getattr(e, 'code', 500)
+                #Flask 레이어의 예외 처리
+                if isinstance(e, HTTPException):
+                    errors.append(e.description)
+
+                #Flask 예외 객체가 아닌 경우의 예외처리
+                #에러 코드와 메세지가 함께 나타날 수 있음.
+                else:
+                    status_code = 500
+                    errors.append(str(e))
+                interceptor_error(status_code, errors)
+
+            return callback
+
+        return trace
+    if hasattr(module.Flask, '_find_error_handler'):
+        module.Flask._find_error_handler = wrapper(
+            module.Flask._find_error_handler)

whatap/trace/mod/application/frappe.py

@@ -0,0 +1,224 @@
+from whatap.trace.trace_handler import trace_handler
+from whatap.trace.trace_error import interceptor_error
+from whatap.trace.mod.application.wsgi import \
+    start_interceptor, isIgnore, \
+    end_interceptor
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.conf.configure import Configure as conf
+from whatap.util.keygen import KeyGen
+import whatap.util.bit_util as bit_util
+from whatap.util.hash_util import HashUtil as hash_util
+from whatap.util.date_util import DateUtil
+from whatap.net.packet_type_enum import PacketTypeEnum
+from whatap.util.hexa32 import Hexa32 as hexa32
+import whatap.net.async_sender as async_sender
+import logging as logging_module
+import sys
+from whatap.trace.trace_context import TraceContext
+
+
+logger = logging_module.getLogger(__name__)
+def toDjangoHeaderName(src):
+
+    return 'HTTP_' + src.upper().replace('-','_')
+class UseridUtil(object):
+    WHATAP_R = "WHATAP"
+
+    @staticmethod
+    def getUserId(args,  defValue):
+        try:
+
+            if conf.user_header_ticket:
+                ticket = UseridUtil.getHeader(args, conf.user_header_ticket)
+                if  ticket:
+                    return hash_util.hashFromString(ticket), ticket
+                return 0,""
+            cookie = UseridUtil.getHeader(args, "HTTP_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))
+
+    @staticmethod
+    def setUserId(request, response, cookieValue):
+        try:
+            if not conf.user_header_ticket:
+                if request.cookies:
+                    cookie = request.cookies.get(UseridUtil.WHATAP_R)
+                else:
+                    cookie = None
+                if not cookie:
+                    cookieDomain=conf.trace_user_cookie_domain if conf.trace_user_cookie_domain else None
+                    UseridUtil.setCookie( response, UseridUtil.WHATAP_R, cookieValue, bit_util.INT_MAX_VALUE, "/", cookieDomain )
+        except Exception:
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            logger.debug("A503", 10, str(exc_value))
+
+    @staticmethod
+    def setCookie(response, key, value, max_age, path, domain):
+        response.set_cookie(key, value, max_age=max_age, path=path, domain=domain)
+        
+    @staticmethod
+    def getRemoteAddr(args):
+        if conf.trace_http_client_ip_header_key:
+            header_val = UseridUtil.getHeader(args, conf.trace_http_client_ip_header_key)
+            if header_val:
+                return header_val.split(',')[0].strip()
+        x_forwarded_for = UseridUtil.getHeader(args, "x-forwarded-for")
+        if x_forwarded_for:
+            return x_forwarded_for.split(',')[0].strip()
+        return UseridUtil.getHeader(args, "REMOTE_ADDR")
+        #return UseridUtil.getHeader(args, "REMOTE_ADDR")
+
+    @staticmethod
+    def getHeader(args, key):
+
+        if args:
+            environ = args[0]
+            wsgiHeaderKey = 'HTTP_'+key.upper().replace('-','_')
+            return environ.get(key, environ.get(wsgiHeaderKey))
+        else:
+            return None
+
+
+def parseServiceName(environ):
+    return environ.get('PATH_INFO', '')
+
+
+def interceptor(rn_environ, *args, **kwargs):
+    if not isinstance(rn_environ, tuple):
+        rn_environ = (rn_environ, args[1])
+    fn, environ = rn_environ
+
+    ctx = TraceContext()
+    ctx.host = environ.get('HTTP_HOST', '').split(':')[0]
+    ctx.service_name = parseServiceName(environ)
+    ctx.remoteIp = UseridUtil.getRemoteAddr(args)
+    ctx.userAgentString = environ.get('HTTP_USER_AGENT', '')
+    ctx.referer = environ.get('HTTP_REFERER', '')
+    
+    if conf.trace_user_enabled:
+        if conf.trace_user_using_ip:
+            ctx.userid = UseridUtil.getRemoteAddr(args)
+        else:
+            ctx.userid, ctx._rawuserid = UseridUtil.getUserId(args, ctx.remoteIp)
+
+    mstt = environ.get('HTTP_{}'.format(
+        conf._trace_mtrace_caller_key.upper().replace('-', '_')), '')
+
+    if mstt:
+        ctx.setTransfer(mstt)
+        if conf.stat_mtrace_enabled:
+            val = environ.get('HTTP_{}'.format(
+                conf._trace_mtrace_info_key.upper().replace('-', '_')), '')
+            if val and len(val):
+                ctx.setTransferInfo(val)
+            pass
+
+        myid = environ.get('HTTP_{}'.format(
+            conf._trace_mtrace_callee_key.upper().replace('-', '_')), '')
+        if myid:
+            ctx.setTxid(myid)
+    caller_poid = environ.get('HTTP_{}'.format(
+        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
+            TraceContextManager.end(ctx.id)
+            return fn(*args, **kwargs)
+    except Exception as e:
+        pass
+
+    start_interceptor(ctx)
+
+    try:
+
+        callback = fn(*args, **kwargs)
+        ctx = TraceContextManager.getLocalContext()
+        if ctx:
+            query_string = environ.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 getattr(callback, 'status_code', None):
+                status_code = callback.status_code
+                errors = [callback.reason_phrase, callback.__class__.__name__]
+                interceptor_error(status_code, errors)
+
+            if conf.profile_http_header_enabled:
+                keys = []
+                for key, value in environ.items():
+                    if key.startswith('HTTP_'):
+                        keys.append(key)
+                keys.sort()
+
+                text = ''
+                for key in keys:
+                    text += '{}={}\n'.format(key.split('HTTP_')[1].lower(),
+                                             environ[key])
+
+                datas = ['HTTP-HEADERS', 'HTTP-HEADERS', text]
+                ctx.start_time = DateUtil.nowSystem()
+                async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+            return callback
+    finally:
+        ctx = TraceContextManager.getLocalContext()
+        if ctx:
+            end_interceptor(ctx=ctx)
+
+def instrument(module):
+    def wrapper(fn):
+        @trace_handler(fn, True)
+        def trace(*args, **kwargs):
+            environ = args[0]
+            callback = interceptor((fn, environ), *args, **kwargs)
+    
+            return callback
+        
+        return trace
+    if hasattr(module, "application"):
+        
+        module.application = wrapper(module.application)
+    
+
+    def run_after_request_hooks_wrapper(fn):
+        @trace_handler(fn, True)
+        def trace(*args, **kwargs):
+            request = args[0]
+            response = args[1]
+            ctx = TraceContextManager.getLocalContext()
+            if ctx and conf.trace_user_enabled:
+                if not conf.trace_user_using_ip:
+                    UseridUtil.setUserId(request, response,  ctx._rawuserid )
+            callback = fn(*args, **kwargs)
+            
+            return callback
+        
+        return trace
+
+
+    if hasattr(module, "run_after_request_hooks"):
+        
+        module.run_after_request_hooks = run_after_request_hooks_wrapper(module.run_after_request_hooks)
+    

whatap/trace/mod/application/graphql.py

@@ -0,0 +1,170 @@
+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
+try:
+    from importlib.metadata import version as _get_version
+except ImportError:
+    from pkg_resources import get_distribution
+    def _get_version(name):
+        return get_distribution(name).version
+from graphql.language.ast import OperationDefinitionNode
+
+
+def parseServiceName(graphql_doc):
+    # GraphQL-core 버전 확인
+    graphql_core_version = _get_version("graphql-core")
+
+    # GraphQL-core 3.x 이상 버전일 경우
+    if graphql_core_version.startswith("3") or graphql_core_version.startswith("4"):
+        try:
+            # OperationDefinitionNode 타입의 노드 필터링 (3.x 이상 버전 로직)
+            op_def = [
+                i for i in graphql_doc.definitions
+                if isinstance(i, OperationDefinitionNode)
+            ][0]
+        except (IndexError, KeyError):
+            return "GraphQL unknown operation"
+
+        # operation의 타입이 OperationType Enum인 경우
+        op = op_def.operation.value  # Enum 값을 문자열로 변환
+    else:
+        try:
+            # 이전 버전 로직 (OperationDefinition 사용)
+            op_def = [
+                i for i in graphql_doc.definitions
+                if type(i).__name__ == "OperationDefinition"
+            ][0]
+        except (IndexError, KeyError):
+            return "GraphQL unknown operation"
+
+        # operation의 타입이 문자열인 경우
+        op = op_def.operation  # 문자열 그대로 사용
+
+    name = op_def.name
+    fields = op_def.selection_set.selections if op_def.selection_set else []
+
+    return "/GraphQL %s %s" % (op.upper(), name.value if name else "+".join([f.name.value for f in fields]))
+
+
+def intercept_execute(fn, *args, **kwargs):
+    ctx = TraceContextManager.getLocalContext()
+    if not ctx:
+        ctx = TraceContext()
+        is_transaction_started = False
+    else:
+        is_transaction_started = not ctx.is_ignored
+    if not is_transaction_started:
+        if len(args) > 1 and hasattr(args[1],"definitions"):
+            name = parseServiceName(args[1])
+            if name:    
+                ctx.service_name =  name
+        start_interceptor(ctx)
+    start_time = DateUtil.nowSystem()
+    try:
+        callback = fn(*args, **kwargs)
+        return callback
+    except Exception as e:
+        interceptor_step_error(e)
+    finally:
+        if not is_transaction_started:
+            end_interceptor()
+        else:
+            text = "graphql.execute"
+            payloads = [text, '']
+            ctx.elapsed = DateUtil.nowSystem() - start_time
+            async_sender.send_packet(PacketTypeEnum.TX_METHOD, ctx, payloads)
+
+def parseDocumentName(op_def):
+    op = op_def.operation
+    name = op_def.name
+    fields = op_def.selection_set.selections
+    if not fields:
+        fields = []
+    return "GraphQL %s %s" % (op.upper(), name if name else "+".join([f.name.value for f in fields]))  
+
+
+def parseSelectionSet(gnode, tokens = [], indent=0):
+    nameFound = False
+    
+    if hasattr(gnode, "selection_set"):
+        if hasattr(gnode, "name") and hasattr(gnode, "selection_set"): 
+            if gnode.selection_set:
+                tokens.append("  "*indent+gnode.name.value+"{")
+                nameFound = True
+            else:
+                tokens.append("  "*indent+gnode.name.value)
+
+    if hasattr(gnode, "selection_set"):
+        if gnode.selection_set:
+            if gnode.selection_set.selections:
+                for sel in gnode.selection_set.selections:
+                    parseSelectionSet(sel, tokens, indent = indent+1)
+    if nameFound:
+        tokens.append("  "*indent+"}")
+
+def parseDocument(defi):
+    tokens = []
+    if hasattr(defi, "name"):
+        tokens.append(defi.name.value+"{")
+    
+    if hasattr(defi, "selection_set"):
+        if defi.selection_set:
+            if defi.selection_set.selections:
+                for sel in defi.selection_set.selections:
+                    if sel:
+                        parseSelectionSet(sel, tokens, 1)
+
+    if hasattr(defi, "name"):
+        tokens.append("}")
+    tokens.reverse()
+    return "\n".join(tokens)
+
+def intercept_execute_method( fn, *args, **kwargs):
+    ctx = TraceContextManager.getLocalContext()
+    start_time = DateUtil.nowSystem()
+    try:
+        callback = fn(*args, **kwargs)
+        return callback
+    except Exception as e:
+        if ctx:
+            interceptor_step_error(e)
+    finally:
+        if ctx and len(args) > 4 and not args[4] and args[3]:
+            operation_definition = args[3][0]
+            text = operation_definition.name.value
+            arg = parseDocument(operation_definition)
+            
+            payloads = [text, arg]
+            ctx.elapsed = DateUtil.nowSystem() - start_time
+            async_sender.send_packet(PacketTypeEnum.TX_METHOD, ctx, payloads)
+        
+def instrument_graphql(module):
+    def wrapper(fn):
+        @trace_handler(fn, start=True)
+        def trace(*args, **kwargs):
+            callback = intercept_execute(fn, *args, **kwargs)
+            return callback
+
+        return trace
+    if hasattr(module, 'execute'):
+        module.execute = wrapper(module.execute)
+
+    def wrapper( fn):
+        @trace_handler(fn, start=True)
+        def trace(*args, **kwargs):
+            callback = intercept_execute_method( fn, *args, **kwargs)
+            return callback
+        return trace
+
+    # if hasattr(module, 'execute_operation'):
+    #    module.execute_operation = wrapper(module.execute_operation)
+        
+    if hasattr(module, 'resolve_field'):
+       module.resolve_field = wrapper(module.resolve_field)

whatap/trace/mod/application/nameko.py

@@ -0,0 +1,39 @@
+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 intercept_worker(fn, *args, **kwargs):
+    ctx = TraceContext()
+    worker_ctx = args[1]
+    ctx.service_name = worker_ctx.call_id_stack
+    start_interceptor(ctx)
+
+    try:
+        callback = fn(*args, **kwargs)
+        return callback
+    except Exception as e:
+        interceptor_step_error(e)
+    finally:
+        end_interceptor()
+
+def instrument_nameko_spawn_worker(module):
+    def wrapper(fn):
+        @trace_handler(fn, start=True)
+        def trace(*args, **kwargs):
+            callback = intercept_worker(fn, *args, **kwargs)
+            return callback
+
+        return trace
+
+    if hasattr(module, 'ServiceContainer') and hasattr(module.ServiceContainer, '_run_worker'):
+        from eventlet.corolocal import local
+        TraceContextManager.local = local()
+        module.ServiceContainer._run_worker = wrapper(module.ServiceContainer._run_worker)
+