whatap-python 2.1.0__tar.gz → 2.1.1__tar.gz

{whatap_python-2.1.0 → whatap_python-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whatap-python
-Version: 2.1.0
+Version: 2.1.1
 Summary: Monitoring and Profiling Service
 Home-page: https://www.whatap.io
 Author: whatap

whatap_python-2.1.1/tests/test_stream_ttft.py

@@ -0,0 +1,192 @@
+"""스트리밍 LLM 응답에서 TTFT/TPOT 트리거 회귀 테스트.
+
+버그: tool_calls / reasoning 위주 스트리밍 응답에서 텍스트 content delta 가 없으면
+on_first_token() 이 호출되지 않아 pack.ttft 가 None 이 되고, 그 결과 perf_stat 의
+TPOT 도 계산되지 않았다. (latency / output_tokens 는 정상)
+
+이 테스트는 stdlib unittest 로 작성됐고, provider SDK(openai/anthropic) 설치 없이
+실행되도록 extractor 모듈을 파일 경로로 직접 로드한다(패키지 __init__ 의 SDK import 우회).
+
+실행:  python3 -m unittest tests.test_stream_ttft -v
+"""
+import importlib.util
+import os
+import unittest
+
+_BASE = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+    "whatap", "llm", "providers",
+)
+
+
+def _load(name, relpath):
+    spec = importlib.util.spec_from_file_location(name, os.path.join(_BASE, relpath))
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+chat_extractor = _load("chat_extractor_ut", "openai/chat/chat_extractor.py")
+messages_extractor = _load("messages_extractor_ut", "anthropic/messages/messages_extractor.py")
+responses_extractor = _load("responses_extractor_ut", "openai/responses/responses_extractor.py")
+completions_extractor = _load("completions_extractor_ut", "openai/completions/completions_extractor.py")
+
+from whatap.llm.log_sink_packs.llm_step_status import LlmStepStatus
+from whatap.llm.stats.perf_stat import PerfStat
+
+
+class _Obj(object):
+    """getattr 기반 더미 — 키워드로 임의 속성을 갖는 객체를 만든다."""
+
+    def __init__(self, **kw):
+        for k, v in kw.items():
+            setattr(self, k, v)
+
+
+def _chat_chunk(content=None, reasoning=None, tool_calls=None, usage=None, finish_reason=None):
+    delta = _Obj(content=content, reasoning_content=reasoning, reasoning=None, tool_calls=tool_calls)
+    choice = _Obj(delta=delta, finish_reason=finish_reason)
+    return _Obj(choices=[choice], usage=usage)
+
+
+def _tool_call_delta(index=0, call_id=None, name=None, arguments=None):
+    fn = _Obj(name=name, arguments=arguments)
+    return _Obj(index=index, id=call_id, function=fn)
+
+
+class ChatStreamTTFTTest(unittest.TestCase):
+    """OpenAI Chat Completions 스트림의 on_first_token 트리거."""
+
+    def _new(self):
+        pack = LlmStepStatus()
+        return chat_extractor.ChatStream(pack, active_key=None)
+
+    def test_text_delta_sets_ttft(self):
+        """회귀: 텍스트 content delta 는 여전히 첫 토큰으로 인식된다."""
+        acc = self._new()
+        acc.on_chunk(_chat_chunk(content="Hello"))
+        self.assertIsNotNone(acc.first_token_time)
+
+    def test_tool_call_only_sets_ttft(self):
+        """수정: content 없이 tool_calls delta 만 와도 첫 토큰으로 인식된다."""
+        acc = self._new()
+        acc.on_chunk(_chat_chunk(tool_calls=[_tool_call_delta(call_id="call_1", name="get_weather", arguments='{"c')]))
+        self.assertIsNotNone(acc.first_token_time)
+        self.assertTrue(acc.has_tool)
+
+    def test_reasoning_only_sets_ttft(self):
+        """수정: content 없이 reasoning delta 만 와도 첫 토큰으로 인식된다."""
+        acc = self._new()
+        acc.on_chunk(_chat_chunk(reasoning="Let me think"))
+        self.assertIsNotNone(acc.first_token_time)
+        self.assertEqual(acc.reasoning, "Let me think")
+
+    def test_first_token_time_idempotent(self):
+        """on_first_token 은 멱등 — 첫 delta 시각이 유지된다."""
+        acc = self._new()
+        acc.on_chunk(_chat_chunk(tool_calls=[_tool_call_delta(call_id="c", name="f", arguments="{}")]))
+        first = acc.first_token_time
+        acc.on_chunk(_chat_chunk(content="text"))
+        self.assertEqual(acc.first_token_time, first)
+
+
+class AnthropicStreamTTFTTest(unittest.TestCase):
+    """Anthropic Messages 스트림의 on_first_token 트리거."""
+
+    def _new(self):
+        return messages_extractor.AnthropicStream(LlmStepStatus(), active_key=None, features=[])
+
+    def test_text_delta_sets_ttft(self):
+        acc = self._new()
+        acc.on_chunk(_Obj(type="content_block_start", content_block=_Obj(type="text", name=None)))
+        acc.on_chunk(_Obj(type="content_block_delta", delta=_Obj(text="Hi", thinking=None)))
+        self.assertIsNotNone(acc.first_token_time)
+
+    def test_tool_use_block_sets_ttft(self):
+        """수정: tool_use 블록 시작 시 첫 토큰으로 인식."""
+        acc = self._new()
+        acc.on_chunk(_Obj(type="content_block_start", content_block=_Obj(type="tool_use", name="get_weather")))
+        self.assertIsNotNone(acc.first_token_time)
+
+    def test_thinking_delta_sets_ttft(self):
+        """수정: thinking(reasoning) delta 시 첫 토큰으로 인식."""
+        acc = self._new()
+        acc.on_chunk(_Obj(type="content_block_start", content_block=_Obj(type="thinking", name=None)))
+        acc.on_chunk(_Obj(type="content_block_delta", delta=_Obj(thinking="hmm", text=None)))
+        self.assertIsNotNone(acc.first_token_time)
+        self.assertEqual(acc.reasoning, "hmm")
+
+
+class ResponsesStreamTTFTTest(unittest.TestCase):
+    """OpenAI Responses 스트림의 on_first_token 트리거."""
+
+    def _new(self):
+        return responses_extractor.ResponsesStream(LlmStepStatus(), active_key=None)
+
+    def test_text_delta_sets_ttft(self):
+        acc = self._new()
+        acc.on_chunk(_Obj(type="response.output_text.delta", delta="Hi"))
+        self.assertIsNotNone(acc.first_token_time)
+
+    def test_function_call_item_sets_ttft(self):
+        """수정: function_call 아이템 추가 시 첫 토큰으로 인식."""
+        acc = self._new()
+        acc.on_chunk(_Obj(type="response.output_item.added",
+                          item=_Obj(type="function_call", call_id="call_1", id="i1", name="get_weather")))
+        self.assertIsNotNone(acc.first_token_time)
+
+    def test_function_call_arguments_delta_sets_ttft(self):
+        """수정: function_call 인자 delta 시에도 첫 토큰으로 인식(아이템 누락 대비)."""
+        acc = self._new()
+        acc.on_chunk(_Obj(type="response.output_item.added",
+                          item=_Obj(type="function_call", call_id="call_1", id="i1", name="f")))
+        ft = acc.first_token_time
+        acc.on_chunk(_Obj(type="response.function_call_arguments.delta", call_id="call_1", delta='{"a":1}'))
+        self.assertEqual(acc.first_token_time, ft)  # 멱등
+
+
+class CompletionsStreamTTFTTest(unittest.TestCase):
+    """레거시 Completions 스트림(텍스트 전용) 회귀 확인."""
+
+    def test_text_delta_sets_ttft(self):
+        acc = completions_extractor.CompletionsStream(LlmStepStatus(), active_key=None)
+        acc.on_chunk(_Obj(choices=[_Obj(text="Hi", finish_reason=None)], usage=None))
+        self.assertIsNotNone(acc.first_token_time)
+
+
+class PerfStatTPOTTest(unittest.TestCase):
+    """ttft 가 세팅되면 perf_stat 이 TPOT 를 계산한다."""
+
+    def _pack(self, ttft, latency, output_tokens):
+        p = LlmStepStatus()
+        p.model = "gpt-5.4"
+        p.provider = "openai"
+        p.stream = True
+        p.success = True
+        p.ttft = ttft
+        p.latency = latency
+        p.output_tokens = output_tokens
+        return p
+
+    def test_tpot_recorded_when_ttft_present(self):
+        stat = PerfStat()
+        stat.update_from_pack(self._pack(ttft=100, latency=900, output_tokens=9))
+        # tpot = (900-100)/(9-1) = 100
+        keys = list(stat._stats["tpot_count"].keys())
+        self.assertEqual(len(keys), 1)
+        self.assertEqual(stat._stats["tpot_count"][keys[0]], 1)
+        self.assertAlmostEqual(stat._stats["tpot_sum"][keys[0]], 100.0)
+        self.assertEqual(stat._stats["ttft_count"][keys[0]], 1)
+
+    def test_tpot_absent_when_ttft_none(self):
+        """버그 재현: ttft 가 None 이면 TPOT 미기록(분자 계산 불가)."""
+        stat = PerfStat()
+        stat.update_from_pack(self._pack(ttft=None, latency=900, output_tokens=9))
+        key = list(stat._stats["call_count"].keys())[0]  # 호출은 기록되지만
+        self.assertEqual(stat._stats["call_count"][key], 1)
+        self.assertEqual(stat._stats["tpot_count"][key], 0)  # TPOT/TTFT 는 미기록
+        self.assertEqual(stat._stats["ttft_count"][key], 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

whatap_python-2.1.1/whatap/build.py

@@ -0,0 +1,4 @@
+app = 'Python'
+name = 'whatap-python'
+version = '2.1.1'
+release_date = '20260622'

whatap_python-2.1.1/whatap/llm/providers/anthropic/messages/messages.py

@@ -0,0 +1,86 @@
+"""Anthropic Messages API 호출을 인터셉트하는 모듈."""
+from anthropic import APIError
+
+from whatap.llm.providers.interceptor import (
+    before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
+    capture_client, extract_response, _safe, _clear_httpc_pending,
+)
+from whatap.llm.providers.stream_accumulator import wrap_sync_stream, wrap_async_stream
+from whatap.llm.providers.anthropic.messages.messages_context import build_context
+from whatap.llm.providers.anthropic.messages.messages_extractor import finalize, AnthropicStream
+
+
+def intercept_create(fn, *args, **kwargs):
+    """Anthropic Messages 동기 호출을 인터셉트한다. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        pack, ctx, features, stream = build_context(kwargs)
+        capture_client(pack, ctx, args)
+        active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+        before_call(pack, active_key)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return fn(*args, **kwargs)
+
+    _stream_returned = False
+    try:
+        try:
+            response = fn(*args, **kwargs)
+        except Exception as err:
+            _safe(handle_error, pack, err, active_key, APIError)
+            raise
+        finally:
+            _safe(_clear_httpc_pending, ctx)
+
+        try:
+            after_call(pack, ctx)
+            if stream:
+                result, _stream_returned = wrap_sync_stream(response, AnthropicStream(pack, active_key, features))
+                return result
+            extract_response(response, finalize, pack, features)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
+        return response
+    finally:
+        if not _stream_returned:
+            _safe(_ensure_end, pack, active_key)
+
+
+async def async_intercept_create(fn, *args, **kwargs):
+    """Anthropic Messages 비동기 호출을 인터셉트한다. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        pack, ctx, features, stream = build_context(kwargs)
+        capture_client(pack, ctx, args)
+        active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+        before_call(pack, active_key)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return await fn(*args, **kwargs)
+
+    _stream_returned = False
+    try:
+        try:
+            response = await fn(*args, **kwargs)
+        except Exception as err:
+            _safe(handle_error, pack, err, active_key, APIError)
+            raise
+        finally:
+            _safe(_clear_httpc_pending, ctx)
+
+        try:
+            after_call(pack, ctx)
+            if stream:
+                result, _stream_returned = wrap_async_stream(response, AnthropicStream(pack, active_key, features))
+                return result
+            extract_response(response, finalize, pack, features)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
+        return response
+    finally:
+        if not _stream_returned:
+            _safe(_ensure_end, pack, active_key)

{whatap_python-2.1.0 → whatap_python-2.1.1}/whatap/llm/providers/anthropic/messages/messages_extractor.py

@@ -84,6 +84,7 @@ class AnthropicStream(StreamAccumulator):
             self.block_type = getattr(block, 'type', None)
             self.block_name = getattr(block, 'name', None)
             if self.block_type == 'tool_use':
+                self.on_first_token()
                 tag = (LlmFeature.COMPUTER_USE
                        if self.block_name and 'computer' in self.block_name
                        else LlmFeature.TOOL_USE)
@@ -92,7 +93,10 @@ class AnthropicStream(StreamAccumulator):
         elif t == 'content_block_delta':
             delta = getattr(event, 'delta', None)
             if self.block_type == 'thinking':
-                self.reasoning += getattr(delta, 'thinking', '') or ''
+                thinking = getattr(delta, 'thinking', '') or ''
+                if thinking:
+                    self.on_first_token()
+                    self.reasoning += thinking
             elif self.block_type == 'text':
                 text = getattr(delta, 'text', '') or ''
                 if text:

{whatap_python-2.1.0 → whatap_python-2.1.1}/whatap/llm/providers/interceptor.py

@@ -6,6 +6,7 @@ API 호출 전후 처리 흐름:
 """
 import time
 
+from whatap import logging
 from whatap.counter.tasks.llm_log_sink_task import dispatch_llm_pack
 
 
@@ -93,6 +94,25 @@ def _active_stat():
     return LlmStatTask.get_stat('ActiveStat')
 
 
+def _safe(fn, *args, **kwargs):
+    """계측 보조 단계를 안전하게 실행한다 — 예외를 흡수(디버그 로깅)해 사용자 호출을 보호.
+
+    계측은 어떤 경우에도 사용자 애플리케이션을 깨면 안 된다. 인터셉트 라이프사이클의
+    모든 보조 호출(before/after/handle_error/_ensure_end 등)을 이걸로 감싼다.
+    """
+    try:
+        return fn(*args, **kwargs)
+    except Exception as e:
+        logging.debug('[LLM] instrumentation step skipped: %s' % e, extra={'id': 'LLM008'})
+        return None
+
+
+def _clear_httpc_pending(ctx):
+    """fn() 직후 httpc pending 플래그 해제(있을 때만)."""
+    if ctx is not None:
+        ctx._llm_httpc_pending = False
+
+
 def before_call(pack, active_key):
     """API 호출 전: active 카운터 증가 + 시작 시간 기록 + 순차 인덱스 할당."""
     pack._active_ended = False
@@ -174,9 +194,39 @@ def finalize_non_streaming(pack, active_key):
         _ensure_end(pack, active_key)
 
 
+def extract_response(response, finalize_fn, pack, *finalize_args):
+    """비스트리밍 응답을 계측한다. 어떤 예외도 사용자 호출로 전파시키지 않는다.
+
+    계측은 사용자 애플리케이션을 절대 깨면 안 된다. finalize_fn 은 응답 구조
+    (``.choices`` / ``.content`` / ``.output`` 등) 를 단정하므로, 예상 밖 응답
+    (예: litellm/langchain 이 ``with_raw_response`` 로 받는 ``LegacyAPIResponse``)
+    이 와도 여기서 흡수하고 계측만 생략한다.
+
+    또한 응답이 ``parse()`` 를 가진 raw 래퍼면 parse() 로 실제 응답을 꺼내 계측한다.
+    parse() 결과는 캐시되어 호출측(litellm 등)의 후속 parse() 와 공유된다.
+    """
+    try:
+        target = response
+        parse = getattr(response, "parse", None)
+        if callable(parse):
+            try:
+                target = parse()
+            except Exception:
+                target = response
+        finalize_fn(target, pack, *finalize_args)
+    except Exception as e:
+        logging.debug('[LLM] response extract skipped: %s' % e, extra={'id': 'LLM005'})
+
+
 def _dispatch(pack):
-    """로그싱크팩 전송 + 메트릭 stat 업데이트 통합 호출."""
-    dispatch_llm_pack(pack)
-    inst = _stat_task()
-    if inst:
-        inst.notify(pack)
+    """로그싱크팩 전송 + 메트릭 stat 업데이트 통합 호출. 송출 실패는 사용자에게 전파 안 함."""
+    try:
+        dispatch_llm_pack(pack)
+    except Exception as e:
+        logging.debug('[LLM] dispatch failed: %s' % e, extra={'id': 'LLM006'})
+    try:
+        inst = _stat_task()
+        if inst:
+            inst.notify(pack)
+    except Exception as e:
+        logging.debug('[LLM] stat notify failed: %s' % e, extra={'id': 'LLM007'})

whatap_python-2.1.1/whatap/llm/providers/openai/chat/chat.py

@@ -0,0 +1,103 @@
+"""OpenAI Chat Completions API 호출을 인터셉트하는 모듈."""
+from openai import OpenAIError
+
+from whatap.llm.providers.interceptor import (
+    before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
+    capture_client, extract_response, _safe, _clear_httpc_pending,
+)
+from whatap.llm.providers.stream_accumulator import wrap_sync_stream, wrap_async_stream
+from whatap.llm.providers.openai.chat.chat_context import build_context
+from whatap.llm.providers.openai.chat.chat_extractor import finalize, ChatStream
+
+
+def intercept_create(fn, *args, **kwargs):
+    """OpenAI Chat Completions 동기 호출을 인터셉트하여 모니터링 데이터를 수집한다.
+
+    계측 어느 단계가 실패해도 사용자 호출은 보호된다 — 계측 예외는 전파하지 않고
+    사용자 fn 의 예외만 전파한다.
+    """
+    pack = active_key = None
+    try:
+        pack, ctx, features, stream = build_context(kwargs)
+        capture_client(pack, ctx, args)
+        active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+        if stream:
+            opts = dict(kwargs.get("stream_options") or {})
+            if not opts.get("include_usage"):
+                opts["include_usage"] = True
+                kwargs["stream_options"] = opts
+        before_call(pack, active_key)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return fn(*args, **kwargs)
+
+    _stream_returned = False
+    try:
+        try:
+            response = fn(*args, **kwargs)
+        except Exception as err:
+            _safe(handle_error, pack, err, active_key, OpenAIError)
+            raise
+        finally:
+            _safe(_clear_httpc_pending, ctx)
+
+        try:
+            after_call(pack, ctx)
+            if stream:
+                result, _stream_returned = wrap_sync_stream(response, ChatStream(pack, active_key))
+                return result
+            extract_response(response, finalize, pack, features)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
+        return response
+    finally:
+        if not _stream_returned:
+            _safe(_ensure_end, pack, active_key)
+
+
+async def intercept_create_async(fn, *args, **kwargs):
+    """OpenAI Chat Completions 비동기 호출을 인터셉트하여 모니터링 데이터를 수집한다.
+
+    계측 어느 단계가 실패해도 사용자 호출은 보호된다.
+    """
+    pack = active_key = None
+    try:
+        pack, ctx, features, stream = build_context(kwargs)
+        capture_client(pack, ctx, args)
+        active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+        if stream:
+            opts = dict(kwargs.get("stream_options") or {})
+            if not opts.get("include_usage"):
+                opts["include_usage"] = True
+                kwargs["stream_options"] = opts
+        before_call(pack, active_key)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return await fn(*args, **kwargs)
+
+    _stream_returned = False
+    try:
+        try:
+            response = await fn(*args, **kwargs)
+        except Exception as err:
+            _safe(handle_error, pack, err, active_key, OpenAIError)
+            raise
+        finally:
+            _safe(_clear_httpc_pending, ctx)
+
+        try:
+            after_call(pack, ctx)
+            if stream:
+                result, _stream_returned = wrap_async_stream(response, ChatStream(pack, active_key))
+                return result
+            extract_response(response, finalize, pack, features)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
+        return response
+    finally:
+        if not _stream_returned:
+            _safe(_ensure_end, pack, active_key)

{whatap_python-2.1.0 → whatap_python-2.1.1}/whatap/llm/providers/openai/chat/chat_extractor.py

@@ -89,9 +89,11 @@ class ChatStream(StreamAccumulator):
             getattr(delta, "reasoning_content", None) or
             getattr(delta, "reasoning", None) or "")
         if reasoning:
+            self.on_first_token()
             self.reasoning += reasoning
 
         if getattr(delta, "tool_calls", None):
+            self.on_first_token()
             self.has_tool = True
             for tc in delta.tool_calls:
                 idx = tc.index

whatap_python-2.1.1/whatap/llm/providers/openai/completions/completions.py

@@ -0,0 +1,86 @@
+"""OpenAI Completions API 인터셉트 진입점."""
+from openai import OpenAIError
+
+from whatap.llm.providers.interceptor import (
+    before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
+    capture_client, extract_response, _safe, _clear_httpc_pending,
+)
+from whatap.llm.providers.stream_accumulator import wrap_sync_stream, wrap_async_stream
+from whatap.llm.providers.openai.completions.completions_context import build_context
+from whatap.llm.providers.openai.completions.completions_extractor import finalize, CompletionsStream
+
+
+def intercept_completions(fn, *args, **kwargs):
+    """Completions API 동기 인터셉트. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        pack, ctx = build_context(kwargs)
+        capture_client(pack, ctx, args)
+        active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+        before_call(pack, active_key)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return fn(*args, **kwargs)
+
+    _stream_returned = False
+    try:
+        try:
+            response = fn(*args, **kwargs)
+        except Exception as err:
+            _safe(handle_error, pack, err, active_key, OpenAIError)
+            raise
+        finally:
+            _safe(_clear_httpc_pending, ctx)
+
+        try:
+            after_call(pack, ctx)
+            if pack.stream:
+                result, _stream_returned = wrap_sync_stream(response, CompletionsStream(pack, active_key))
+                return result
+            extract_response(response, finalize, pack)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
+        return response
+    finally:
+        if not _stream_returned:
+            _safe(_ensure_end, pack, active_key)
+
+
+async def intercept_completions_async(fn, *args, **kwargs):
+    """Completions API 비동기 인터셉트. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        pack, ctx = build_context(kwargs)
+        capture_client(pack, ctx, args)
+        active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+        before_call(pack, active_key)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return await fn(*args, **kwargs)
+
+    _stream_returned = False
+    try:
+        try:
+            response = await fn(*args, **kwargs)
+        except Exception as err:
+            _safe(handle_error, pack, err, active_key, OpenAIError)
+            raise
+        finally:
+            _safe(_clear_httpc_pending, ctx)
+
+        try:
+            after_call(pack, ctx)
+            if pack.stream:
+                result, _stream_returned = wrap_async_stream(response, CompletionsStream(pack, active_key))
+                return result
+            extract_response(response, finalize, pack)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
+        return response
+    finally:
+        if not _stream_returned:
+            _safe(_ensure_end, pack, active_key)

whatap_python-2.1.1/whatap/llm/providers/openai/embeddings/embeddings.py

@@ -0,0 +1,75 @@
+"""OpenAI Embeddings API 호출을 인터셉트하는 모듈."""
+from openai import OpenAIError
+
+from whatap.llm.providers.interceptor import (
+    before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
+    capture_client, extract_response, _safe, _clear_httpc_pending,
+)
+from whatap.llm.providers.openai.embeddings.embeddings_context import build_context
+from whatap.llm.providers.openai.embeddings.embeddings_extractor import finalize
+
+
+def intercept_embeddings(fn, *args, **kwargs):
+    """OpenAI Embeddings 동기 호출을 인터셉트한다. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        pack, ctx = build_context(kwargs)
+        capture_client(pack, ctx, args)
+        active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+        before_call(pack, active_key)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return fn(*args, **kwargs)
+
+    try:
+        try:
+            response = fn(*args, **kwargs)
+        except Exception as err:
+            _safe(handle_error, pack, err, active_key, OpenAIError)
+            raise
+        finally:
+            _safe(_clear_httpc_pending, ctx)
+
+        try:
+            after_call(pack, ctx)
+            extract_response(response, finalize, pack, kwargs)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
+        return response
+    finally:
+        _safe(_ensure_end, pack, active_key)
+
+
+async def intercept_embeddings_async(fn, *args, **kwargs):
+    """OpenAI Embeddings 비동기 호출을 인터셉트한다. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        pack, ctx = build_context(kwargs)
+        capture_client(pack, ctx, args)
+        active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+        before_call(pack, active_key)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return await fn(*args, **kwargs)
+
+    try:
+        try:
+            response = await fn(*args, **kwargs)
+        except Exception as err:
+            _safe(handle_error, pack, err, active_key, OpenAIError)
+            raise
+        finally:
+            _safe(_clear_httpc_pending, ctx)
+
+        try:
+            after_call(pack, ctx)
+            extract_response(response, finalize, pack, kwargs)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
+        return response
+    finally:
+        _safe(_ensure_end, pack, active_key)