whatap-python 2.1.0__py3-none-any.whl

whatap/llm/log_sink_packs/llm_input_message.py

@@ -0,0 +1,16 @@
+"""LLM 입력 메시지 데이터 모델 정의."""
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+
+
+class LlmInputMessage(LlmLogSinkPack):
+    """사용자 입력 프롬프트 메시지를 담는 팩."""
+
+    LLM_LOG_TYPE = 'input_message'
+
+    def __init__(self):
+        super().__init__()
+        self.prompt_text = ''
+
+    def content(self):
+        """입력 프롬프트 텍스트를 반환한다."""
+        return self.prompt_text

whatap/llm/log_sink_packs/llm_log_sink_pack.py

@@ -0,0 +1,72 @@
+"""LLM LogSink 팩의 기본 클래스 정의."""
+from whatap.llm.definitions import LOG_SINK_CATEGORY
+
+
+class LlmLogSinkPack(object):
+    """LLM LogSink 팩 기본 클래스로, 공통 태그와 컨텍스트 설정을 제공한다."""
+
+    CATEGORY = LOG_SINK_CATEGORY
+    LLM_LOG_TYPE = None
+
+    def __init__(self):
+        """공통 필드(txid, step_id, index, provider, url, operation_type, prompt_version)."""
+        self.txid = None
+        self.step_id = None
+        self.index = 0
+        self.provider = ''
+        self.url = ''
+        # operation_type 태그는 ``prompt_meta`` 데코레이터/스코프 의 prompt name 을 담는다.
+        # default: 'default' — 데코레이터 미적용 시.
+        self.operation_type = 'default'
+        # prompt 버전. ``prompt_meta(version='v2')`` 등으로 지정. default 'v1'.
+        self.prompt_version = 'v1'
+
+    @classmethod
+    def from_pack(cls, pack, **kwargs):
+        """기존 팩으로부터 새 인스턴스를 생성한다."""
+        obj = cls()
+        obj.txid = pack.txid
+        obj.step_id = pack.step_id
+        obj.provider = pack.provider
+        obj.index = pack.index
+        obj.operation_type = getattr(pack, 'operation_type', 'default')
+        obj.prompt_version = getattr(pack, 'prompt_version', 'v1')
+        for key, val in kwargs.items():
+            setattr(obj, key, val)
+        return obj
+
+    def set_context(self, ctx):
+        """트랜잭션 컨텍스트에서 txid, step_id, provider 정보를 설정한다."""
+        if ctx:
+            if not self.txid:
+                self.txid = str(ctx.id)
+            if not self.step_id:
+                self.step_id = str(getattr(ctx, '_llm_step_id', 0))
+            if not self.provider:
+                httpc_url = getattr(ctx, '_llm_httpc_url', '') or ''
+                if httpc_url:
+                    url = httpc_url
+                    if '://' in url:
+                        url = url.split('://', 1)[1]
+                    self.provider = url.split('/', 1)[0]
+                    if '/' in url:
+                        self.url = '/' + url.split('/', 1)[1]
+
+    def tags(self):
+        """공통 태그 딕셔너리를 반환한다 (모든 sub-pack 이 상속)."""
+        return {
+            'llm_log_type': self.LLM_LOG_TYPE,
+            '@txid': self.txid,
+            '@step_id': self.step_id,
+            'provider': self.provider,
+            'operation_type': self.operation_type,
+            'prompt_version': self.prompt_version,
+        }
+
+    def fields(self):
+        """필드 딕셔너리를 반환한다."""
+        return {}
+
+    def content(self):
+        """로그 콘텐츠 문자열을 반환한다."""
+        return ''

whatap/llm/log_sink_packs/llm_output_message.py

@@ -0,0 +1,19 @@
+"""LLM 출력 메시지 데이터 모델 정의."""
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+
+
+class LlmOutputMessage(LlmLogSinkPack):
+    """LLM 응답(completion + reasoning) 메시지를 담는 팩."""
+
+    LLM_LOG_TYPE = 'output_message'
+
+    def __init__(self):
+        super().__init__()
+        self.completion_text = ''
+        self.reasoning_text = ''
+
+    def content(self):
+        """reasoning + completion 텍스트를 합쳐서 반환한다."""
+        if self.reasoning_text and self.completion_text:
+            return self.reasoning_text + '\n' + self.completion_text
+        return self.reasoning_text or self.completion_text or ''

whatap/llm/log_sink_packs/llm_step_eval_status.py

@@ -0,0 +1,94 @@
+"""LLM 평가 결과 데이터 모델.
+
+``LlmStepStatus`` 와 동일한 구조 (모델/토큰/비용/지연시간/결합키 등) 를 그대로 갖되
+``llm_log_type`` 만 ``llm_step_eval_status`` 로 다른 pack. 평가 결과 점수 필드 추가.
+
+평가 워커가 evaluator.evaluate() 결과를 받으면 원본 ``LlmStepStatus`` pack 을 복제해
+이 클래스로 만들고 (txid, step_id, index 결합 키 동일) 점수를 채워 송출한다.
+백엔드에서는 같은 ``(txid, step_id)`` 로 원본 ``llm_step_status`` 와 짝지어 본다.
+
+점수 필드 (0.0 ~ 1.0, evaluator label 별):
+  eval_hallucination       — HallucinationEvaluator
+  eval_answer_relevance    — AnswerRelevanceEvaluator
+  eval_toxicity            — ToxicityEvaluator
+  eval_prompt_injection    — PromptInjectionEvaluator
+  eval_factuality          — FactualityEvaluator
+  eval_pii_leak            — PIILeakEvaluator (규칙 기반)
+  eval_url_scan            — URLScanEvaluator  (규칙 기반)
+  eval_combined_judge      — CombinedJudgeEvaluator (worst-aspect risk)
+  eval_success             — 평가 자체 성공/실패 (bool → 1/0)
+
+대응되는 evaluator-label → 필드 매핑은 ``llm_evaluator_task._LABEL_TO_FIELD`` 에 있고,
+대응되는 metric (score histogram) 카테고리 매핑은 ``stats.eval_stat._LABEL_TO_STAT_NAME``
+에 있다. 신규 evaluator 추가 시 세 곳 (이 attr / _LABEL_TO_FIELD / _LABEL_TO_STAT_NAME)
+모두 갱신 필요.
+"""
+import copy
+
+from whatap.llm.log_sink_packs.llm_step_status import LlmStepStatus
+
+
+class LlmStepEvalStatus(LlmStepStatus):
+    """LlmStepStatus 와 동일한 구조 + 평가 점수 필드들."""
+
+    LLM_LOG_TYPE = 'llm_step_eval_status'
+
+    def __init__(self):
+        super().__init__()
+        # 평가 점수 (0.0 ~ 1.0). evaluator 가 산출 안 했으면 None — 송출 시 누락.
+        self.eval_hallucination = None
+        self.eval_answer_relevance = None
+        self.eval_toxicity = None
+        self.eval_prompt_injection = None
+        self.eval_factuality = None
+        self.eval_pii_leak = None
+        self.eval_url_scan = None
+        self.eval_combined_judge = None
+        # 평가 자체가 성공/실패 (judge 호출 + parse 모두 정상이면 True). bool.
+        self.eval_success = None
+
+    @classmethod
+    def from_step_status(cls, step):
+        """원본 ``LlmStepStatus`` pack 의 모든 attr 을 복제한 새 EvalStatus 인스턴스 반환.
+
+        평가 워커가 원본 pack 을 받아 이 메서드로 복제 → 점수 채움 → 송출.
+        원본 pack 은 LlmLogSinkTask 가 이미 즉시 송출했고 변경 없이 그대로 둔다.
+
+        mutable 컨테이너 (list/dict — e.g. ``system_texts``) 는 얕은 복사로
+        분리해 원본과 별도 인스턴스가 되도록 한다. evaluator 가 metadata 를 list
+        에 append 하거나 future 코드가 eval pack 의 필드를 변형해도 원본에 leak
+        되지 않도록 방어. trace ctx / client / event loop 같은 외부 객체는 공유
+        (reference 만 들고있음).
+        """
+        new = cls()
+        for k, v in step.__dict__.items():
+            if isinstance(v, (list, dict, set)):
+                # 동일 컨테이너 reference 공유 차단. 안의 원소는 그대로.
+                try:
+                    v = copy.copy(v)
+                except Exception:
+                    pass
+            setattr(new, k, v)
+        return new
+
+    def fields(self):
+        f = super().fields()
+        if self.eval_hallucination is not None:
+            f['eval_hallucination.n'] = float(self.eval_hallucination)
+        if self.eval_answer_relevance is not None:
+            f['eval_answer_relevance.n'] = float(self.eval_answer_relevance)
+        if self.eval_toxicity is not None:
+            f['eval_toxicity.n'] = float(self.eval_toxicity)
+        if self.eval_prompt_injection is not None:
+            f['eval_prompt_injection.n'] = float(self.eval_prompt_injection)
+        if self.eval_factuality is not None:
+            f['eval_factuality.n'] = float(self.eval_factuality)
+        if self.eval_pii_leak is not None:
+            f['eval_pii_leak.n'] = float(self.eval_pii_leak)
+        if self.eval_url_scan is not None:
+            f['eval_url_scan.n'] = float(self.eval_url_scan)
+        if self.eval_combined_judge is not None:
+            f['eval_combined_judge.n'] = float(self.eval_combined_judge)
+        if self.eval_success is not None:
+            f['eval_success.n'] = 1 if self.eval_success else 0
+        return f

whatap/llm/log_sink_packs/llm_step_status.py

@@ -0,0 +1,118 @@
+"""LLM 스텝 상태 데이터 모델 정의."""
+from whatap.llm.definitions import PROVIDER_TOKEN_FIELDS, DEFAULT_TOKEN_FIELDS
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+
+
+class LlmStepStatus(LlmLogSinkPack):
+    """LLM API 호출 단위의 상태, 토큰, 비용, 지연시간 데이터를 담는 팩.
+
+    평가 결과는 별도 ``LlmStepEvalStatus`` pack 으로 송출되며 (txid, step_id) 결합 키로
+    백엔드에서 사후 결합. LlmStepStatus 자체는 평가 결과를 담지 않는다.
+    """
+
+    LLM_LOG_TYPE = 'llm_step_status'
+
+    def __init__(self):
+        """상태, 토큰, 비용, 지연시간 필드를 초기화한다."""
+        super().__init__()
+        # status
+        self.model = None
+        self.stream = False
+        self.success = False
+        self.finish_reason = None
+        self.features = ''
+        self.temperature = None
+        self.error = None
+        self.error_type = None
+
+        # tokens
+        self.input_tokens = None
+        self.output_tokens = None
+        self.total_tokens_count = None
+        self.cached_tokens = None
+        self.reasoning_tokens = None
+        self.audio_input_tokens = None
+        self.audio_output_tokens = None
+        self.accepted_prediction_tokens = None
+        self.rejected_prediction_tokens = None
+        self.embedding_count = None
+        self.dimensions = None
+        self.similarity = None
+        self.cache_creation_input_tokens = None
+        self.cache_read_input_tokens = None
+
+        # cost (USD)
+        self.cost = None
+        self.input_cost = None
+        self.output_cost = None
+        self.cached_cost = None
+        self.cache_creation_cost = None
+
+        # latency (ms)
+        self._start_time = 0
+        self.ttft = None
+        self.latency = None
+
+    def set_error(self, error, error_type):
+        """에러 정보를 설정한다."""
+        self.error = str(error)
+        self.error_type = error_type
+
+    def set_tokens(self, token_dict):
+        """토큰 사용량 딕셔너리로부터 값을 설정한다."""
+        for key, val in token_dict.items():
+            if hasattr(self, key) and val is not None:
+                setattr(self, key, val)
+
+    def calculate_cost(self):
+        """모델 가격 정보를 기반으로 비용을 계산한다."""
+        from whatap.llm.pricing import calculate_cost
+        calculate_cost(self)
+
+    def tags(self):
+        """스텝 상태 태그(모델, 스트림, 성공 여부 등)."""
+        t = super().tags()
+        t['model'] = self.model
+        t['stream'] = str(self.stream)
+        t['finish_reason'] = self.finish_reason or ''
+        t['operation_type'] = self.operation_type
+        t['features'] = self.features
+        return t
+
+    def fields(self):
+        """온도, 토큰, 에러 등 수치 필드."""
+        f = {}
+        if self.temperature is not None:
+            f['temperature.n'] = self.temperature
+        f.update(self._token_fields())
+        if self.error_type in ('api_error', 'program_error'):
+            f['error'] = self.error
+            f['error_type'] = self.error_type
+        return f
+
+    def _token_fields(self):
+        keys = DEFAULT_TOKEN_FIELDS
+        for provider_key, token_fields in PROVIDER_TOKEN_FIELDS.items():
+            if provider_key in self.provider:
+                keys = token_fields
+                break
+        fields = {}
+        for key in keys:
+            val = getattr(self, key, None)
+            if val is not None:
+                fields[key + '.n'] = val
+        if self.cost is not None:
+            fields['cost.n'] = self.cost
+        if self.input_cost:
+            fields['input_cost.n'] = self.input_cost
+        if self.output_cost:
+            fields['output_cost.n'] = self.output_cost
+        if self.cached_cost:
+            fields['cached_cost.n'] = self.cached_cost
+        if self.cache_creation_cost:
+            fields['cache_creation_cost.n'] = self.cache_creation_cost
+        if self.latency is not None:
+            fields['latency.n'] = self.latency
+        if self.ttft is not None:
+            fields['ttft.n'] = self.ttft
+        return fields

whatap/llm/log_sink_packs/llm_system_message.py

@@ -0,0 +1,16 @@
+"""LLM 시스템 메시지 데이터 모델 정의."""
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+
+
+class LlmSystemMessage(LlmLogSinkPack):
+    """시스템 프롬프트 메시지를 담는 팩."""
+
+    LLM_LOG_TYPE = 'system_message'
+
+    def __init__(self):
+        super().__init__()
+        self.system_text = ''
+
+    def content(self):
+        """시스템 메시지 텍스트를 반환한다."""
+        return self.system_text

whatap/llm/log_sink_packs/llm_tool_calls.py

@@ -0,0 +1,44 @@
+"""LLM 도구 호출 데이터 모델 정의."""
+from whatap import logging
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+
+
+class LlmToolCalls(LlmLogSinkPack):
+    """LLM 도구(tool) 호출 정보를 담는 팩."""
+
+    LLM_LOG_TYPE = 'tool'
+
+    def __init__(self):
+        super().__init__()
+        self.tool_calls_text = ''
+
+    def fields(self):
+        """도구 호출 JSON을 파싱하여 함수명과 인자를 필드로 반환한다."""
+        return self._parse(self.tool_calls_text)
+
+    def content(self):
+        """도구 호출 원본 텍스트를 반환한다."""
+        return self.tool_calls_text
+
+    @staticmethod
+    def _parse(tool_calls_text):
+        import json
+        fields = {}
+        try:
+            tc_list = json.loads(tool_calls_text)
+            if isinstance(tc_list, list):
+                names = []
+                args = []
+                for tc in tc_list:
+                    fn = tc.get("function", "")
+                    if isinstance(fn, dict):
+                        names.append(fn.get("name", ""))
+                        args.append(fn.get("arguments", ""))
+                    else:
+                        names.append(fn)
+                        args.append(tc.get("arguments", ""))
+                fields["function"] = ",".join(n for n in names if n)
+                fields["arguments"] = ",".join(a for a in args if a)
+        except Exception as e:
+            logging.warning('[LLM] tool_calls parse failed: %s' % e, extra={'id': 'LLM017'})
+        return fields

whatap/llm/log_sink_packs/llm_tool_results.py

@@ -0,0 +1,16 @@
+"""LLM 도구 실행 결과 데이터 모델 정의."""
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+
+
+class LlmToolResults(LlmLogSinkPack):
+    """도구(tool) 실행 결과를 담는 팩."""
+
+    LLM_LOG_TYPE = 'tool_result'
+
+    def __init__(self):
+        super().__init__()
+        self.tool_results_text = ''
+
+    def content(self):
+        """도구 실행 결과 텍스트를 반환한다."""
+        return self.tool_results_text

whatap/llm/log_sink_packs/llm_tx_status.py

@@ -0,0 +1,108 @@
+"""LLM 트랜잭션 요약 상태 데이터 모델 정의."""
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+
+TX_SUMMARY_TOKEN_FIELDS = [
+    'input_tokens', 'output_tokens', 'total_tokens_count',
+    'cached_tokens', 'reasoning_tokens',
+    'audio_input_tokens', 'audio_output_tokens',
+    'accepted_prediction_tokens', 'rejected_prediction_tokens',
+    'cache_creation_input_tokens', 'cache_read_input_tokens',
+    'embedding_count',
+]
+
+
+class LlmTxStatus(LlmLogSinkPack):
+    """트랜잭션 단위의 LLM 호출 요약 정보를 집계하는 팩."""
+
+    LLM_LOG_TYPE = 'llm_tx_status'
+
+    def __init__(self):
+        """호출 횟수, 에러, 토큰, 비용, 모델 등 집계 필드를 초기화한다."""
+        super().__init__()
+        self.first_step_id = None
+        self.last_step_id = None
+        self.call_count = 0
+        self.error_count = 0
+        self.latency = 0.0
+        self.cost = 0.0
+        self.input_cost = 0.0
+        self.output_cost = 0.0
+        self.models = set()
+        self.operation_types = set()
+        self.prompt_versions = set()
+        self.providers = set()
+        for f in TX_SUMMARY_TOKEN_FIELDS:
+            setattr(self, f, 0)
+
+    def accumulate(self, pack):
+        """스텝 상태 팩의 데이터를 트랜잭션 요약에 누적한다."""
+        self.call_count += 1
+        if not pack.success:
+            self.error_count += 1
+
+        for f in TX_SUMMARY_TOKEN_FIELDS:
+            val = getattr(pack, f, None)
+            if val:
+                setattr(self, f, getattr(self, f) + val)
+
+        if pack.latency:
+            self.latency += pack.latency
+        if pack.cost:
+            self.cost += pack.cost
+        if pack.input_cost:
+            self.input_cost += pack.input_cost
+        if pack.output_cost:
+            self.output_cost += pack.output_cost
+
+        if pack.step_id:
+            if self.first_step_id is None:
+                self.first_step_id = pack.step_id
+            self.last_step_id = pack.step_id
+
+        if pack.provider:
+            self.providers.add(pack.provider)
+        if pack.model:
+            self.models.add(pack.model)
+        if pack.operation_type and pack.operation_type not in ('unknown', ''):
+            self.operation_types.add(pack.operation_type)
+        pv = getattr(pack, 'prompt_version', None)
+        if pv:
+            self.prompt_versions.add(pv)
+
+    def tags(self):
+        """트랜잭션 요약 태그(provider, model, operation_type, prompt_version 등)."""
+        tags = {
+            'llm_log_type': self.LLM_LOG_TYPE,
+            '@txid': self.txid,
+            '@first_step_id': self.first_step_id or '',
+            '@last_step_id': self.last_step_id or '',
+        }
+        if self.providers:
+            tags['provider'] = ','.join(sorted(self.providers))
+        if self.models:
+            tags['model'] = ','.join(sorted(self.models))
+        if self.operation_types:
+            tags['operation_type'] = ','.join(sorted(self.operation_types))
+        if self.prompt_versions:
+            tags['prompt_version'] = ','.join(sorted(self.prompt_versions))
+        return tags
+
+    def fields(self):
+        """호출 횟수, 토큰, 비용 등 집계 수치 필드를 반환한다."""
+        fields = {
+            'call_count.n': self.call_count,
+            'error_count.n': self.error_count,
+        }
+        for f in TX_SUMMARY_TOKEN_FIELDS:
+            val = getattr(self, f, 0)
+            if val:
+                fields[f + '.n'] = val
+        if self.latency:
+            fields['latency.n'] = self.latency
+        if self.cost:
+            fields['cost.n'] = round(self.cost, 6)
+        if self.input_cost:
+            fields['input_cost.n'] = round(self.input_cost, 6)
+        if self.output_cost:
+            fields['output_cost.n'] = round(self.output_cost, 6)
+        return fields