whatap-python 2.1.0__py3-none-any.whl

whatap/trace/mod/logging.py

@@ -0,0 +1,161 @@
+import sys
+from whatap import DateUtil, conf
+import whatap.net.async_sender as async_sender
+from whatap.pack import logSinkPack
+from whatap.trace.trace_context_manager import TraceContextManager
+import whatap.io as whatapio
+
+loguru_injection_processed = False
+def instrument_loguru(module):
+    global loguru_injection_processed
+
+    
+    if not conf.trace_loguru_enabled:
+        return
+
+    def wrapper(fn):
+        def trace(*args, **kwargs):
+            if not conf.trace_loguru_enabled:
+                return fn(*args, **kwargs)
+
+            if len(args) <=1:
+                return fn(*args, **kwargs)
+
+            ctx = TraceContextManager.getLocalContext()
+            if not ctx:
+                return fn(*args, **kwargs)
+
+            record = args[1]
+
+            if conf.trace_logging_mtid_enabled and ctx and hasattr(ctx, 'mtid') and ctx.mtid:
+                original_message = record["message"]
+                try:
+                    record["message"] = original_message + f" (@mtid: {ctx.mtid})"
+
+                    result = fn(*args, **kwargs)
+                    record["message"] = original_message
+
+                    return result
+                except Exception as e:
+                    record["message"] = original_message
+
+            category = "AppLog"
+            tags = {'@txid': str(ctx.id)} if ctx is not None else {}
+
+            filename = None
+            # record = args[1]
+            levelname = record["level"].name
+            msg = record["message"]
+            fields = {"filename": filename}
+
+            content = f"{levelname}  {msg}"
+
+            p = logSinkPack.getLogSinkPack(
+                t=DateUtil.now(),
+                category=f"{category}",
+                tags=tags,
+                fields=fields,
+                line=DateUtil.now(),
+                content=content
+            )
+
+            p.pcode = conf.PCODE
+            bout = whatapio.DataOutputX()
+            bout.writePack(p, None)
+            packbytes = bout.toByteArray()
+
+            async_sender.send_relaypack(packbytes)
+            return fn(*args, **kwargs)
+        return trace
+    if not loguru_injection_processed:
+        module.Handler.emit = wrapper(module.Handler.emit)
+        loguru_injection_processed = True
+
+logging_injection_processed = False
+def instrument_logging(module):
+    global logging_injection_processed
+
+    if not conf.trace_logging_enabled:
+        return
+
+    def wrapper(fn):
+        def trace(*args, **kwargs):
+            if not conf.trace_logging_enabled:
+                return fn(*args, **kwargs)
+
+            ctx = TraceContextManager.getLocalContext()
+            record = args[1]
+
+            if conf.trace_logging_mtid_enabled and ctx and hasattr(ctx, 'mtid') and ctx.mtid:
+                original_msg = record.msg
+                original_args = record.args
+                try:
+                    if isinstance(record.msg, str):
+                        if record.args:
+                            # 포맷 문자열이 있는 경우, 원본 포맷팅을 먼저 수행
+                            formatted_msg = record.msg % record.args
+                            record.msg = formatted_msg
+                            record.args = ()  # args를 비워줌
+                        record.msg = record.msg + f" (@mtid: {ctx.mtid})"
+
+                    result = fn(*args, **kwargs)
+
+                    record.msg = original_msg
+                    record.args = original_args
+
+                    return result
+                except Exception as e:
+                    record.msg = original_msg
+                    record.args = original_args
+
+            ##1.3.6 Backward Compatibility
+            setattr(record, "txid", None)
+
+            if not ctx:
+                return fn(*args, **kwargs)
+
+            instance = args[0]
+            category = "AppLog"
+
+            # logger_name = getattr(instance, "name", None)
+            # if logger_name and logger_name == "whatap":
+            #     category = "#AppLog"
+
+            filehandler = [handler for handler in instance.handlers if handler.__class__.__name__ == "FileHandler"]
+            filename = None
+            if filehandler and len(filehandler)>0:
+                filehandler = filehandler[0]
+                if hasattr(filehandler, "baseFilename"):
+                    filename = filehandler.baseFilename
+
+            levelname = getattr(record, "levelname", None)
+            msg = record.getMessage()
+
+            fields = {"filename": filename}
+
+            content = f"{levelname}  {msg}"
+
+            tags = {'@txid': ctx.id} if ctx is not None else {}
+
+            p = logSinkPack.getLogSinkPack(
+                t=DateUtil.now(),
+                category=f"{category}",
+                tags=tags,
+                fields=fields,
+                line=DateUtil.now(),
+                content=content
+            )
+
+            p.pcode = conf.PCODE
+            bout = whatapio.DataOutputX()
+            bout.writePack(p, None)
+            packbytes = bout.toByteArray()
+
+            async_sender.send_relaypack(packbytes)
+            return fn(*args, **kwargs)
+        return trace
+
+    if not logging_injection_processed:
+        module = sys.modules.get("logging")
+        module.Logger.callHandlers = wrapper(module.Logger.callHandlers)
+        logging_injection_processed = True

whatap/trace/mod/plugin.py

@@ -0,0 +1,84 @@
+import inspect
+from whatap.net.packet_type_enum import PacketTypeEnum
+import whatap.net.async_sender as async_sender
+from whatap.trace import get_dict
+from whatap.trace.trace_handler import trace_handler
+from whatap.util.date_util import DateUtil
+from whatap.trace.trace_context_manager import TraceContextManager
+
+from whatap import logging
+
+
+def instrument_plugin(module_dict):
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            module_name = fn.__module__
+            def_name = fn.__name__
+            class_name = args[0].__class__.__name__ if len(args) and hasattr(
+                args[0], def_name) else None
+            
+            if class_name:
+                text = '{}:{}.{}'.format(module_name, class_name, def_name)
+            else:
+                text = '{}:{}'.format(module_name, def_name)
+            
+            ctx = TraceContextManager.getLocalContext()
+            start_time = DateUtil.nowSystem()
+            ctx.start_time = start_time
+            try:
+                callback = fn(*args, **kwargs)
+                return callback
+            except Exception as e:
+                logging.debug(e, extra={'id': 'hook_method_patterns PARSING ERROR'})
+            finally:
+                datas = [text, '']
+                ctx.elapsed = DateUtil.nowSystem() - start_time
+                async_sender.send_packet(PacketTypeEnum.TX_METHOD, ctx, datas)
+        
+        return trace
+    
+    try:
+        for class_def in module_dict['class_defs']:
+            class_def_list = class_def.split('.')  # exception
+            
+            m_list = []
+            t_list = []
+            module = module_dict['module']
+            if len(class_def_list) == 2:
+                if class_def_list[0] == '*':
+                    for attr in dir(module):
+                        if not attr.startswith('__') \
+                                and not attr.endswith('__') \
+                                and inspect.isclass(getattr(module, attr)) \
+                                and not isinstance(getattr(module, attr), type(module)) \
+                                and module.__name__ == getattr(module, attr).__module__ :
+                            m_list.append(getattr(module, attr))
+                else:
+                    m_list = [getattr(module, class_def_list[0])]
+                    
+                target = class_def_list[1]
+            else:
+                m_list = [module]
+                target = class_def_list[0]
+                
+            for m in m_list:
+                if target == '*':
+                    for attr in dir(m):
+                        if not attr.startswith('__') \
+                                and not attr.endswith('__') \
+                                and hasattr(m, attr) \
+                                and inspect.isfunction(getattr(m, attr)):
+                            t_list.append(attr)
+                else:
+                    t_list.append(target)
+                
+                for t in t_list:
+                    if hasattr(m, t):
+                        try:
+                            setattr(m, t, wrapper(getattr(m, t)))
+                        except Exception as e:
+                            get_dict(m)[t] = wrapper(getattr(m, t))
+    except Exception as e:
+        logging.debug(e, extra={'id': 'hook_method_patterns PARSING ERROR'})
+        

whatap/trace/mod/standalone/multiple.py

@@ -0,0 +1,293 @@
+import os
+import sys
+import atexit
+import time
+import traceback
+
+import whatap.net.async_sender as async_sender
+
+from functools import wraps
+
+from whatap.conf.configure import Configure as conf
+from whatap.util.date_util import DateUtil
+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.trace.trace_handler import trace_handler
+from whatap import logging
+
+
+import threading
+
+from whatap.util.frame_util import get_current_frame
+
+def trace_handler(fn, start=False, preload=None):
+    def handler(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if preload:
+                preload(*args, **kwargs)
+
+            ctx = TraceContextManager.getLocalContext()
+            if not start and not ctx:
+                return fn(*args, **kwargs)
+            try:
+                callback = func(*args, **kwargs)
+            except Exception as e:
+                if ctx and ctx.error_step == e:
+                    ctx.error_step = None
+                    raise e
+                raise
+            else:
+                if ctx and ctx.error_step:
+                    e = ctx.error_step
+                    ctx.error_step = None
+                    raise e
+                return callback
+
+        return wrapper
+
+    return handler
+
+def load_transaction_patterns():
+    raw = conf.standalone_transaction_patterns
+    patterns = set(entry.strip() for entry in raw.split(",") if entry.strip())
+
+    return patterns
+
+
+def shutdown_agent():
+
+    start_time = time.time()
+
+    while not async_sender.q.empty():
+        if time.time() - start_time > 3.0:
+            break
+        time.sleep(0.1)
+
+    if async_sender.q.empty():
+        return
+    else:
+        remaining_items = async_sender.q.qsize()
+
+def end_interceptor(ctx):
+    if not ctx:
+        return
+
+    if conf.dev:
+        logging.debug(f'end   transaction id(seq): {ctx.id}', extra={'id': 'WA112'})
+        print(f'end   transaction id(seq): {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 start_interceptor(ctx):
+    if conf.dev:
+        logging.debug(f'start transaction id(seq): {ctx.id}', extra={'id': 'WA111'})
+        print(f'start transaction id(seq): {ctx.id}', dict(extra={'id': 'WA111'}))
+
+    start_time = DateUtil.nowSystem()
+    ctx.start_time = start_time
+
+    datas = [ctx.host, ctx.service_name, ctx.remoteIp, ctx.userAgentString,
+             ctx.referer, ctx.userid, ctx.isStaticContents, ctx.http_method]
+
+    async_sender.send_packet(PacketTypeEnum.TX_START, ctx, datas)
+
+def error_interceptor(error_msg,error_type,ctx):
+    if not ctx:
+        ctx = TraceContextManager.getLocalContext()
+    if not ctx:
+        return
+    if not ctx.error:
+        ctx.error = 1
+
+    error = ''
+    errors = []
+    errors.append(error_type)
+    errors.append(error_msg)
+
+    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)
+
+    async_sender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors)
+
+    if conf.profile_exception_stack:
+        desc = '\n'.join(errors)
+        datas = [' ', ' ', desc]
+        ctx.start_time = DateUtil.nowSystem()
+        async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+
+def instrument_standalone_multiple():
+    atexit.register(shutdown_agent)
+
+    patterns = load_transaction_patterns()
+    targets_to_patch = {tuple(entry.split(":", 1)) for entry in patterns}
+
+    tracked_methods = set()
+    tracked_funcs = set()
+    modules = set()
+
+
+    for entry in patterns:
+        mod, target = entry.split(":", 1)
+        if "." in target:
+            cls, mtd = target.split(".", 1)
+            tracked_methods.add((mod, cls, mtd))
+        else:
+            func = target
+            tracked_funcs.add((mod, func))
+
+        modules.add(mod)
+
+    def wrapper(fn, module_name, target_name):
+        @trace_handler(fn, start=True)
+        def trace(*args, **kwargs):
+            prev_ctx = TraceContextManager.getLocalContext()
+            ctx = TraceContext()
+            ctx.service_name = f"{module_name}:{target_name}"
+            start_interceptor(ctx)
+            try:
+                callback = fn(*args, **kwargs)
+                return callback
+            except Exception as e:
+                error_msg = str(e)
+                error_type = e.__class__.__name__
+                error_interceptor(error_msg,error_type,ctx)
+                raise e
+            finally:
+                end_interceptor(ctx)
+                TraceContextManager.setLocalContext(prev_ctx)
+
+        return trace
+
+
+
+    patching_queue = []
+    sys_trace_current_service_name = None
+
+    def trace_and_patch_profiler(frame, event, arg):
+        global sys_trace_current_service_name
+
+        if not targets_to_patch and not patching_queue:
+            pass
+
+        module_name = frame.f_globals.get("__name__")
+        if module_name not in (modules) or event not in ("call", "return","exception"):
+            return trace_and_patch_profiler
+
+        fn_name = frame.f_code.co_name
+        is_method = "self" in frame.f_locals
+
+        is_target = False
+        full_target_name = fn_name
+        target_tuple = None
+
+        if is_method:
+            cls_name = type(frame.f_locals["self"]).__name__
+            full_target_name = f"{cls_name}.{fn_name}"
+            if (module_name, cls_name, fn_name) in tracked_methods:
+                is_target = True
+                target_tuple = (module_name, full_target_name)
+        else:
+            if (module_name, fn_name) in tracked_funcs:
+                is_target = True
+                target_tuple = (module_name, full_target_name)
+
+        if target_tuple in targets_to_patch:
+            if event == "call":
+                if not is_target:
+                    return trace_and_patch_profiler
+
+                prev_ctx = TraceContextManager.getLocalContext()
+                if prev_ctx:
+                    patching_queue.append(prev_ctx)
+
+                ctx = TraceContext()
+                ctx.service_name = f"{module_name}:{full_target_name}"
+                sys_trace_current_service_name = ctx.service_name
+
+                TraceContextManager.setLocalContext(ctx)
+                start_interceptor(ctx)
+
+                try:
+                    module_obj = sys.modules[module_name]
+                    if is_method:
+                        cls_name, mtd_name = target_tuple[1].split('.', 1)
+                        cls_obj = getattr(module_obj, cls_name)
+                        fn = getattr(cls_obj, mtd_name)
+                        wrapped_fn = wrapper(fn, module_name, target_tuple[1])
+                        setattr(cls_obj, mtd_name, wrapped_fn)
+                    else:
+                        func_name = target_tuple[1]
+                        fn = getattr(module_obj, func_name)
+                        wrapped_fn = wrapper(fn, module_name, func_name)
+                        setattr(module_obj, func_name, wrapped_fn)
+
+                    targets_to_patch.remove(target_tuple)
+
+
+
+                except (AttributeError, KeyError) as e:
+                    if target_tuple in targets_to_patch:
+                        targets_to_patch.remove(target_tuple)
+
+        if event == "return":
+            ctx = TraceContextManager.getLocalContext()
+            if ctx and sys_trace_current_service_name == f"{module_name}:{full_target_name}":
+                end_interceptor(ctx)
+                if patching_queue:
+                    prev_ctx = patching_queue.pop()
+                    TraceContextManager.setLocalContext(prev_ctx)
+                    sys_trace_current_service_name = prev_ctx.service_name
+                else:
+                    if not(targets_to_patch):
+                        sys.settrace(None)
+
+        if event == "exception":
+            ctx = TraceContextManager.getLocalContext()
+            if ctx and sys_trace_current_service_name == f"{module_name}:{full_target_name}":
+                exc_type, exc_value , tb = arg
+                error_interceptor(exc_value,exc_type,ctx)
+                end_interceptor(ctx)
+                if patching_queue:
+                    prev_ctx = patching_queue.pop()
+                    TraceContextManager.setLocalContext(prev_ctx)
+                    sys_trace_current_service_name = prev_ctx.service_name
+                else:
+                    if not (targets_to_patch):
+                        sys.settrace(None)
+
+        return trace_and_patch_profiler
+
+    sys.settrace(trace_and_patch_profiler)

whatap/trace/mod/standalone/single.py

@@ -0,0 +1,135 @@
+import atexit
+import os
+import sys
+import traceback
+import time
+
+from whatap.conf.configure import Configure as conf
+from whatap.util.date_util import DateUtil
+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 import logging
+
+from whatap.util.frame_util import get_current_frame
+
+ctx = None
+
+
+def global_exception_handler(exc_type, exc_value, exc_traceback):
+
+    global ctx
+    traceback.print_exception(exc_type, exc_value, exc_traceback)
+
+    standalone_error(exc_value, ctx)
+
+sys.excepthook = global_exception_handler
+
+
+def standalone_error(e, ctx=None):
+
+    if not ctx:
+        ctx = TraceContextManager.getLocalContext()
+    if not ctx:
+        return
+
+    ctx.error_step = e
+    if not ctx.error:
+        ctx.error = 1
+
+    errors = []
+    errors.append(e.__class__.__name__)
+
+    error_message = str(e)
+    errors.append(error_message)
+
+    error_stack = ''
+    frame = get_current_frame(ctx)
+    if not frame:
+        return
+
+    for stack in traceback.extract_stack(frame):
+        if 'whatap' + os.sep + 'trace' in stack.filename or 'threading.py' in stack.filename:
+            continue
+        error_stack += f'{stack.name} ({stack.filename}:{stack.lineno})\n'
+
+    errors.append(error_stack)
+    async_sender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors)
+    if conf.profile_exception_stack:
+        desc = '\n'.join(errors)
+        datas = [' ', ' ', desc]
+        ctx.start_time = DateUtil.nowSystem()
+        async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+
+
+
+
+@atexit.register
+def standalone_end():
+    global ctx
+    ctx = ctx
+
+    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
+
+    shutdown_start_time = time.time()
+    while not async_sender.q.empty():
+        if time.time() - shutdown_start_time > 3.0:
+            break
+        time.sleep(0.1)
+
+
+
+def instrument_standalone_single():
+    global ctx
+
+    ctx = TraceContext()
+    ctx = 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
+
+    ctx.service_name = sys.argv[0]
+
+    datas = [ctx.host,
+             ctx.service_name,
+             ctx.remoteIp,
+             ctx.userAgentString,
+             ctx.referer,
+             ctx.userid,
+             ctx.isStaticContents,
+             ctx.http_method
+             ]
+
+
+    async_sender.send_packet(PacketTypeEnum.TX_START, ctx, datas)

whatap/trace/simple_trace_context.py

@@ -0,0 +1,18 @@
+import copy
+
+from whatap.trace.trace_context import TraceContext
+
+
+class SimpleTraceContext(TraceContext):
+    def __init__(self, ctx: TraceContext):
+        self.ctx = ctx
+
+    """
+    Replaced Python's built-in deepcopy function with a manual deep copy method in SimpleTraceContext.
+    This change prevents potential pickle errors when serializing the TraceContext object.
+    Each attribute is copied individually to ensure that complex objects within TraceContext are correctly handled.
+    """
+    def getDeepCopiedContext(self):
+        for key, value in self.ctx.__dict__.items():
+            setattr(self, key, value)
+        return self