whatap-python 2.1.0__py3-none-any.whl

whatap/trace/mod/application/django_py3.py

@@ -0,0 +1,251 @@
+
+from whatap.conf.configure import Configure as conf
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.trace.trace_context import TraceContext
+from whatap.trace.trace_error import interceptor_error
+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
+import whatap.net.async_sender as async_sender
+from whatap.net.packet_type_enum import PacketTypeEnum
+from whatap import logging
+
+
+from functools import wraps
+import logging as logging_module
+import datetime, 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_async():
+    def handler(func):
+        from django.http import HttpResponse
+        async def wrapper(*args, **kwargs):
+            scope, headers = parseHeaders(args)
+    
+            if conf.throttle_enabled and scope and headers:
+                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 = 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 await func(*args, **kwargs)
+
+        return wrapper
+
+    return handler
+
+def trace_handler_async(fn, start=False):
+    def handler(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            ctx = TraceContextManager.getLocalContext()
+            if not start and not ctx:
+                return fn(*args, **kwargs)
+            
+            try:
+                callback = await func(*args, **kwargs)
+            except Exception as e:
+                ctx = TraceContextManager.getLocalContext()
+                if ctx and ctx.error_step ==e:
+                    ctx.error_step= None
+                    raise 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:
+                if ctx and ctx.error_step:
+                    e = ctx.error_step
+                    ctx.error_step = None
+                    raise e
+                return callback
+        
+        return wrapper
+    
+    return handler
+
+def instrument_handlers_async(module):
+    def get_response_wrapper(fn):
+        @trace_handler_async(fn, start=True)
+        async def trace(*args, **kwargs):
+            
+            print('starting wrapped:', args, kwargs)
+            # request = get_request_fromargs(args)
+            startedAt = datetime.datetime.Now()
+            callback = await fn(*args, **kwargs)
+
+            print('elapsed:', datetime.datetime.now() - startedAt )
+            return callback
+        print('wrapper called')
+        return trace
+
+    if hasattr(module, 'BaseHandler') and hasattr(module.BaseHandler, 'get_response_async'):
+        module.BaseHandler.get_response_async = get_response_wrapper(module.BaseHandler.get_response_async)
+    
+def parseHeaders(args):
+    headers = {}
+    if len(args) > SCOPE_ARGS_LENGTH:
+        scope = args[1]
+        if HEADER in scope:
+            for arg in scope[HEADER]:
+                if arg and len(arg) == 2 and arg[0] and arg[1]:
+                    headers[arg[0].decode('utf8').lower()] = arg[1].decode('utf8')
+
+        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 ""
+
+async def interceptor_async(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
+        callback = await fn(*args, **kwargs)
+        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 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 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)
+    

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

@@ -0,0 +1,31 @@
+"""FastAPI / Starlette ASGI 계측 패키지.
+
+외부 공개 심볼 — 변경 금지:
+  - instrument_applications  (trace_module_definition.py)
+  - instrument               (trace_module_definition.py)
+  - instrument_util          (trace_module_definition.py)
+  - interceptor_error_log    (whatap/__init__.py)
+
+모듈 구성:
+  scope            scope/headers 파싱 + ctx 주입 (parse_headers, client_ip,
+                   resolve_user_id, populate_ctx)
+  transaction      TX 라이프사이클 (is_ignored, begin, finish)
+  endpoint         route template · 쿠키 · SSE 래핑 (upgrade_service_name,
+                   write_whatap_cookie, wrap_streaming_response)
+  exception_log    interceptor_error_log
+  instrumentation  훅 엔트리 3 개 (instrument_applications / instrument /
+                   instrument_util)
+"""
+from whatap.trace.mod.application.fastapi.exception_log import interceptor_error_log
+from whatap.trace.mod.application.fastapi.instrumentation import (
+    instrument,
+    instrument_applications,
+    instrument_util,
+)
+
+__all__ = [
+    'instrument_applications',
+    'instrument',
+    'instrument_util',
+    'interceptor_error_log',
+]

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

@@ -0,0 +1,73 @@
+"""엔드포인트 도달 시에만 유효한 메타 / 응답 보강.
+
+TX 라이프사이클에는 관여하지 않는다 (transaction.py 전담).
+"""
+import logging as logging_module
+import sys
+
+from whatap.conf.configure import Configure as conf
+from whatap.trace.trace_error import interceptor_step_error
+from whatap.util import bit_util
+from whatap.util.userid_util import UseridUtil
+
+logger = logging_module.getLogger(__name__)
+
+
+def upgrade_service_name(ctx, dependant):
+    """raw path(/items/42) → route template(/items/{item_id})."""
+    if dependant is None:
+        return
+    path = getattr(dependant, 'path', None)
+    if path:
+        ctx.service_name = path
+
+
+def write_whatap_cookie(environ, response, raw_user_id):
+    """응답 객체에 WhaTap userid 쿠키 기록. 조건 미충족 시 no-op."""
+    if response is None or not raw_user_id:
+        return
+    if not conf.trace_user_enabled or conf.trace_user_using_ip:
+        return
+    if conf.user_header_ticket:
+        return
+
+    cookie = environ.get('cookie') if environ else None
+    if (cookie
+            and cookie.find(UseridUtil.WHATAP_R) >= 0
+            and cookie.find(raw_user_id) >= 0):
+        return
+
+    try:
+        response.set_cookie(
+            key=UseridUtil.WHATAP_R,
+            value=raw_user_id,
+            max_age=bit_util.INT_MAX_VALUE,
+            path='/',
+            domain=conf.trace_user_cookie_domain,
+        )
+    except Exception:
+        _, exc, _ = sys.exc_info()
+        logger.debug('A503', 10, str(exc))
+
+
+def wrap_streaming_response(callback):
+    """StreamingResponse body_iterator 에 step-error 포착 래퍼 장착."""
+    try:
+        from fastapi.responses import StreamingResponse
+    except ImportError:
+        return callback
+    if not isinstance(callback, StreamingResponse):
+        return callback
+
+    original = callback.body_iterator
+
+    async def _traced():
+        try:
+            async for chunk in original:
+                yield chunk
+        except Exception as exc:
+            interceptor_step_error(exc)
+            raise
+
+    callback.body_iterator = _traced()
+    return callback

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

@@ -0,0 +1,63 @@
+"""엔드포인트 실행 중 발생한 unhandled exception 을 LogSink 로 전송.
+
+외부(whatap/__init__.py)가 `interceptor_error_log` 이름으로 직접 import 하므로
+함수명 · 시그니처 변경 금지.
+"""
+import inspect
+import linecache
+import sys
+import traceback
+
+from whatap.conf.configure import Configure as conf
+import whatap.io as whatapio
+import whatap.net.async_sender as async_sender
+import whatap.pack.logSinkPack as logSinkPack
+from whatap.util.date_util import DateUtil
+
+
+def interceptor_error_log(trxid, e, fn, args, kwargs):
+    if conf.log_unhandled_exception == 'false':
+        return
+
+    error_class = ''
+    if e.args:
+        error_class = str(e.args[0])
+    elif hasattr(e, 'detail'):
+        error_class = getattr(e, 'detail')
+
+    _, _, tb = sys.exc_info()
+    last_filename = last_lineno = last_globals = None
+    for frame, lineno in traceback.walk_tb(tb):
+        last_filename = frame.f_code.co_filename
+        last_lineno = lineno
+        last_globals = frame.f_globals
+
+    fields = {
+        'errorClass': error_class,
+        'args': str(inspect.getcallargs(fn, *args, **kwargs)),
+    }
+    content = ''
+    if last_filename and last_lineno:
+        fields['filename'] = last_filename
+        fields['lineno'] = last_lineno
+        linecache.checkcache(last_filename)
+        for i, line in enumerate(linecache.getlines(last_filename, last_globals)):
+            if i == last_lineno - 1 and len(line.lstrip()) > 2:
+                indent = len(line) - len(line.lstrip())
+                content += ''.join(['-' * (indent - 1) + '>', line.lstrip()])
+            else:
+                content += line
+
+    pack = logSinkPack.getLogSinkPack(
+        t=DateUtil.now(),
+        category='UnhandledException',
+        tags={'@txid': trxid},
+        fields=fields,
+        line=DateUtil.now(),
+        content=content,
+    )
+    pack.pcode = conf.PCODE
+
+    buf = whatapio.DataOutputX()
+    buf.writePack(pack, None)
+    async_sender.send_relaypack(buf.toByteArray())

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

@@ -0,0 +1,204 @@
+"""FastAPI 훅 엔트리포인트 — 3 개 모듈 함수.
+
+  - instrument_applications : fastapi.applications.FastAPI.__call__
+      ASGI 진입점. scope 파싱 → ctx 주입 → begin → wrapped_send → finish.
+      미들웨어 early-return / 404 / 405 / CORS preflight 등 엔드포인트
+      미도달 응답도 이 지점에서 캡처된다.
+  - instrument              : fastapi.routing.run_endpoint_function
+      엔드포인트 도달 시 route template / setUserId 쿠키 / SSE body wrap /
+      unhandled exception 로깅. TX 라이프사이클에는 관여하지 않는다.
+  - instrument_util         : fastapi.dependencies.utils.solve_dependencies
+      엔드포인트에서 쓰기 위한 request / response 를 dependant 에
+      `__whatap__` dict 로 부착.
+"""
+from copy import copy
+
+from whatap.trace.mod.application.fastapi import endpoint, scope, transaction
+from whatap.trace.mod.application.fastapi.exception_log import interceptor_error_log
+from whatap.trace.trace_context import TraceContext, TraceContextManager
+from whatap.trace.trace_error import interceptor_step_error
+from whatap.trace.trace_handler import async_trace_handler, trace_handler
+
+_WHATAP_DICT = '__whatap__'
+_DEPENDANT = 'dependant'
+_REQUEST = 'request'
+_RESPONSE = 'response'
+_REMOTE_ADDR = 'remoteAddr'
+
+
+# ── FastAPI.__call__ : TX 생명주기 전담 ────────────────────────
+
+def instrument_applications(module):
+    def wrapper(fn):
+        async def trace(instance, asgi_scope, receive, send):
+            if asgi_scope.get('type') != 'http':
+                await fn(instance, asgi_scope, receive, send)
+                return
+
+            headers = scope.parse_headers(asgi_scope)
+            ctx = TraceContext()
+            scope.populate_ctx(ctx, asgi_scope, headers)
+
+            if transaction.is_ignored(ctx.service_name):
+                ctx.is_ignored = True
+                try:
+                    await fn(instance, asgi_scope, receive, send)
+                finally:
+                    TraceContextManager.end(ctx.id)
+                return
+
+            transaction.begin(ctx)
+
+            status_holder = [0]
+            original_send = send
+
+            async def wrapped_send(message):
+                if message and message.get('type') == 'http.response.start':
+                    try:
+                        status_holder[0] = int(message.get('status') or 0)
+                    except (TypeError, ValueError):
+                        pass
+                await original_send(message)
+
+            try:
+                await fn(instance, asgi_scope, receive, wrapped_send)
+            except Exception as exc:
+                # 하위(endpoint wrapper)에서 이미 step_error 를 발사했으면
+                # ctx.error == 1. TX_ERROR 중복 방지를 위해 여기서는 스킵.
+                if not ctx.error:
+                    interceptor_step_error(exc)
+                raise
+            finally:
+                try:
+                    transaction.finish(ctx, asgi_scope, headers, status_holder[0])
+                finally:
+                    TraceContextManager.end(ctx.id)
+
+        return trace
+
+    module.FastAPI.__call__ = wrapper(module.FastAPI.__call__)
+
+
+# ── run_endpoint_function : endpoint 메타 보강만 ──────────────
+
+def instrument(module):
+    def wrapper(fn):
+        @trace_handler(fn, True)
+        def trace(*args, **kwargs):
+            dependant = kwargs[_DEPENDANT] = copy(kwargs[_DEPENDANT])
+            if kwargs.get('is_coroutine'):
+                dependant.call = _wrap_async_endpoint(dependant.call, dependant)
+            else:
+                dependant.call = _wrap_sync_endpoint(dependant.call, dependant)
+            return fn(*args, **kwargs)
+
+        return trace
+
+    if hasattr(module, 'run_endpoint_function'):
+        module.run_endpoint_function = wrapper(module.run_endpoint_function)
+
+
+def _wrap_sync_endpoint(fn, dependant):
+    @trace_handler(fn, True)
+    def trace(*args, **kwargs):
+        if not hasattr(dependant, _WHATAP_DICT):
+            return fn(*args, **kwargs)
+        whatap_dict = _pop_whatap_dict(dependant)
+        ctx = TraceContextManager.getLocalContext()
+        try:
+            _pre_endpoint(ctx, dependant, whatap_dict)
+            callback = fn(*args, **kwargs)
+            return _post_endpoint(ctx, whatap_dict, callback)
+        except Exception as exc:
+            interceptor_step_error(exc)
+            raise
+
+    return trace
+
+
+def _wrap_async_endpoint(fn, dependant):
+    @async_trace_handler(fn, True)
+    async def trace(*args, **kwargs):
+        if not hasattr(dependant, _WHATAP_DICT):
+            return await fn(*args, **kwargs)
+        whatap_dict = _pop_whatap_dict(dependant)
+        ctx = TraceContextManager.getLocalContext()
+        try:
+            _pre_endpoint(ctx, dependant, whatap_dict)
+            callback = await fn(*args, **kwargs)
+            return _post_endpoint(ctx, whatap_dict, callback)
+        except Exception as exc:
+            interceptor_step_error(exc)
+            if ctx is not None:
+                interceptor_error_log(ctx.id, exc, fn, args, kwargs)
+            raise
+
+    return trace
+
+
+def _pop_whatap_dict(dependant):
+    whatap_dict = getattr(dependant, _WHATAP_DICT)
+    try:
+        delattr(dependant, _WHATAP_DICT)
+    except Exception:
+        pass
+    return whatap_dict
+
+
+def _pre_endpoint(ctx, dependant, whatap_dict):
+    if ctx is None:
+        return
+    endpoint.upgrade_service_name(ctx, dependant)
+    if not ctx.remoteIp:
+        fb = whatap_dict.get(_REMOTE_ADDR)
+        if fb:
+            ctx.remoteIp = fb
+
+
+def _post_endpoint(ctx, whatap_dict, callback):
+    if ctx is None:
+        return callback
+    environ = whatap_dict.get('headers')
+    response = whatap_dict.get(_RESPONSE)
+    endpoint.write_whatap_cookie(
+        environ, response, getattr(ctx, '_rawuserid', ''),
+    )
+    return endpoint.wrap_streaming_response(callback)
+
+
+# ── solve_dependencies : whatap_dict 세팅 ─────────────────────
+
+def instrument_util(module):
+    def wrapper(fn):
+        async def trace(*args, **kwargs):
+            whatap_dict = None
+            if _DEPENDANT in kwargs:
+                whatap_dict = _attach_whatap_dict(kwargs)
+            ret = await fn(*args, **kwargs)
+            if whatap_dict is not None and hasattr(ret, '__len__') and len(ret) >= 4:
+                whatap_dict[_RESPONSE] = ret[3]
+            return ret
+
+        return trace
+
+    if hasattr(module, 'solve_dependencies'):
+        module.solve_dependencies = wrapper(module.solve_dependencies)
+
+
+def _attach_whatap_dict(kwargs):
+    dependant = kwargs[_DEPENDANT]
+    whatap_dict = {}
+    setattr(dependant, _WHATAP_DICT, whatap_dict)
+    request = kwargs.get(_REQUEST)
+    if request is not None:
+        if request.client is not None:
+            remote_addr = request.client.host
+        else:
+            remote_addr = request.headers.get('x-forwarded-for')
+        whatap_dict.update({
+            _REMOTE_ADDR: remote_addr,
+            'headers': copy(request.headers),
+            'cookies': copy(request.cookies),
+            'query_params': copy(request.query_params),
+        })
+    return whatap_dict