whatap-python 2.1.0__py3-none-any.whl

whatap/trace/mod/application/odoo.py

@@ -0,0 +1,63 @@
+import traceback
+from whatap import logging
+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):
+    root = module.http.root
+    AppClass = root.__class__
+    original_call = AppClass.__call__
+
+    def wrapper(fn):
+        @trace_handler(fn, True)
+        def trace(self, environ, start_response):
+            def custom_start_response(status, headers, exc_info=None):
+                ctx = TraceContextManager.getLocalContext()
+                try:
+                    ctx.status = int(status.split()[0])
+                except Exception as e:
+                    logging.warning('[ODOO] status parse failed: %s' % e, extra={'id': 'ODOO001'})
+                    ctx.status = 0
+                return start_response(status, headers, exc_info)
+            try:
+                callback = interceptor(fn, self, environ, custom_start_response)
+            except Exception as e:
+                interceptor_error(
+                    500 , #해당 status 값은 에러 처리용으로만 사용됩니다.
+                    [e.__class__.__name__, str(e)]
+                )
+                raise
+            return callback
+
+        return trace
+
+    AppClass.__call__ = wrapper(original_call)
+
+
+    """ 
+    Odoo 16+ HttpDispatcher.handle_error 패치
+    """
+    Dispatcher = getattr(module.http, 'HttpDispatcher', None)
+
+    if Dispatcher:
+        original_handle_error = Dispatcher.handle_error
+
+        def wrapper(fn):
+            @trace_handler(fn)
+            def trace(self,exception):
+                ctx = TraceContextManager.getLocalContext()
+                interceptor_error(
+                    500,  # 해당 status 값은 에러 처리용으로만 사용됩니다.
+                    [exception.__class__.__name__,
+                     str(exception)],
+                    ctx=ctx
+                )
+
+                callback = fn(self, exception)
+                return callback
+
+            return trace
+        Dispatcher.handle_error = wrapper(Dispatcher.handle_error)

whatap/trace/mod/application/starlette.py

@@ -0,0 +1,126 @@
+import whatap.net.async_sender as async_sender
+from whatap.trace.trace_context import TraceContext
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.net.packet_type_enum import PacketTypeEnum
+from whatap.util.date_util import DateUtil
+from whatap.util.userid_util import UseridUtil as userid_util
+from whatap.trace.trace_error import interceptor_step_error
+from whatap.trace.mod.application.wsgi import \
+start_interceptor,end_interceptor
+from whatap.conf.configure import Configure as conf
+from typing import Any
+
+
+
+def intercept_websocket(web_socket, data: str):
+    try:
+        ctx = TraceContext()
+
+        scope = web_socket.scope
+        headers = dict(scope.get("headers", []))  # headers는 리스트(tuple) 형태
+        query_string = scope.get("query_string", b'').decode()
+        client = scope.get("client", ("0.0.0.0", 0))
+
+        # 기본 ctx 설정
+        ctx.service_name = scope.get("path", "WebSocket")
+        if query_string:
+            ctx.service_name += f"?{query_string}"
+        ctx.http_method = "WEBSOCKET"
+        ctx.remoteIp = client[0]
+        ctx.port = client[1]
+
+        # User-Agent, Referer 추출 (바이트를 디코딩)
+        ctx.userAgentString = headers.get(b'user-agent', b'').decode()
+        ctx.referer = headers.get(b'referer', b'').decode()
+
+        # userid 관련
+        if conf.trace_user_enabled:
+            if conf.trace_user_using_ip:
+                ctx.userid = ctx.remoteIp
+            else:
+                ctx.userid, ctx._rawuserid = userid_util.getUserId([scope], ctx.remoteIp)
+
+        # 트랜잭션 전파 관련
+        mstt = headers.get(f"HTTP_{conf._trace_mtrace_caller_key}".encode(), b'').decode()
+        if mstt:
+            ctx.setTransfer(mstt)
+            if conf.stat_mtrace_enabled:
+                val = headers.get(f"HTTP_{conf._trace_mtrace_info_key}".encode(), b'').decode()
+                if val:
+                    ctx.setTransferInfo(val)
+            txid = headers.get(f"HTTP_{conf._trace_mtrace_callee_key}".encode(), b'').decode()
+            if txid:
+                ctx.setTxid(txid)
+
+        poid = headers.get(f"HTTP_{conf._trace_mtrace_caller_poid_key}".encode(), b'').decode()
+        if poid:
+            ctx.mcaller_poid = poid
+
+        start_interceptor(ctx)
+
+        start_time = DateUtil.nowSystem()
+        ctx.start_time = start_time
+        ctx.error = 0
+        ctx.elapsed = 0
+
+        datas = [ctx.remoteIp, ctx.port, ctx.elapsed, ctx.error]
+        async_sender.send_packet(PacketTypeEnum.TX_WEB_SOCKET, ctx, datas)
+
+    except Exception as e:
+        interceptor_step_error(e)
+    finally:
+        end_interceptor(ctx=ctx)
+
+
+def instrument_starlette_websocket(module):
+
+    if not conf.trace_websocket_enabled:
+        return
+
+    OriginalWebSocket = module.WebSocket
+    if getattr(OriginalWebSocket, "_whatap_patched", False):
+        return
+
+    #original_accept = OriginalWebSocket.accept
+    original_send_text = OriginalWebSocket.send_text
+    original_send_bytes = OriginalWebSocket.send_bytes
+    original_send_json = OriginalWebSocket.send_json
+
+
+    # # 연결 시점도 래핑은 하지만, APM 인터셉트는 하지 않음
+    # async def wrapped_accept(self, *args, **kwargs):
+    #     try:
+    #         pass
+    #     except Exception as e:
+    #         interceptor_step_error(e)
+    #     return await original_accept(self, *args, **kwargs)
+
+    async def wrapped_send_text(self, data: str):
+        try:
+            intercept_websocket(self, data)
+        except Exception as e:
+            interceptor_step_error(e)
+        return await original_send_text(self, data)
+
+    async def wrapped_send_bytes(self, data: bytes):
+        try:
+            intercept_websocket(self, None)
+        except Exception as e:
+            interceptor_step_error(e)
+        return await original_send_bytes(self, data)
+
+    async def wrapped_send_json(self, data: Any):
+        try:
+            intercept_websocket(self, None)
+        except Exception as e:
+            interceptor_step_error(e)
+        return await original_send_json(self, data)
+
+    #OriginalWebSocket.accept = wrapped_accept
+    OriginalWebSocket.send_text = wrapped_send_text
+    OriginalWebSocket.send_bytes = wrapped_send_bytes
+    OriginalWebSocket.send_json = wrapped_send_json
+    OriginalWebSocket._whatap_patched = True
+
+
+

whatap/trace/mod/application/tornado.py

@@ -0,0 +1,163 @@
+import inspect
+import whatap.net.async_sender as async_sender
+from whatap.net.packet_type_enum import PacketTypeEnum
+from whatap.util.userid_util import UseridUtil as userid_util
+from whatap.trace.trace_context import TraceContext
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.util.date_util import DateUtil
+from whatap.conf.configure import Configure as conf
+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, end_interceptor, isIgnore
+
+
+def parseServiceName(environ):
+    return environ.get('PATH_INFO', '')
+
+
+def instrument(module):
+    def wrapper(fn):
+        async def trace(*args, **kwargs):
+            request = args[0].request
+            environ = {
+                'HTTP_HOST': request.host,
+                'PATH_INFO': request.path,
+                'QUERY_STRING': request.query_arguments,
+                'REMOTE_ADDR': request.remote_ip,
+                'HTTP_USER_AGENT': request.headers.get('User-Agent', ''),
+                'HTTP_REFERER': request.headers.get('Referer', ''),
+                'REQUEST_METHOD': request.method
+            }
+
+            for header_name, value in request.headers.items():
+                key = 'HTTP_' + header_name.upper().replace('-', '_')
+                environ[key] = value
+
+            async def run():
+                await interceptor((fn, environ), *args, **kwargs)
+
+            from tornado.ioloop import IOLoop
+            IOLoop.current().add_callback(run)
+
+            return None
+
+        return trace
+
+    module.RequestHandler._execute = wrapper(module.RequestHandler._execute)
+
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            callback = fn(*args, **kwargs)
+
+            e = args[1]
+            status_code = args[0]._status_code
+            errors = [e.__class__.__name__, str(e)]
+            interceptor_error(status_code, errors)
+            return callback
+
+        return trace
+
+    module.RequestHandler._handle_request_exception = wrapper(
+        module.RequestHandler._handle_request_exception)
+
+
+async 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.http_method = environ.get('REQUEST_METHOD', '')
+    ctx.remoteIp = userid_util.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 = userid_util.getRemoteAddr(args)
+        else:
+            ctx.userid, ctx._rawuserid = userid_util.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)
+            callback = fn(*args, **kwargs)
+            if inspect.isawaitable(callback):
+                return await callback
+            return callback
+    except Exception:
+        pass
+
+    start_interceptor(ctx)
+
+    try:
+        callback = fn(*args, **kwargs)
+        if inspect.isawaitable(callback):
+            callback = await callback
+
+        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'
+
+        handler = args[0]
+        status_code = getattr(handler, '_status_code', 200)
+        if status_code >= 400:
+            errors = [
+                callback.__class__.__name__ if callback else 'Unknown',
+                getattr(callback, 'reason_phrase', '')
+            ]
+            interceptor_error(status_code, errors, ctx=ctx)
+
+        else:
+            ctx.status = status_code
+
+        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:
+        end_interceptor(ctx=ctx)

whatap/trace/mod/application/wsgi.py

@@ -0,0 +1,195 @@
+import sys
+import traceback
+import threading
+
+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_context import TraceContext
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.util.date_util import DateUtil
+from whatap.util.hash_util import HashUtil
+from whatap.util.userid_util import UseridUtil as userid_util
+from whatap import logging
+
+
+def isEventlet():
+    greenlet = sys.modules.get('greenlet')
+
+    if greenlet:
+        current = greenlet.getcurrent()
+        if current is not None and current.parent:
+            print('thread:', threading.get_ident(), 'greenlet:', id(current.parent))
+            traceback.print_stack()
+            return True
+    else:
+        return False
+
+
+from whatap.trace.trace_error import interceptor_error
+
+
+
+def start_interceptor(ctx):
+    if conf.dev:
+        logging.debug('start transaction id(seq): {}'.format(ctx.id),
+                      extra={'id': 'WA111'})
+        print('start transaction id(seq): {}'.format(ctx.id), dict(extra={'id': 'WA111'}))
+
+    start_time = DateUtil.nowSystem()
+    ctx.start_time = start_time
+
+    if ctx.service_name and not ctx.service_hash:
+        ctx.service_hash = HashUtil.hashFromString(ctx.service_name)
+
+    datas = [ctx.host,
+             ctx.service_name,
+             ctx.remoteIp,
+             ctx.userAgentString,
+             ctx.referer,
+             ctx.userid,
+             ctx.isStaticContents,
+             ctx.http_method
+             ]
+    # print("start_interceptor txid:", ctx.id)
+    async_sender.send_packet(PacketTypeEnum.TX_START, ctx, datas)
+
+    return ctx
+
+
+def end_interceptor(thread_id=None, ctx=None):
+    if not ctx:
+        ctx = TraceContextManager.getContext(
+            thread_id) if thread_id else TraceContextManager.getLocalContext()
+    if not ctx:
+        return
+
+    if conf.dev:
+        logging.debug('end   transaction id(seq): {}'.format(ctx.id),
+                      extra={'id': 'WA112'})
+        print('end   transaction id(seq): {}'.format(ctx.id),
+              dict(extra={'id': 'WA112'}))
+
+    start_time = DateUtil.nowSystem()
+    ctx.start_time = start_time
+
+    datas = [ctx.host, ctx.service_name, ctx.mtid, ctx.mdepth, ctx.mcaller_txid,
+             ctx.mcaller_pcode, ctx.mcaller_spec, str(ctx.mcaller_url_hash), ctx.mcaller_poid, ctx.status,
+             ctx.is_llm, ctx.mcaller_step_id]
+    ctx.elapsed = DateUtil.nowSystem() - start_time
+
+    async_sender.send_packet(PacketTypeEnum.TX_END, ctx, datas)
+
+    try:
+        from whatap.counter.tasks.llm_log_sink_task import send_llm_tx_status
+        send_llm_tx_status(ctx)
+        from whatap.counter.tasks.llm_stat_task import LlmStatTask
+        if LlmStatTask._instance:
+            LlmStatTask._instance.flush_last_error(ctx)
+    except Exception:
+        pass
+
+
+def parseServiceName(environ):
+    return environ.get('PATH_INFO', '')
+
+
+def isIgnore(service_name):
+    if conf.trace_ignore_url_prefix and service_name.startswith(conf.trace_ignore_url_prefix):
+        return True
+
+    if conf.trace_ignore_url_set and service_name in conf.trace_ignore_url_set:
+        return True
+
+    return False
+
+
+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.http_method = environ.get('REQUEST_METHOD', '')
+    ctx.remoteIp = userid_util.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 = userid_util.getRemoteAddr(args)
+        else:
+            ctx.userid, ctx._rawuserid = userid_util.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)
+        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
+
+            if (status_code >= 400):
+                errors = [callback.__class__.__name__, callback.reason_phrase]
+                interceptor_error(status_code, errors, ctx=ctx)
+
+        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:
+        end_interceptor(ctx=ctx)
+

whatap/trace/mod/database/cxoracle.py

@@ -0,0 +1,49 @@
+from whatap.trace import get_dict
+from whatap.trace.trace_handler import trace_handler
+from whatap.trace.mod.database.util import interceptor_db_con, interceptor_db_execute, interceptor_db_close
+
+db_info = {}
+
+def _preload_oracle_db_info(*args, **kwargs):
+    global db_info
+    db_info = {'type': 'oracle'}
+    db_info.update(kwargs)
+
+def instrument_oracle_client(module):
+
+    def wrapper(fn):
+        @trace_handler(fn, preload=_preload_oracle_db_info)
+        def trace(*args, **kwargs):
+            callback = interceptor_db_con(fn, db_info, *args, **kwargs)
+            return callback
+
+        return trace
+
+    if hasattr(module, "connect"):
+        module.connect = wrapper(module.connect)
+
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            callback = interceptor_db_close(fn, *args, **kwargs)
+            return callback
+
+        return trace
+
+    if hasattr(module, "Connection") and hasattr(module.Connection, "close"):
+        get_dict(module.Connection)['close'] = wrapper(
+            module.Connection.close)
+
+    # def wrapper(fn):
+    #     @trace_handler(fn)
+    #     def trace(*args, **kwargs):
+    #         callback = interceptor_db_execute(fn, db_info, *args, **kwargs)
+    #         return callback
+    #
+    #     return trace
+    #
+    # if hasattr(module, 'Cursor') and hasattr(module.Cursor, "execute"):
+    #     get_dict(module.Cursor)['execute'] = wrapper(module.Cursor.execute)
+
+
+