whatap-python 2.1.0__py3-none-any.whl

whatap/trace/trace_context.py

@@ -0,0 +1,212 @@
+import threading
+import time
+
+from whatap.conf.configure import Configure as conf
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.util.date_util import DateUtil
+from whatap.util.hexa32 import Hexa32
+from whatap.util.hash_util import HashUtil
+
+from whatap.util.linked_map import LinkedMap
+try:
+    from resource import getrusage, RUSAGE_SELF
+    HAS_RESOURCE = True
+except ImportError:
+    # resource module is not available on Windows
+    HAS_RESOURCE = False
+import os
+
+
+class TraceContext(object):
+    transfer_id = None
+    transfer_info = None
+
+    def __init__(self):
+        self.host = ''
+        self.elapsed = 0
+
+        self.isStaticContents = 'false'
+
+        self.id = TraceContextManager.getId()
+        self.thread = threading.current_thread()
+        self.thread_id = self.thread.ident
+        TraceContextManager.start(self)
+
+        self.pid = os.getpid()
+
+        self.start_time = 0
+        self.start_cpu = 0
+        self.start_malloc = 0
+
+        self.status = 0
+        self.asgi_response = None
+        self.service_hash = 0
+        self.service_name = ''
+        self.remoteIp = ''
+        self.error = 0
+        self.error_step = ''
+        self.http_method = ''
+        self.http_query = ''
+        self.http_content_type = ''
+
+        self.sql_count = 0
+        self.sql_time = 0
+        self.sql_insert = 0
+        self.sql_update = 0
+        self.sql_delete = 0
+        self.sql_select = 0
+        self.sql_others = 0
+
+        self.executed_sqlhash = 0
+        self.active_sqlhash = 0
+        self.active_dbc = 0
+        self.active_crud = 0
+
+        self.httpc_checked = False
+        self.httpc_count = 0
+        self.httpc_time = 0
+        self.httpc_url = ''
+
+        self.active_httpc_hash = 0
+        self.active_httpc_start_time = 0
+        self.httpc_host = ''
+        self.httpc_port = 0
+
+        self.mtid = 0
+        self.mdepth = 0
+        self.mcallee = 0
+
+        self.mcaller_txid = 0
+        self.mcaller_pcode = 0
+        self.mcaller_spec = ''
+        self.mcaller_url = ''
+        self.mcaller_poid = ''
+        self.transfer_poid = None
+
+        self.userid = ''
+        self._rawuserid = ''
+        self.userAgent = 0
+        self.userAgentString = ''
+        self.referer = ''
+        self.login = ''
+        self.userTransaction = 0
+        self.debug_sql_call = False
+        self.lastSqlStep = None
+        self.profileActive = 0
+
+        self.jdbc_updated = False
+        self.jdbc_update_record = 0
+        self.jdbc_identity = 0
+        self.jdbc_commit = 0
+        self.resultSql = LinkedMap()
+
+        self.rs_count = 0
+        self.rs_time = 0
+        self.db_opening = False
+        self.socket_connecting = False
+
+        self.mcaller_url_hash = 0
+        self.mcaller_step_id = 0
+
+        self.step_id = 0
+
+        self.lctx = {}
+        self.is_ignored = False
+        self.driver = ''
+        self.is_llm = 0
+        self._llm_httpc_pending = False
+        self._llm_httpc_url = ''
+        self._llm_operation_type = ''
+        self._llm_model = ''
+        self._llm_provider = ''
+
+    def getElapsedTime(self, time=None):
+        if not time:
+            time = DateUtil.now()
+        return time - self.start_time
+
+    def getCpuTime(self):
+        return int(time.time())
+
+    def getMemory(self):
+        # https://docs.python.org/3/library/resource.html?highlight=resource#resource-usage
+        if HAS_RESOURCE:
+            return int(getrusage(RUSAGE_SELF)[3] + getrusage(RUSAGE_SELF)[4])
+        else:
+            # Windows fallback: use psutil if available, otherwise return 0
+            try:
+                import psutil
+                process = psutil.Process(os.getpid())
+                mem_info = process.memory_info()
+                return int(mem_info.rss / 1024)  # Convert bytes to KB
+            except ImportError:
+                return 0
+
+    def resetStartTime(self):
+        self.start_time = 0
+
+    def transfer(self):
+        if self.transfer_id:
+            return self.transfer_id
+
+        sb = []
+        sb.append(Hexa32.toString32(self.mtid))
+        sb.append(str(self.mdepth + 1))
+        sb.append(Hexa32.toString32(self.id))
+        sb.append(Hexa32.toString32(self.step_id) if self.step_id else '0')
+        transfer_id = ','.join(sb)
+        return transfer_id
+
+    def transferInfo(self):
+        if self.transfer_info:
+            return self.transfer_info
+
+        sb = []
+        sb.append(str(conf.mtrace_spec))
+        sb.append(str(self.service_hash))
+
+        transfer_info = ','.join(sb)
+        return transfer_info
+
+    def setTransfer(self, headerString):
+        x = headerString.find(',')
+        if x > 0:
+            self.mtid = Hexa32.toLong32(headerString[0:x])
+            y = headerString.find(',', x + 1)
+            if y > 0:
+                self.mdepth = int(headerString[x + 1:y])
+                z = headerString.find(',', y + 1)
+
+                if z < 0:
+                    self.mcaller_txid = Hexa32.toLong32(headerString[y + 1:])
+                else:
+                    self.mcaller_txid = Hexa32.toLong32(headerString[y + 1: z])
+                    w = headerString.find(',', z + 1)
+                    if w < 0:
+                        step_id_str = headerString[z + 1:]
+                    else:
+                        step_id_str = headerString[z + 1: w]
+                    if step_id_str and step_id_str != '0':
+                        self.mcaller_step_id = Hexa32.toLong32(step_id_str)
+
+    def setTransferInfo(self, headerString):
+        x = headerString.index(',')
+        s1 = headerString[0: x]
+        self.mcaller_spec = s1
+        self.mcaller_url_hash = headerString[x + 1:]
+
+    def setTxid(self, myid):
+        old_id = self.id
+        new_id = Hexa32.toLong32(myid)
+        self.id = new_id
+        TraceContextManager.entry.remove(old_id)
+        TraceContextManager.entry.put(new_id, self)
+
+    def transferPOID(self):
+        if not self.transfer_poid:
+            self.transfer_poid = ",".join(
+                (Hexa32.toString32(conf.PCODE),
+                 Hexa32.toString32(HashUtil.hashFromString(conf.OKIND) if isinstance(conf.OKIND, str) else conf.OKIND),
+                 Hexa32.toString32(int(conf.OID))))
+
+        return self.transfer_poid

whatap/trace/trace_context_manager.py

@@ -0,0 +1,244 @@
+import os, sys
+import random
+import threading
+import time
+import uuid
+import random
+from collections import defaultdict
+from ctypes import c_int64
+from urllib.parse import urlparse
+from whatap import logging
+from whatap.conf.configure import Configure as conf
+from whatap.io.data_inputx import DataInputX
+from whatap.io.data_outputx import DataOutputX
+from whatap.util.linked_map import LinkedMap
+from whatap.util.hash_util import HashUtil
+from whatap.util.frame_util import set_greenlet_info
+
+import whatap.util.date_util as date_util
+if sys.version_info >= (3, 7):
+    import contextvars
+else:
+    contextvars = None
+
+class TraceContextManager(object):
+    entry = LinkedMap()
+    local = threading.local()
+    if contextvars:
+        ## python3.7+ support contextvars
+        ## contextvars support compatibility with threading.local()
+        whatap_coroutine_context = contextvars.ContextVar("whatap_coroutine_context", default=None)
+    node = uuid.getnode()
+    clock_seq = random.randrange(1 << 14)
+    dbpool = LinkedMap()
+
+    @classmethod
+    def keys(cls):
+        return cls.entry.keys()
+
+    @classmethod
+    def size(cls):
+        return cls.entry.size()
+
+    @classmethod
+    def getActiveCount(cls):
+        act = [0 for _ in range(3)]
+        try:
+            en = cls.entry.values()
+            while en.hasMoreElements():
+                ctx = en.nextElement()
+                elapsed = ctx.getElapsedTime()
+                if elapsed < conf.trace_active_transaction_yellow_time:
+                    act[0] += 1
+                elif elapsed < conf.trace_active_transaction_red_time:
+                    act[1] += 1
+                else:
+                    act[2] += 1
+
+        except Exception as e:
+            logging.debug(e, extra={'id': 'WA310'}, exc_info=True)
+
+        return act
+
+    _host_hash_cache = {}
+
+    @classmethod
+    def _get_host_hash(cls, url):
+        cached = cls._host_hash_cache.get(url)
+        if cached is not None:
+            return cached
+        try:
+            url_str = str(url)
+            if '://' not in url_str:
+                url_str = 'http://' + url_str
+            host = urlparse(url_str).hostname
+            if not host:
+                return 0
+            h = HashUtil.hashFromString(host)
+            if len(cls._host_hash_cache) < 1000:
+                cls._host_hash_cache[url] = h
+            return h
+        except Exception:
+            return 0
+
+    @classmethod
+    def getActiveStats(cls):
+        act = [0 for _ in range(5)]
+        httpc_detail = defaultdict(lambda: {'actx': 0, 'acts': [0, 0, 0]})
+        now = date_util.DateUtil.nowSystem()
+        try:
+            en = cls.entry.values()
+            while en.hasMoreElements():
+                ctx = en.nextElement()
+                if ctx.active_sqlhash:
+                    act[1] += 1 # sql
+                elif ctx.active_httpc_hash:
+                    act[2] += 1 # httpc
+                    host_hash = cls._get_host_hash(ctx.active_httpc_hash)
+                    if host_hash:
+                        stats = httpc_detail[host_hash]
+                        stats['actx'] += 1
+                        start_time = getattr(ctx, 'active_httpc_start_time', 0)
+                        if start_time > 0:
+                            elapsed_sec = int(now - start_time) // 1000
+                            if elapsed_sec <= 2:
+                                stats['acts'][0] += 1
+                            elif elapsed_sec <= 7:
+                                stats['acts'][1] += 1
+                            else:
+                                stats['acts'][2] += 1
+                elif ctx.db_opening:
+                    act[3] += 1 # dbc
+                elif ctx.socket_connecting:
+                    act[4] += 1  # socket
+                else:
+                    act[0] += 1 # method
+        except Exception as e:
+            logging.debug(e, extra={'id': 'WA311'}, exc_info=True)
+        return act, httpc_detail
+
+    @classmethod
+    def getContextEnumeration(cls):
+        return cls.entry.values()
+
+    @classmethod
+    def getContext(cls, key):
+        return cls.entry.get(key)
+
+    @classmethod
+    def getLocalContext(cls):
+        ##python3.7+ support contextvars
+        ##if contextvars is imported, use contextvars first
+        if contextvars:
+            return cls.whatap_coroutine_context.get()
+
+        if not bool(cls.local.__dict__):
+            cls.local.context = None
+        return cls.local.context
+
+    @classmethod
+    def setLocalContext(cls, o):
+        o.thread = threading.current_thread()
+        o.thread_id = o.thread.ident
+
+        # greenlet 환경이면 greenlet 정보 저장
+        set_greenlet_info(o)
+
+        if contextvars:
+            cls.whatap_coroutine_context.set(o)
+        cls.local.context = o
+
+    @classmethod
+    def getId(cls):
+        uuid1 = uuid.uuid1(TraceContextManager.node, TraceContextManager.clock_seq)
+        key = (uuid1.int >> 64 & 0xffffffffffffffff) ^ (uuid1.int << 64 & 0xffffffffffffffff)
+        return c_int64(key).value
+
+    @classmethod
+    def start(cls, o):
+        key = o.id
+        if contextvars:
+            cls.whatap_coroutine_context.set(o)
+        cls.local.context = o
+        cls.entry.put(key, o)
+
+        return key
+
+    @classmethod
+    def parseThreadId(cls, key):
+        o = cls.entry.get(key)
+        if o:
+            return o.thread_id, o.pid
+        else:
+            return None, None
+
+    @classmethod
+    def end(cls, key):
+        cls.local.context = None
+        cls.entry.remove(key)
+
+    @classmethod
+    def getTxProfile(cls, n):
+        ctx = cls.getLocalContext()
+        if not ctx:
+            return None
+        return ctx.profile.getLastSteps(n)
+
+    @classmethod
+    def getCurrentThreadId(cls):
+        greenlet = sys.modules.get('greenlet')
+
+        if greenlet:
+            current = greenlet.getcurrent()
+            if current is not None and current.parent:
+                return id(current.parent)
+        return threading.get_ident()
+
+    @classmethod
+    def getDBConnPool(cls):
+        d = dict()
+        keyvalueEnumer = cls.dbpool.entries()
+        while keyvalueEnumer.hasMoreElements():
+            en = keyvalueEnumer.nextElement()
+            d[en.getKey()] = en.getValue()
+        return d
+
+    @classmethod
+    def addDBPoolIdle(cls, url, isCheckIn = False):
+        if not cls.dbpool.containsKey(url):
+            cls.dbpool.put(url,[0, 0])
+
+        newstat = cls.dbpool.get(url)
+        if isCheckIn:
+            newstat[0] -= 1
+            if newstat[0] < 0:
+                newstat[0] = 0
+        newstat[1] += 1
+
+        cls.dbpool.put(url, newstat)
+        return
+
+    @classmethod
+    def removeDBPoolIdle(cls, url):
+        if not cls.dbpool.containsKey(url):
+            cls.dbpool.put(url,[0, 0])
+            return
+        newstat = cls.dbpool.get(url)
+        if newstat:
+            newstat[1] -= 1
+            if newstat[1] < 0:
+                newstat[1] = 0
+            cls.dbpool.put(url, newstat)
+
+    @classmethod
+    def addDBPoolActive(cls, url):
+        if not cls.dbpool.containsKey(url):
+            cls.dbpool.put(url,[0, 0])
+        newstat = cls.dbpool.get(url)
+        if newstat:
+            newstat[0] += 1
+            newstat[1] -= 1
+            if newstat[1] < 0:
+                newstat[1] = 0
+            cls.dbpool.put(url, newstat)
+        return

whatap/trace/trace_error.py

@@ -0,0 +1,84 @@
+import os
+import traceback
+
+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_manager import TraceContextManager
+from whatap.util.date_util import DateUtil
+from whatap.util.frame_util import get_current_frame
+
+
+def sendDebugProfile(ctx, msg):
+    if ctx:
+        ctx.elapsed = 0
+        datas = [' ', ' ', 'DEBUG: ' + msg]
+        async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+
+
+def interceptor_error(status_code, errors, ctx=None):
+    if not ctx:
+        ctx = TraceContextManager.getLocalContext()
+    if not ctx:
+        return
+    ctx.status = status_code
+    if status_code >= 400 and not ctx.error:
+        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)
+
+        async_sender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors)
+
+
+def interceptor_step_error(e, ctx=None):
+    from whatap.trace.mod.database.util import extract_db_error_message
+    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 = extract_db_error_message(e)
+    errors.append(error_message)
+
+    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)
+    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)

whatap/trace/trace_handler.py

@@ -0,0 +1,89 @@
+from functools import wraps
+from whatap.trace.trace_context_manager import TraceContextManager
+
+
+def _in_eval_worker():
+    """평가 워커 안에서 호출되었고 + judge tracking 옵션이 켜져있는지.
+
+    옵션 ``llm_eval_track_judge_calls`` (기본 False) 로 토글:
+      - False (기본): judge 호출은 intercept 우회 (short-circuit) → 메트릭/logsink 에 안 잡힘
+      - True       : judge 호출도 intercept 가 정상 동작 → llm_step_status + 메트릭에 잡힘
+
+    재귀 방지는 ``LlmEvaluatorTask.enqueue`` 의 동일 가드로 차단됨.
+    Conf 값이 string 'true'/'false' 일 수도 있어 (Configure.setProperty 의 reload 버그)
+    안전하게 string interpret.
+    """
+    try:
+        from whatap.conf.configure import Configure as conf
+        val = getattr(conf, 'llm_eval_track_judge_calls', False)
+        if isinstance(val, str):
+            enabled = val.strip().lower() in ('true', 'yes', '1', 'on')
+        else:
+            enabled = bool(val)
+        if not enabled:
+            return False
+        from whatap.counter.tasks.llm_evaluator_task import _is_in_evaluator_worker
+        return _is_in_evaluator_worker()
+    except Exception:
+        return False
+
+
+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 and not _in_eval_worker():
+                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 async_trace_handler(fn, start=False, preload=None):
+    def handler(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            if preload:
+                preload(*args, **kwargs)
+
+            ctx = TraceContextManager.getLocalContext()
+
+            if not start and not ctx and not _in_eval_worker():
+                return await fn(*args, **kwargs)
+
+            try:
+                callback = await 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