whatap-python 2.1.0__py3-none-any.whl

whatap/counter/tasks/llm_log_sink_task.py

@@ -0,0 +1,309 @@
+import queue
+import threading
+
+from whatap import DateUtil
+from whatap import logging
+from whatap.pack import logSinkPack
+from whatap.conf.configure import Configure as conf
+from whatap.trace.trace_context_manager import TraceContextManager
+
+import whatap.io as whatapio
+import whatap.net.async_sender as async_sender
+
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+from whatap.llm.log_sink_packs.llm_step_status import LlmStepStatus
+from whatap.llm.log_sink_packs.llm_system_message import LlmSystemMessage
+from whatap.llm.log_sink_packs.llm_input_message import LlmInputMessage
+from whatap.llm.log_sink_packs.llm_output_message import LlmOutputMessage
+from whatap.llm.log_sink_packs.llm_tool_calls import LlmToolCalls
+from whatap.llm.log_sink_packs.llm_tool_results import LlmToolResults
+from whatap.llm.log_sink_packs.llm_tx_status import LlmTxStatus
+
+_MAX_CONTENT_BYTES = 20000
+
+
+class LlmLogSinkTask(object):
+    """LLM logsink pack 송출 파이프라인.
+
+    LLM 호출 결과 pack 을 받아 즉시 송출. 평가 (LLM-judge 등) 는 별도 파이프라인
+    (``LlmEvaluatorTask``) 에서 비동기로 처리되며, 평가 결과는 ``LlmStepEvalStatus``
+    pack (``llm_log_type=llm_step_eval_status``) 으로 송출된다 — 원본 LlmStepStatus 와
+    동일한 fields/tags + 평가 점수 5 필드. (txid, step_id) 결합 키로 백엔드 사후 결합.
+
+    이 단순한 모델 덕분에 hold/timeout/callback 등의 복잡도가 모두 제거됨.
+    """
+
+    _instance = None
+    _lock = threading.Lock()
+
+    def __init__(self):
+        self._q = queue.Queue(4096)
+        self._started = False
+
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    def dispatch(self, pack):
+        """LLM 호출 결과 pack 을 즉시 송출 + 평가 큐 트리거.
+
+        평가 워커 안에서 호출된 judge LLM call 인 경우 (intercept 가 fire 한 케이스):
+          - operation_type='whatap_evaluation' / prompt_version='v1' 고정
+          - parent (user) step 의 (txid, step_id, index) 그대로 propagate
+            → dashboard 에서 같은 transaction 으로 묶여 보임
+          - eval enqueue 는 재귀 가드가 자동 차단
+        """
+        if not isinstance(pack, LlmStepStatus):
+            return
+
+        ctx = getattr(pack, '_trace_ctx', None) or TraceContextManager.getLocalContext()
+        pack.set_context(ctx)
+
+        if not pack.operation_type and ctx:
+            pack.operation_type = getattr(ctx, '_llm_operation_type', '') or 'unknown'
+
+        try:
+            pack.calculate_cost()
+        except Exception as e:
+            logging.warning('[LLM] calculate_cost failed: model=%s, input_tokens=%s, output_tokens=%s, cached_tokens=%s, error=%s'
+                            % (pack.model, pack.input_tokens, pack.output_tokens, pack.cached_tokens, e),
+                            extra={'id': 'LLM024'})
+
+        # ── judge LLM call (eval 워커 안에서 발생) — 고정 라벨 + parent step ids ──
+        try:
+            from whatap.counter.tasks.llm_evaluator_task import (
+                _is_in_evaluator_worker, _get_eval_worker_state,
+            )
+            if _is_in_evaluator_worker():
+                state = _get_eval_worker_state() or {}
+                pack.operation_type = 'whatap_evaluation'
+                pack.prompt_version = 'v1'
+                if state.get('parent_txid'):
+                    pack.txid = state['parent_txid']
+                if state.get('parent_step_id'):
+                    pack.step_id = state['parent_step_id']
+                if state.get('parent_index') is not None:
+                    pack.index = state['parent_index']
+        except Exception:
+            pass
+
+        # tx_summary 누적
+        self._accumulate_tx_summary(ctx, pack)
+
+        if ctx and not pack.success and pack.error_type:
+            ctx._llm_last_error_type = pack.error_type
+            ctx._llm_last_error_model = pack.model or 'unknown'
+            ctx._llm_last_error_provider = pack.provider or ''
+            ctx._llm_last_error_op_type = pack.operation_type or 'unknown'
+            ctx._llm_last_error_url = pack.url or ''
+            ctx._llm_last_error_prompt_version = (
+                getattr(pack, 'prompt_version', 'v1') or 'v1')
+
+        # pack 즉시 송출 — eval 결과 기다리지 않음
+        self._enqueue_for_send(pack)
+
+        # 평가 큐 트리거 — worker 가 pack 을 복제해 LlmStepEvalStatus 로 만들어 점수 채워 송출
+        # judge 호출 인 경우 enqueue_evaluation 의 재귀 가드가 차단
+        try:
+            from whatap.counter.tasks.llm_evaluator_task import enqueue_evaluation
+            enqueue_evaluation(pack)
+        except Exception as e:
+            logging.warning('[LLM] eval enqueue failed: %s' % e, extra={'id': 'LLM034'})
+
+    def _enqueue_for_send(self, pack):
+        """완성된 pack 을 송출 큐에 적재. queue full 이면 drop + LLM025."""
+        self._ensure_started()
+        if self._q.full():
+            logging.warning('[LLM] send queue full, pack dropped: model=%s' % pack.model,
+                            extra={'id': 'LLM025'})
+            return
+        self._q.put(pack)
+
+    def send_tx_status(self, ctx):
+        if not ctx:
+            return
+        if not getattr(conf, 'llm_enabled', False):
+            return
+        tx = getattr(ctx, '_llm_tx_status', None)
+        if not tx or tx.call_count == 0:
+            return
+
+        try:
+            self._send_log_sink(tx)
+            # 트랜잭션 경계에서 LLM 버퍼에 남아있는 데이터 flush (큐를 거쳐 순서 보장)
+            async_sender.flush_llm_relaypack()
+        except Exception as e:
+            logging.warning('[LLM] send_llm_tx_status failed: %s' % e, extra={'id': 'LLM022'})
+
+    # ── internal ──
+
+    def _ensure_started(self):
+        if self._started:
+            return
+        with self._lock:
+            if self._started:
+                return
+            self._started = True
+            t = threading.Thread(target=self._run, daemon=True)
+            t.start()
+
+    def _run(self):
+        while True:
+            pack = self._q.get()
+            if not pack:
+                continue
+            try:
+                self._process_pack(pack)
+            except Exception as e:
+                logging.warning('[LLM] process failed: %s' % e, extra={'id': 'LLM003'})
+
+    def _process_pack(self, pack):
+        # llm_step_status
+        self._send_log_sink(pack)
+
+        # system_message
+        for text in getattr(pack, 'system_texts', None) or []:
+            self._send_log_sink(LlmSystemMessage.from_pack(pack, system_text=text))
+
+        # input_message
+        prompt_text = getattr(pack, 'prompt_text', '') or ''
+        self._send_log_sink(LlmInputMessage.from_pack(pack, prompt_text=prompt_text))
+
+        # output_message
+        completion_text = getattr(pack, 'completion_text', '') or ''
+        reasoning_text = getattr(pack, 'reasoning_text', '') or ''
+        self._send_log_sink(LlmOutputMessage.from_pack(pack,
+            completion_text=completion_text, reasoning_text=reasoning_text))
+
+        # tool
+        tool_calls_text = getattr(pack, 'tool_calls_text', '') or ''
+        if tool_calls_text:
+            self._send_log_sink(LlmToolCalls.from_pack(pack, tool_calls_text=tool_calls_text))
+
+        # tool_result
+        tool_results_text = getattr(pack, 'tool_results_text', '') or ''
+        if tool_results_text:
+            self._send_log_sink(LlmToolResults.from_pack(pack, tool_results_text=tool_results_text))
+
+    def _accumulate_tx_summary(self, ctx, pack):
+        if not ctx:
+            return
+        tx = getattr(ctx, '_llm_tx_status', None)
+        if tx is None:
+            tx = LlmTxStatus()
+            tx.txid = str(ctx.id)
+            ctx._llm_tx_status = tx
+        tx.accumulate(pack)
+
+    def _send_log_sink(self, data):
+        tags = data.tags()
+        fields = data.fields()
+        content = data.content()
+        if content:
+            self._send_chunked(tags, fields, content, data.index)
+        else:
+            self._send_pack(tags, fields, '', data.index)
+
+    def _send_pack(self, tags, fields, content, index):
+        try:
+            tags = {k: v for k, v in tags.items() if v is not None}
+            fields = {k: v for k, v in fields.items() if v is not None}
+            fields['index'] = index
+            if content:
+                encoded = content.encode('utf-8', errors='replace')
+                if len(encoded) > _MAX_CONTENT_BYTES:
+                    content = encoded[:_MAX_CONTENT_BYTES].decode('utf-8', errors='replace')
+            p = logSinkPack.getLogSinkPack(
+                t=DateUtil.now(),
+                category=LlmLogSinkPack.CATEGORY,
+                tags=tags,
+                fields={},
+                line=DateUtil.now(),
+                content=content
+            )
+            for k, v in fields.items():
+                if isinstance(v, (int, float)):
+                    p.fields.putAuto(k, v)
+                else:
+                    p.fields.putString(k, str(v))
+
+            p.pcode = conf.PCODE
+            bout = whatapio.DataOutputX()
+            bout.writePack(p, None)
+            packbytes = bout.toByteArray()
+            async_sender.send_llm_relaypack(packbytes)
+        except Exception as e:
+            logging.warning('[LLM] send_pack failed: %s' % e, extra={'id': 'LLM001'})
+
+    def _send_chunked(self, tags, fields, content, index):
+        try:
+            if not content:
+                self._send_pack(tags, fields, '', index)
+                return
+
+            tags = {k: v for k, v in tags.items() if v is not None}
+            fields = {k: v for k, v in fields.items() if v is not None}
+
+            content_bytes = content.encode('utf-8', errors='replace')
+            total_bytes = len(content_bytes)
+
+            if total_bytes <= _MAX_CONTENT_BYTES:
+                chunk_fields = dict(fields)
+                chunk_fields["chunk_index"] = 0
+                chunk_fields["chunk_total"] = 1
+                self._send_pack(tags, chunk_fields, content, index)
+                return
+
+            raw_chunks = []
+            i = 0
+            while i < total_bytes:
+                end = min(i + _MAX_CONTENT_BYTES, total_bytes)
+                if end < total_bytes:
+                    while end > i and (content_bytes[end] & 0xC0) == 0x80:
+                        end -= 1
+                raw_chunks.append(content_bytes[i:end].decode('utf-8', errors='replace'))
+                i = end
+
+            chunk_total = len(raw_chunks)
+            for idx, chunk in enumerate(raw_chunks):
+                chunk_fields = dict(fields)
+                chunk_fields["chunk_index"] = idx
+                chunk_fields["chunk_total"] = chunk_total
+                self._send_pack(tags, chunk_fields, chunk, index)
+        except Exception as e:
+            logging.warning('[LLM] send_chunked failed: %s' % e, extra={'id': 'LLM002'})
+
+
+# ── module-level API ──
+
+def dispatch_llm_pack(pack):
+    LlmLogSinkTask.get_instance().dispatch(pack)
+
+
+def send_llm_tx_status(ctx):
+    LlmLogSinkTask.get_instance().send_tx_status(ctx)
+
+
+def send_llm_pack(metadata):
+    pack = LlmStepStatus()
+    for key, val in metadata.items():
+        if hasattr(pack, key):
+            setattr(pack, key, val)
+    dispatch_llm_pack(pack)
+
+
+def dispatch_llm_evaluation_pack(pack):
+    """LlmStepEvalStatus pack 을 LogSink 인프라로 송출.
+
+    LlmEvaluatorTask._run_one 이 원본 LlmStepStatus 를 복제해 만든 LlmStepEvalStatus 를
+    이 함수로 송출. (txid, step_id) 결합 키로 백엔드에서 LlmStepStatus 와 사후 결합.
+    """
+    try:
+        LlmLogSinkTask.get_instance()._send_log_sink(pack)
+    except Exception as e:
+        logging.warning('[LLM] dispatch_llm_evaluation_pack failed: %s' % e,
+                        extra={'id': 'LLM037'})

whatap/counter/tasks/llm_stat_task.py

@@ -0,0 +1,78 @@
+import time
+import logging
+from threading import Thread
+
+from whatap.llm.stats import LLM_STAT_CLASSES
+
+
+class LlmStatTask(Thread):
+    _instance = None
+
+    def __init__(self):
+        super(LlmStatTask, self).__init__()
+        self.stats = list()
+        self._stat_map = {}
+        self.last_executed = {}
+        LlmStatTask._instance = self
+
+    def _register_stats(self):
+        for cls in LLM_STAT_CLASSES:
+            stat = cls()
+            self.stats.append(stat)
+            self._stat_map[stat.name()] = stat
+            self.last_executed[stat.name()] = 0
+
+    def run(self):
+        self._register_stats()
+
+        while True:
+            current_time = time.time()
+            time.sleep(1)
+            for stat in self.stats:
+                last_executed_time = self.last_executed[stat.name()]
+                interval = stat.interval()
+
+                if current_time - last_executed_time >= interval:
+                    try:
+                        self.last_executed[stat.name()] = current_time
+                        stat.process()
+                    except Exception as e:
+                        logging.debug(e, extra={'id': 'WA182'}, exc_info=True)
+
+    def notify(self, pack):
+        from whatap.conf.configure import Configure as conf
+        if not getattr(conf, 'llm_enabled', False):
+            return
+        for stat in self.stats:
+            try:
+                stat.update_from_pack(pack)
+            except Exception as e:
+                logging.debug(e, extra={'id': 'WA183'}, exc_info=True)
+
+        if pack.success:
+            from whatap.llm.stats.meter import Meter
+            Meter.increment()
+
+    def flush_last_error(self, ctx):
+        last_error_type = getattr(ctx, '_llm_last_error_type', None)
+        if not last_error_type:
+            return
+        from whatap.conf.configure import Configure as conf
+        if not getattr(conf, 'llm_enabled', False):
+            return
+        stat = self._stat_map.get('ErrorStat')
+        if stat:
+            stat.update_last_error(
+                getattr(ctx, '_llm_last_error_model', 'unknown'),
+                getattr(ctx, '_llm_last_error_provider', ''),
+                getattr(ctx, '_llm_last_error_op_type', 'unknown'),
+                url=getattr(ctx, '_llm_last_error_url', ''),
+                error_type=last_error_type,
+                prompt_version=getattr(ctx, '_llm_last_error_prompt_version', 'v1'),
+            )
+
+    @classmethod
+    def get_stat(cls, name):
+        if cls._instance is None:
+            return None
+        return cls._instance._stat_map.get(name)

whatap/counter/tasks/openfiledescriptor.py

@@ -0,0 +1,67 @@
+from whatap.counter.tasks.base_task import BaseTask
+from whatap.pack import tagCountPack
+from whatap import DateUtil
+import os
+
+try:
+    import resource
+    HAS_RESOURCE = True
+except ImportError:
+    HAS_RESOURCE = False
+
+currentpid = os.getpid()
+
+if HAS_RESOURCE:
+    soft_limit, _= resource.getrlimit(resource.RLIMIT_NOFILE)
+else:
+    soft_limit = None
+
+
+class OpenFileDescriptorTask(BaseTask):
+
+    def interval(self):
+        from whatap.conf.configure import Configure as conf
+        return conf.open_file_descriptor_interval
+
+    def process(self):
+        from whatap.conf.configure import Configure as conf
+        if not conf.open_file_descriptor_enabled:
+            return
+
+        currentnofile = self.currentNofile()
+        if soft_limit:
+            current_nofile_pct = float(currentnofile) / float(soft_limit) * float(100)
+        else:
+            current_nofile_pct = "N/A"
+        category = "app_filedescriptor"
+        tags = dict(pid=currentpid)
+        fields = dict(max_nofile = soft_limit,
+                      currnet_nofile=currentnofile,
+                      current_nofile_pct=current_nofile_pct )
+
+        p = tagCountPack.getTagCountPack(
+            t=DateUtil.now(),
+            category=f"{category}",
+            tags=tags,
+            fields=fields
+        )
+
+        self.send_pack(p)
+
+    def currentNofile(self):
+        if not HAS_RESOURCE:
+            try:
+                import psutil
+                process = psutil.Process(currentpid)
+                return len(process.open_files())
+            except ImportError:
+                return "N/A"
+            except Exception:
+                return "N/A"
+
+        fd_directory = f'/proc/{currentpid}/fd'
+        try:
+            fd_count = len(os.listdir(fd_directory))
+            return fd_count
+        except FileNotFoundError:
+            return "N/A"

whatap/io/__init__.py

@@ -0,0 +1 @@
+from whatap.io.data_outputx import DataOutputX

whatap/io/data_inputx.py

@@ -0,0 +1,161 @@
+import io
+import struct
+from whatap.pack.pack_enum import PackEnum
+
+from whatap.value.value_enum import ValueEnum
+
+
+class DataInputX(object):
+    def __init__(self, v):
+        self.buffer = io.BytesIO(v)
+
+    @staticmethod
+    def toInt(buf, pos):
+        ch1 = buf[pos] & 0xff
+        ch2 = buf[pos + 1] & 0xff
+        ch3 = buf[pos + 2] & 0xff
+        ch4 = buf[pos + 3] & 0xff
+        return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0))
+
+    def readPack(self):
+        type = self.readShort()
+        return PackEnum.create(type).read(self)
+
+    def readValue(self):
+        type = self.readByte()
+        return ValueEnum.create(type).read(self)
+
+    # TODO
+    # def available(self):
+    #     return len(self.buffer.getvalue())- self.offset > 0
+
+    # TODO
+    # def readStep(self):
+    #     raise
+    #     # byte type = this.inner.readByte();
+    #     # return StepEnum.create(type).read(this);
+    #     return None
+
+    def readIntBytes(self, max):
+        ln = self.readInt()
+        if ln < 0 or ln > max:
+            raise Exception('error')
+        return self.buffer.read(ln)
+
+    def readBoolean(self):
+        v = self.buffer.read(1)
+        return struct.unpack('>?', v)[0]
+
+    def readByte(self):
+        v = self.buffer.read(1)
+        return struct.unpack('>b', v)[0]
+
+    def readShort(self):
+        v = self.buffer.read(2)
+        return struct.unpack('>h', v)[0]
+
+    def readInt3(self):
+        s = self.buffer.read(3)
+        chrs = struct.unpack('>bBB', s)
+        ch1 = (chrs[0])
+        ch2 = (chrs[1])
+        ch3 = (chrs[2])
+        return (ch1 << 16) + (ch2 << 8) + ch3
+
+    def readInt(self):
+        v = self.buffer.read(4)
+
+        return struct.unpack('>i', v)[0]
+
+    def readLong5(self):
+        s = self.buffer.read(5)
+        chrs = struct.unpack('>bBBBB', s)
+        ch1 = (chrs[0])
+        ch2 = (chrs[1])
+        ch3 = (chrs[2])
+        ch4 = (chrs[3])
+        ch5 = (chrs[4])
+        return ((ch1 << 32) + (ch2 << 24) + (ch3 << 16) + (ch4 << 8) + (ch5))
+
+    def readLong(self):
+        v = self.buffer.read(8)
+        return struct.unpack('>q', v)[0]
+
+    def readFloat(self):
+        v = self.buffer.read(4)
+        return struct.unpack('>f', v)[0]
+
+    def readDouble(self):
+        v = self.buffer.read(8)
+        return struct.unpack('>d', v)[0]
+
+    def readDecimal(self):
+        ln = self.readByte()
+        if ln == 0:
+            return 0
+        elif ln == 1:
+            return self.readByte()
+        elif ln == 2:
+            return self.readShort()
+        elif ln == 3:
+            return self.readInt3()
+        elif ln == 4:
+            return self.readInt()
+        elif ln == 5:
+            return self.readLong5()
+        else:
+            return self.readLong()
+
+    def read(self, ln):
+        return self.buffer.read(ln)
+
+    def readBlob(self):
+        baselen = self.readByte() & 0xff
+        if baselen == 255:
+            ln = self.readShort() & 0xffff
+            return self.buffer.read(ln)
+        elif baselen == 254:
+            ln = self.readInt()
+            return self.buffer.read(ln)
+        elif baselen == 0:
+            return []
+        else:
+            return self.buffer.read(baselen)
+
+    def readText(self):
+        arr = self.readBlob()
+        if not len(arr):
+            return ''
+        else:
+            return arr.decode("utf-8")
+
+    def toByteArray(self):
+        return self.buffer.getvalue()
+
+    def readFloatArray(self):
+        ln = self.readShort()
+        data = []
+        for _ in range(ln):
+            data.append(self.readFloat())
+        return data
+
+    def readIntArray(self):
+        ln = self.readShort()
+        data = []
+        for _ in range(ln):
+            data.append(self.readInt())
+        return data
+
+    def readLongArray(self):
+        ln = self.readShort()
+        data = []
+        for _ in range(ln):
+            data.append(self.readLong())
+        return data
+
+    def readDecimalArray(self):
+        ln = self.readShort()
+        data = []
+        for _ in range(ln):
+            data.append(self.readDecimal())
+        return data