whatap-python 2.1.0__py3-none-any.whl

whatap/llm/stats/token_usage_stat.py

@@ -0,0 +1,133 @@
+from collections import defaultdict
+
+from whatap.llm.stats.base_stat import BaseStat
+from whatap.util.hash_util import HashUtil
+
+_TOKEN_TYPES = [
+    'input_tokens', 'output_tokens', 'cached_tokens', 'reasoning_tokens',
+    'cache_creation_input_tokens', 'cache_read_input_tokens',
+]
+
+_TOKEN_COST_MAP = {
+    'input_tokens': 'input_cost',
+    'output_tokens': 'output_cost',
+    'cached_tokens': 'cached_cost',
+}
+
+
+class TokenUsageStat(BaseStat):
+    _category = "llm_token_usage"
+    _is_listed = True
+
+    def _empty_stats(self):
+        return {
+            'calls': defaultdict(int),
+            'tokens': defaultdict(lambda: defaultdict(int)),
+            'token_costs': defaultdict(lambda: defaultdict(float)),
+        }
+
+    def _get_keys(self, stats):
+        # call 은 집계됐지만 토큰이 전부 0 인 key (에러 응답, usage 미수신 스트리밍
+        # 등) 는 제외한다. 포함하면 _build_fields_listed 에서 한 row 도 추가되지
+        # 않아 평행 배열이 비어 있는 채로 pack 이 송출되고, 백엔드에서 빈 칸 row 로
+        # 나타난다.
+        tokens = stats['tokens']
+        return [k for k in stats['calls'].keys()
+                if any(v > 0 for v in tokens[k].values())]
+
+    def update_stats(self, input_tokens, output_tokens,
+                     model_name, host='', operation_type='default', url='',
+                     cached_tokens=0, reasoning_tokens=0,
+                     cache_creation_input_tokens=0, cache_read_input_tokens=0,
+                     input_cost=0.0, output_cost=0.0, cached_cost=0.0,
+                     prompt_version='v1'):
+        key = (model_name or 'unknown', host or '', operation_type or 'default',
+               url or '', prompt_version or 'v1')
+        with self._lock:
+            self._stats['calls'][key] += 1
+            t = self._stats['tokens'][key]
+            t['input_tokens'] += input_tokens
+            t['output_tokens'] += output_tokens
+            t['cached_tokens'] += cached_tokens
+            t['reasoning_tokens'] += reasoning_tokens
+            t['cache_creation_input_tokens'] += cache_creation_input_tokens
+            t['cache_read_input_tokens'] += cache_read_input_tokens
+            c = self._stats['token_costs'][key]
+            c['input_cost'] += input_cost
+            c['output_cost'] += output_cost
+            c['cached_cost'] += cached_cost
+
+    def update_from_pack(self, pack):
+        self.update_stats(
+            pack.input_tokens or 0,
+            pack.output_tokens or 0,
+            pack.model or 'unknown',
+            host=pack.provider or '',
+            operation_type=pack.operation_type or 'default',
+            url=pack.url or '',
+            cached_tokens=pack.cached_tokens or 0,
+            reasoning_tokens=pack.reasoning_tokens or 0,
+            cache_creation_input_tokens=pack.cache_creation_input_tokens or 0,
+            cache_read_input_tokens=pack.cache_read_input_tokens or 0,
+            input_cost=pack.input_cost or 0.0,
+            output_cost=pack.output_cost or 0.0,
+            cached_cost=pack.cached_cost or 0.0,
+            prompt_version=getattr(pack, 'prompt_version', 'v1') or 'v1',
+        )
+
+    def _build_fields_listed(self, pack, stats, keys, pid):
+        """리스트형 메트릭. 모든 key 의 (token_type) row 를 평행 배열로 평탄화.
+
+        Layout:
+          - 키 차원 (row 단위): pid / model / provider / operation_type / url / prompt_version
+          - 토큰 차원 (row 단위): tokens / tokens_count / tokens_cost / @id
+
+        key-level scalar 은 두지 않는다:
+          - call_count / error_count / stream_count → llm_perf_stat 으로 이전
+          - total_tokens / total_cost → tokens_count / tokens_cost list 합으로
+            백엔드에서 도출 (리스트 평행 배열에서 "첫 row 에만 값" 표현은 의미가
+            깨지고, 이미 list 필드로 derivable 이라 중복)
+        """
+        # 평행 배열 column 들
+        id_list = pack.fields.newList("@id")
+        pid_list = pack.fields.newList("pid")
+        model_list = pack.fields.newList("model")
+        provider_list = pack.fields.newList("provider")
+        op_type_list = pack.fields.newList("operation_type")
+        url_list = pack.fields.newList("url")
+        prompt_version_list = pack.fields.newList("prompt_version")
+
+        tokens_list = pack.fields.newList("tokens")
+        tokens_count_list = pack.fields.newList("tokens_count")
+        tokens_cost_list = pack.fields.newList("tokens_cost")
+
+        for key in keys:
+            try:
+                model, provider, op_type, url, prompt_version = key
+            except ValueError:
+                model, provider, op_type, url = key
+                prompt_version = 'v1'
+
+            t = stats['tokens'][key]
+            c = stats['token_costs'][key]
+
+            for token_type in _TOKEN_TYPES:
+                count = t.get(token_type, 0)
+                if count <= 0:
+                    continue
+
+                # 토큰 차원
+                id_list.addLong(HashUtil.hashFromString(
+                    "{}:{}:{}:{}:{}".format(model, provider, op_type, prompt_version, token_type)))
+                tokens_list.addString(token_type)
+                tokens_count_list.addLong(count)
+                cost_key = _TOKEN_COST_MAP.get(token_type)
+                tokens_cost_list.addFloat(round(c.get(cost_key, 0.0), 6) if cost_key else 0.0)
+
+                # 키 차원 (모든 row 에 반복)
+                pid_list.addLong(pid)
+                model_list.addString(model)
+                provider_list.addString(provider)
+                op_type_list.addString(op_type)
+                url_list.addString(url)
+                prompt_version_list.addString(prompt_version)

whatap/llm/stats/toxicity_eval_stat.py

@@ -0,0 +1,10 @@
+"""llm_eval_toxicity 카테고리 — Toxicity 평가 점수 히스토그램.
+
+11-bucket 분포 (value0~value10). 자세한 동작은 ``eval_stat.ScoreHistogramStat``
+docstring 참고.
+"""
+from whatap.llm.stats.eval_stat import ScoreHistogramStat
+
+
+class ToxicityEvalStat(ScoreHistogramStat):
+    _category = 'llm_eval_toxicity'

whatap/llm/stats/url_scan_eval_stat.py

@@ -0,0 +1,12 @@
+"""llm_eval_url_scan 카테고리 — URL Scan suspicious 점수 히스토그램.
+
+11-bucket 분포 (value0~value10). 자세한 동작은 ``eval_stat.ScoreHistogramStat``
+docstring 참고.
+
+값 의미: 0.0 = URL 없거나 모두 안전, 1.0 = 모든 URL 이 suspicious.
+"""
+from whatap.llm.stats.eval_stat import ScoreHistogramStat
+
+
+class URLScanEvalStat(ScoreHistogramStat):
+    _category = 'llm_eval_url_scan'

whatap/net/async_sender.py

@@ -0,0 +1,107 @@
+import copy
+import queue, time, threading
+from . import udp_session
+from whatap.conf.configure import Configure as conf
+from whatap.trace.simple_trace_context import SimpleTraceContext
+from whatap.net.packet_type_enum import PacketTypeEnum
+
+q = queue.Queue(conf.max_send_queue_size)
+
+from enum import Enum
+class SendType(Enum):
+    DATAS = 1
+    RELAY = 2
+    LLM_RELAY = 3
+    LLM_FLUSH = 4
+
+_LLM_IDLE_FLUSH_SEC = 0.1
+
+_STEP_TYPES = {
+    PacketTypeEnum.TX_DB_CONN, PacketTypeEnum.TX_DB_FETCH,
+    PacketTypeEnum.TX_SQL, PacketTypeEnum.TX_HTTPC,
+    PacketTypeEnum.TX_ERROR, PacketTypeEnum.TX_MSG,
+    PacketTypeEnum.TX_METHOD,
+}
+
+
+def send_packet( packet_type, ctx, datas=[]):
+
+    ctx = SimpleTraceContext(ctx)
+
+        # deep coopy TraceContext object before adding it to the queue, preventing potential data overwriting issues caused by concurrent modifications
+    copied_ctx = ctx.getDeepCopiedContext()
+    _initThread()
+    global q
+    if q.full():
+        return
+    q.put((SendType.DATAS, (packet_type, copied_ctx, datas)))
+
+def send_relaypack( packbytes):
+    _initThread()
+    global q
+    if q.full():
+        return
+    q.put((SendType.RELAY, packbytes))
+
+def send_llm_relaypack( packbytes):
+    """LLM 데이터 전용. LLM Go Agent 소켓으로만 전송."""
+    _initThread()
+    global q
+    if q.full():
+        return
+    q.put((SendType.LLM_RELAY, packbytes))
+
+def flush_llm_relaypack():
+    """LLM 버퍼 명시적 flush 요청. 큐를 거치므로 이전에 enqueue된 LLM_RELAY들이 모두 처리된 뒤 flush된다."""
+    _initThread()
+    global q
+    if q.full():
+        return
+    q.put((SendType.LLM_FLUSH, None))
+
+def startWhatapThread():
+    def __sendPackets():
+        global q
+        while True:
+            try:
+                packet_env = q.get(timeout=_LLM_IDLE_FLUSH_SEC)
+            except queue.Empty:
+                # idle 상태에서 LLM 버퍼에 남아있는 데이터 flush
+                udp_session.UdpSession.flush_llm_buffer()
+                continue
+            if not packet_env:
+                continue
+            sendType,params = packet_env
+            if sendType == SendType.DATAS:
+                packet_type, ctx, datas = params
+                udp_session.UdpSession.send_packet(packet_type, ctx, datas)
+            elif sendType == SendType.RELAY:
+                packbytes = params
+                udp_session.UdpSession.send_relaypack(packbytes)
+            elif sendType == SendType.LLM_RELAY:
+                packbytes = params
+                udp_session.UdpSession.send_llm_relaypack(packbytes)
+            elif sendType == SendType.LLM_FLUSH:
+                udp_session.UdpSession.flush_llm_buffer()
+    t = threading.Thread(target=__sendPackets)
+    t.setDaemon(True)
+    t.start()
+
+_lock = threading.Lock()
+_initialized = False
+
+def _initThread():
+    global _lock, _initialized
+    if _initialized:
+        return
+    try:
+        if _initialized:
+            return
+        _lock.acquire()
+        if _initialized:
+            return
+        _initialized=True
+        startWhatapThread()
+    finally:
+        _lock.release()
+

whatap/net/packet_enum.py

@@ -0,0 +1,44 @@
+class PacketEnum(object):
+    PACKET_BUFFER_SIZE = 48 * 1024
+    PACKET_SEND_BUFFER_SIZE = 64 * 1024
+    DATA_SIZE_LIMIT = 30*1024 +1
+
+    SERVER = "127.0.0.1"
+    PORT = 6600
+    PACKET_VERSION = 20106
+
+    # PACKET_HEADER
+    PACKET_HEADER_TYPE_POS = 0
+    PACKET_HEADER_TYPE_SIZE = 1
+
+    PACKET_HEADER_VERSION_POS = 1
+    PACKET_HEADER_VERSION_SIZE = 4
+
+    PACKET_HEADER_LEN_POS = 5
+    PACKET_HEADER_LEN_SIZE = 4
+
+    # PACKET_BODY
+    PACKET_BODY_ID_POS = 9
+    PACKET_BODY_ID_SIZE = 8
+
+    PACKET_BODY_START_TIME_POS = 17
+    PACKET_BODY_START_TIME_SIZE = 8
+
+    PACKET_BODY_ELAPSED_POS = 25
+    PACKET_BODY_ELAPSED_SIZE = 4
+
+    PACKET_BODY_CPU_POS = 29
+    PACKET_BODY_CPU_SIZE = 8
+
+    PACKET_BODY_MEMOERY_POS = 37
+    PACKET_BODY_MEMOERY_SIZE = 8
+
+    PACKET_BODY_THREAD_ID_POS = 45
+    PACKET_BODY_THREAD_ID_SIZE = 8
+
+    PACKET_BODY_TRACE_DATA_POS = 53
+
+    # PACKET_SIZE
+    PACKET_HEADER_SIZE = PACKET_HEADER_TYPE_SIZE + PACKET_HEADER_VERSION_SIZE + PACKET_HEADER_LEN_SIZE
+    PACKET_BODY_REQUIRED_SIZE = PACKET_BODY_ID_SIZE + PACKET_BODY_START_TIME_SIZE + PACKET_BODY_ELAPSED_SIZE \
+                + PACKET_BODY_CPU_SIZE + PACKET_BODY_MEMOERY_SIZE + PACKET_BODY_THREAD_ID_SIZE

whatap/net/packet_type_enum.py

@@ -0,0 +1,31 @@
+class PacketTypeEnum(object):
+    TX_BLANK = 0
+    TX_START = 1
+    TX_DB_CONN = 2
+    TX_DB_FETCH = 3
+    TX_SQL = 4
+    TX_SQL_START = 5
+    TX_SQL_END = 6
+
+    TX_HTTPC = 7
+    TX_HTTPC_START = 8
+    TX_HTTPC_END = 9
+
+    TX_ERROR = 10
+    TX_MSG = 11
+    TX_METHOD = 12
+
+    # secure msg
+    TX_SECURE_MSG = 13
+
+    TX_WEB_SOCKET = 16
+    TX_END = 255
+
+    TX_PARAM = 30
+    ACTIVE_STACK = 40
+    ACTIVE_STATS = 41
+    DBCONN_POOL = 42
+
+    EVENT = 50
+
+    RELAY_PACK = 244

whatap/net/param_def.py

@@ -0,0 +1,69 @@
+class ParamDef(object):
+	KEEPALIVE = 1
+	AGENT_BOOT_ENV = 2
+	CONFIGURE_UPDATE = 3
+	CONFIGURE_GET = 4
+	COMPO_VERSIONS = 5
+	THREAD_LIST = 7
+	THREAD_DETAIL = 8
+	GET_ACTIVE_STACK = 9
+	HEAP_HISTO = 10
+	LOADED_CLASS_LIST = 11
+	GET_ENV = 12
+	SYSTEM_GC = 13
+	SET_CONFIG = 14
+	OPEN_SOCKET_LIST = 15
+	LOADED_CLASS_DETAIL = 16
+	LOADED_CLASS_REDEFINE = 17
+	AGENT_JAR_LIST = 18
+	AGENT_JAR_SAVE = 19
+	AGENT_JAR_DELETE = 20
+	RESET_STRING_SENT_MARK = 21
+	AGENT_LOG_LIST = 22
+	AGENT_LOG_READ = 23
+	THREAD_CONTROL = 24
+	GET_ACTIVE_TRANSACTION_LIST = 25
+	GET_ACTIVE_TRANSACTION_DETAIL = 26
+	GET_TOPOLOGY = 27
+	INFRA_NET_STAT=28
+	INFRA_PS_EF=29
+	INFRA_DOCKER_LIST=30
+	INFRA_REMOTE_CMD=33
+	INFRA_PEER_LIST = 34
+	INFRA_AGENT_UPDATE = 36
+	AGENT_DUMP_LIST = 31
+	AGENT_DUMP_READ = 32
+	AGENT_STAT = 35
+	JVM_THREAD_DUMP = 37
+	JVM_HEAP_DUMP = 38
+	KUBENETES = 39
+	GET_ACTIVE_STATS = 40
+	GET_DBCONN_POOL = 41
+	MODULE_DEPENDENCY = 101
+	DBX_INFO = 201
+	DBX_SETTINGS = 202
+	DBX_USER_SCRIPT = 207
+	DBX_SCRIPT_LIST = 208
+	DBX_SCRIPT_SQL = 209
+	DBX_KILL_SESSION = 210
+	DBX_GET_ALERT = 211
+	DBX_SET_ALERT = 212
+	DBX_PLAN = 213
+	DBX_SESSION_LIST = 214
+	DBX_SET_CPUCORES = 215
+	DBX_SESSION_STAT = 203
+	DBX_SESSION_EVENT = 204
+	DBX_TOPSTAT = 205
+	DBX_TOPEVENT = 206
+	CONFIG_DBC = 301
+	METHOD_PERF_STAT = 302
+	BLOCKING_DETECT = 303
+	CW_INFO = 401
+	CW_EVENTS = 402
+	CW_CREDENTIAL = 403
+	CW_REGIONS = 404
+	CW_METRIC_NAMES = 405
+	CW_AWS_RESOURCE_IDS = 406
+	CW_STATISTICS = 407
+	CW_UNITS = 408
+	CW_METRICS = 409

whatap/net/stackhelper.py

@@ -0,0 +1,87 @@
+import shlex
+import faulthandler
+import tempfile
+import os
+class StackParser:
+
+    parsers = {}
+    @staticmethod
+    def onNewParser(parser):
+        StackParser.parsers[parser.getThreadId()] =parser
+
+    @staticmethod
+    def listAll():
+        for p in StackParser.parsers:
+            yield p
+    
+    @classmethod
+    def find(cls, thread_id):
+        if thread_id in cls.parsers:
+            p = cls.parsers.get(thread_id)
+            return p.iterateStacks()
+        else:
+            return iter([])
+
+    @staticmethod
+    def parse():
+        with tempfile.NamedTemporaryFile() as buf:
+            faulthandler.dump_traceback(buf)
+            if buf.tell() < 1:
+                return
+            buf.seek(0)
+            stackdump = buf.read().decode("utf-8")
+            stackParser = None
+            for stack in stackdump.split('\n'):
+                if not stack:
+                    stackParser.onComplete()
+                    stackParser = None
+                    continue
+                if not stackParser:
+                    stackParser = StackParser(stack)
+                else:
+                    stackParser.add(stack)
+
+    def __init__(self, threadBegin):
+        self.__stacks = []
+        tokens = shlex.split(threadBegin)
+        if tokens and len(tokens) > 2:
+            try:
+                if 'Thread' == tokens[0] and int(tokens[1],0) > 0:
+                    threadid = int(tokens[1],0)
+                    self.__threadid = threadid
+
+                    StackParser.onNewParser(self)
+                elif 'Current' == tokens[0] and 'thread' == tokens[1] and int(tokens[2],0):
+                    threadid = int(tokens[2],0)
+                    self.__threadid = threadid
+                
+                    StackParser.onNewParser(self)
+            except ValueError:
+                pass
+
+    def getThreadId(self):
+        return self.__threadid
+    
+    def add(self, line):
+        tokens = shlex.split(line)
+        if len(tokens) == 6:
+            _, module, _, lineno, _, method = tokens
+            self.__stacks.append((module.strip(','), lineno, method))
+
+    def iterateStacks(self):
+        return iter(self.__stacks)
+
+    def toString(self):
+        return """Thread: {}
+{}""".format(self.__threadid, "\n".join([ "{} {} {}".format(stack[0],stack[1],stack[2]) for stack in self.__stacks]))
+
+    def onComplete(self):
+        pass
+
+def getThreadStackFaultHandler( thread_id):
+    StackParser.parse()
+    for line, line_num, method_name in StackParser.find(thread_id):
+        if 'whatap' + os.sep + 'trace' in line or 'threading.py' in line:
+            continue
+        yield '{} ({}:{})\n'.format(method_name, line, line_num)
+