whatap-python 2.1.2__tar.gz → 2.1.3rc1__tar.gz

{whatap_python-2.1.2 → whatap_python-2.1.3rc1}/PKG-INFO

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

{whatap_python-2.1.2 → whatap_python-2.1.3rc1}/whatap/__init__.py

@@ -389,6 +389,25 @@ def hooks(home):
                                                       'mod',
                                                       key)}
 
+            # 서비스(트랜잭션) 진입점 자동 래핑 (conf 방법). hook_method_patterns 와 같은
+            # import-hook 플러밍, 래퍼만 트랜잭션 open/close (whatap.trace.mod.hook_service_patterns).
+            # @method_profiling 을 소스 수정 없이 conf 로 적용하는 경로.
+            if conf.hook_service_patterns:
+                for pattern in conf.hook_service_patterns.split(','):
+                    pattern = pattern.strip()
+                    if not pattern or ':' not in pattern:
+                        continue
+                    module_name, class_def = pattern.split(':', 1)
+                    module_name = module_name.strip()
+                    class_def = class_def.strip()
+                    if not PLUGIN.get(module_name):
+                        PLUGIN[module_name] = []
+                    PLUGIN[module_name].append(class_def)
+                    # 대상 모듈이 PLUGIN 에 등록되면 ImportFinder 가 class_defs 패키징.
+                    IMPORT_HOOKS[module_name] = {
+                        'def': 'instrument_service',
+                        'module': 'whatap.trace.mod.hook_service_patterns'}
+
             if conf.standalone_enabled:
                 if conf.standalone_type == 'multiple-transaction':
                     from whatap.trace.mod.standalone.multiple import instrument_standalone_multiple
@@ -644,6 +663,7 @@ def go(batch=False, opts={}, llm=False):
 
 
 import signal
+import functools
 
 from whatap.trace.trace_handler import trace_handler
 from whatap.trace.trace_error import interceptor_step_error
@@ -671,7 +691,90 @@ def register_app(fn):
     return trace
 
 
+def _service_trace(fn, service_name=None):
+    """fn 을 하나의 트랜잭션(TX_START~TX_END)으로 감싼 래퍼를 반환한다.
+
+    ``@method_profiling`` 데코레이터와 conf ``hook_service_patterns``
+    (whatap.trace.mod.hook_service_patterns) 의 **공용 코어**. 여기엔 agent() 부팅이
+    없다 (데코레이터/부트 경로가 각자 처리).
+
+    코루틴 함수는 동기 래퍼로 감싸면 트랜잭션이 start_interceptor → 코루틴 생성 →
+    end_interceptor 로 즉시 열렸다 닫히고, 실제 본문은 호출자가 await 할 때 트랜잭션
+    밖에서 실행된다. async def 래퍼로 await 경계 안에서 트랜잭션을 열고 닫는다.
+    """
+    import inspect
+
+    name = service_name or fn.__name__
+
+    # 트랜잭션 종료 후 컨텍스트 정리. end_interceptor 는 TX_END 패킷만 보내고
+    # entry 맵/로컬 컨텍스트를 비우지 않는다(프레임워크 훅은 별도로 end 를 호출함).
+    # 스스로 트랜잭션을 열고 닫으므로 여기서 직접 정리한다:
+    #   - entry 맵에서 제거(안 하면 활성 트랜잭션 카운트/메모리 누수)
+    #   - 부모가 있으면(중첩 호출) 복원, 없으면(루트) 로컬 컨텍스트 클리어
+    #     (안 하면 종료된 ctx 를 계속 가리켜 이후 스텝이 죽은 트랜잭션에 붙음)
+    def _finish(ctx, parent):
+        try:
+            end_interceptor(ctx=ctx)
+            if ctx:
+                TraceContextManager.end(ctx.id)
+        finally:
+            if parent:
+                TraceContextManager.setLocalContext(parent)
+            else:
+                TraceContextManager.clearLocalContext()
+
+    # 감싼 함수의 예외는 기록만 하고 반드시 다시 던진다. 과거엔 예외를 삼키고 None 을
+    # 반환해, 호출자가 예외로 에러를 판별하는 코드(예: ASGI 핸들러가 500 을 내보내는 경로)
+    # 를 망가뜨렸다(200 + null 응답). 계측 기록 자체가 실패해도 원본 예외를 가리지 않도록
+    # 기록부는 감싼다. finally 에서 return 하면 예외가 억제되므로 정리만 한다.
+    def _record_error(ctx, e, args, kwargs):
+        try:
+            interceptor_step_error(e, ctx=ctx)
+            if ctx:
+                interceptor_error_log(ctx.id, e, fn, args, kwargs)
+            logging.debug('WHATAP(@method_profiling): ' + str(e),
+                          extra={'id': 'WA776'}, exc_info=True)
+        except Exception:
+            pass
+
+    if inspect.iscoroutinefunction(fn):
+        @functools.wraps(fn)
+        async def trace(*args, **kwargs):
+            parent = TraceContextManager.getLocalContext()
+            ctx = TraceContext()
+            try:
+                ctx.service_name = name
+                start_interceptor(ctx)
+                return await fn(*args, **kwargs)
+            except Exception as e:
+                _record_error(ctx, e, args, kwargs)
+                raise
+            finally:
+                _finish(ctx, parent)
+
+        return trace
+
+    @functools.wraps(fn)
+    def trace(*args, **kwargs):
+        parent = TraceContextManager.getLocalContext()
+        ctx = TraceContext()
+        try:
+            ctx.service_name = name
+            start_interceptor(ctx)
+            return fn(*args, **kwargs)
+        except Exception as e:
+            _record_error(ctx, e, args, kwargs)
+            raise
+        finally:
+            _finish(ctx, parent)
+
+    return trace
+
+
 def method_profiling(fn):
+    # NOTE: 의도적으로 _service_trace 를 쓰지 않는다. 이 데코레이터는 이미 배포된
+    # 공개 API 라, 예외 재전파/컨텍스트 정리/async 지원으로 바꾸면 기존 사용자의
+    # 동작이 달라진다. 해당 수정은 dev 에 있고 정식 머지 때 함께 들어온다.
     def trace(*args, **kwargs):
         callback = None
         try:
@@ -689,10 +792,10 @@ def method_profiling(fn):
             ctx = TraceContextManager.getLocalContext()
             end_interceptor(ctx=ctx)
             return callback
-    
+
     if not os.environ.get('whatap.enabled'):
         agent()
-    
+
     return trace
 
 

whatap_python-2.1.3rc1/whatap/build.py

@@ -0,0 +1,4 @@
+app = 'Python'
+name = 'whatap-python'
+version = '2.1.3rc1'
+release_date = '20260805'

{whatap_python-2.1.2 → whatap_python-2.1.3rc1}/whatap/conf/configuration.py

@@ -37,6 +37,10 @@ Configuration = {
     "profile_http_parameter_enabled": False,
     "profile_sql_param_enabled": False,
     "hook_method_patterns": "",
+    # 트랜잭션(서비스) 진입점으로 자동 래핑할 메서드 패턴 (module:Class.method, 콤마 구분).
+    # 해당 메서드 호출이 하나의 트랜잭션이 된다(= @method_profiling 의 conf 버전).
+    # 프레임워크 자동계측이 안 되는 진입점용. hook_service_patterns 모듈 참조.
+    "hook_service_patterns": "",
 
     "mtrace_rate": 10,
     "mtrace_spec": '',

whatap_python-2.1.3rc1/whatap/trace/mod/application/odoo.py

@@ -0,0 +1,77 @@
+import traceback
+from whatap import logging
+from whatap.trace.trace_handler import trace_handler
+from whatap.trace.trace_error import interceptor_error
+from whatap.trace.mod.application.wsgi import interceptor
+from whatap.trace.trace_context_manager import TraceContextManager
+
+
+def instrument(module):
+    # module is odoo.http (hooked as 'odoo.http' so that `root`/`HttpDispatcher`
+    # already exist when the hook fires; on Odoo 18+ `odoo.http` is no longer
+    # imported during `import odoo`, so hooking the top-level package fired too
+    # early and silently failed).
+    root = module.root
+    AppClass = root.__class__
+    original_call = AppClass.__call__
+
+    def wrapper(fn):
+        @trace_handler(fn, True)
+        def trace(self, environ, start_response):
+            def custom_start_response(status, headers, exc_info=None):
+                ctx = TraceContextManager.getLocalContext()
+                try:
+                    ctx.status = int(status.split()[0])
+                except Exception as e:
+                    logging.warning('[ODOO] status parse failed: %s' % e, extra={'id': 'ODOO001'})
+                    ctx.status = 0
+                return start_response(status, headers, exc_info)
+            try:
+                callback = interceptor(fn, self, environ, custom_start_response)
+            except Exception as e:
+                interceptor_error(
+                    500 , #해당 status 값은 에러 처리용으로만 사용됩니다.
+                    [e.__class__.__name__, str(e)]
+                )
+                raise
+            return callback
+
+        return trace
+
+    AppClass.__call__ = wrapper(original_call)
+
+
+    """
+    HTTP 요청 경로의 예외 단일 처리 지점을 후킹한다.
+      - Odoo 16+   : HttpDispatcher.handle_error(self, exc)
+      - Odoo 14/15 : HttpRequest._handle_exception(self, exception)
+                     (dispatcher 구조 도입 이전이라 HttpDispatcher 가 없다.
+                      두 메서드 모두 시그니처가 (self, <exc>) 라 래퍼를 공유한다.)
+    실제 응답 status 는 custom_start_response 가 이후에 갱신하므로, 여기서 넘기는
+    500 은 interceptor_error 의 에러 기록 트리거 용도로만 사용된다.
+    """
+    def error_wrapper(fn):
+        @trace_handler(fn)
+        def trace(self, exception):
+            ctx = TraceContextManager.getLocalContext()
+            interceptor_error(
+                500,  # 해당 status 값은 에러 처리용으로만 사용됩니다.
+                [exception.__class__.__name__,
+                 str(exception)],
+                ctx=ctx
+            )
+
+            callback = fn(self, exception)
+            return callback
+
+        return trace
+
+    Dispatcher = getattr(module, 'HttpDispatcher', None)
+    if Dispatcher:
+        # Odoo 16+
+        Dispatcher.handle_error = error_wrapper(Dispatcher.handle_error)
+    else:
+        # Odoo 14/15
+        HttpRequest = getattr(module, 'HttpRequest', None)
+        if HttpRequest and hasattr(HttpRequest, '_handle_exception'):
+            HttpRequest._handle_exception = error_wrapper(HttpRequest._handle_exception)

whatap_python-2.1.3rc1/whatap/trace/mod/hook_service_patterns.py

@@ -0,0 +1,72 @@
+"""conf ``hook_service_patterns`` — 지정 메서드를 트랜잭션(서비스) 진입점으로 자동 래핑.
+
+whatap.conf 예:
+
+    hook_service_patterns=myapp.infer:RunwayModel.predict, myapp.jobs:run_batch
+
+각 패턴 ``module:Class.method`` / ``module:func`` / ``module:Class.*`` / ``module:*.*``
+의 메서드를 import 시점에 ``@method_profiling`` 과 동일하게 감싼다. 그 메서드 호출이
+곧 하나의 트랜잭션(TX_START~TX_END)이 된다. raw ASGI·커스텀 워커처럼 프레임워크
+자동계측이 안 되는 진입점을 **소스 수정 없이** 트랜잭션으로 잡는 선언적 경로.
+
+계열 비교 (모두 동일한 import-hook 플러밍, 래퍼만 다름):
+  - hook_method_patterns   → 메서드를 기존 트랜잭션 안의 **스텝**(TX_METHOD) 으로
+  - workflow_method_patterns → 메서드를 LLM **워크플로우** 경계로
+  - hook_service_patterns  → 메서드를 **트랜잭션** 진입점으로  (이 모듈)
+
+대상 모듈이 PLUGIN 에 class_defs 를 등록하면 ImportFinder 가 그 목록을 패키징해
+넘겨준다 (trace_import.load_module).
+"""
+import inspect
+
+from whatap.trace import get_dict
+from whatap import logging
+
+
+def instrument_service(module_dict):
+    """module_dict = {'module': <module>, 'class_defs': [<class.method ...>]}."""
+    # 트랜잭션 래핑 코어(@method_profiling 과 공용). 예외 재전파 + 컨텍스트 정리 포함.
+    from whatap import _service_trace
+
+    try:
+        module = module_dict['module']
+        for class_def in module_dict['class_defs']:
+            parts = class_def.split('.')
+
+            # 대상 클래스/모듈 목록 + 타깃 메서드명 해석 (instrument_plugin 과 동일 규칙).
+            if len(parts) == 2:
+                if parts[0] == '*':
+                    m_list = [
+                        getattr(module, attr) for attr in dir(module)
+                        if not attr.startswith('__')
+                        and inspect.isclass(getattr(module, attr))
+                        and getattr(getattr(module, attr), '__module__', None) == module.__name__
+                    ]
+                else:
+                    m_list = [getattr(module, parts[0])]
+                target = parts[1]
+            else:
+                m_list = [module]
+                target = parts[0]
+
+            for m in m_list:
+                if target == '*':
+                    t_list = [
+                        attr for attr in dir(m)
+                        if not attr.startswith('__')
+                        and hasattr(m, attr)
+                        and inspect.isfunction(getattr(m, attr))
+                    ]
+                else:
+                    t_list = [target]
+
+                for t in t_list:
+                    if not hasattr(m, t):
+                        continue
+                    wrapped = _service_trace(getattr(m, t))
+                    try:
+                        setattr(m, t, wrapped)
+                    except Exception:
+                        get_dict(m)[t] = wrapped
+    except Exception as e:
+        logging.debug(e, extra={'id': 'hook_service_patterns ERROR'})

{whatap_python-2.1.2 → whatap_python-2.1.3rc1}/whatap/trace/trace_context_manager.py

@@ -177,6 +177,17 @@ class TraceContextManager(object):
         cls.local.context = None
         cls.entry.remove(key)
 
+    @classmethod
+    def clearLocalContext(cls):
+        """현재 로컬 컨텍스트를 비운다 — threading.local + contextvars 양쪽.
+
+        복원할 부모가 없는 **루트 트랜잭션 종료**용. ``setLocalContext(None)`` 은 None 에
+        thread 속성을 세팅하다 터지고, ``end()`` 는 contextvars(py3.7+ getLocalContext 가
+        우선 참조) 를 비우지 않아 컨텍스트가 누수된다. 둘 다 안전하게 None 으로 만든다."""
+        if contextvars:
+            cls.whatap_coroutine_context.set(None)
+        cls.local.context = None
+
     @classmethod
     def getTxProfile(cls, n):
         ctx = cls.getLocalContext()

{whatap_python-2.1.2 → whatap_python-2.1.3rc1}/whatap/trace/trace_import.py

@@ -24,7 +24,11 @@ def load_module(module, fullname):
                 __import__(wfullname)
                 wmodule = sys.modules.get(wfullname)
 
-            if wfullname.endswith('plugin'):
+            # 대상 모듈이 PLUGIN 에 class_defs 를 등록했으면(hook_method_patterns /
+            # workflow_method_patterns / hook_service_patterns 계열) 패턴 목록을 함께
+            # 넘긴다. 과거엔 인스트루먼트 모듈명이 'plugin' 으로 끝나는지로 판별했으나,
+            # 파일명 규칙과 디커플하기 위해 PLUGIN 등록 여부로 판별한다.
+            if fullname in PLUGIN:
                 module = {'module': module, 'class_defs': PLUGIN[fullname]}
 
             getattr(wmodule,

{whatap_python-2.1.2 → whatap_python-2.1.3rc1}/whatap/trace/trace_module_definition.py

@@ -151,6 +151,6 @@ DEFINITION = {
         ('frappe.app', 'instrument'),
     ],
     'application.odoo': [
-        ('odoo', 'instrument'),
+        ('odoo.http', 'instrument'),
     ],
 }

{whatap_python-2.1.2 → whatap_python-2.1.3rc1}/whatap_python.egg-info/PKG-INFO

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

{whatap_python-2.1.2 → whatap_python-2.1.3rc1}/whatap_python.egg-info/SOURCES.txt

@@ -130,6 +130,7 @@ whatap/trace/trace_handler.py
 whatap/trace/trace_import.py
 whatap/trace/trace_module_definition.py
 whatap/trace/mod/__init__.py
+whatap/trace/mod/hook_service_patterns.py
 whatap/trace/mod/logging.py
 whatap/trace/mod/plugin.py
 whatap/trace/mod/amqp/__init__.py

whatap_python-2.1.2/whatap/build.py

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

whatap_python-2.1.2/whatap/trace/mod/application/odoo.py

@@ -1,63 +0,0 @@
-import traceback
-from whatap import logging
-from whatap.trace.trace_handler import trace_handler
-from whatap.trace.trace_error import interceptor_error
-from whatap.trace.mod.application.wsgi import interceptor
-from whatap.trace.trace_context_manager import TraceContextManager
-
-
-def instrument(module):
-    root = module.http.root
-    AppClass = root.__class__
-    original_call = AppClass.__call__
-
-    def wrapper(fn):
-        @trace_handler(fn, True)
-        def trace(self, environ, start_response):
-            def custom_start_response(status, headers, exc_info=None):
-                ctx = TraceContextManager.getLocalContext()
-                try:
-                    ctx.status = int(status.split()[0])
-                except Exception as e:
-                    logging.warning('[ODOO] status parse failed: %s' % e, extra={'id': 'ODOO001'})
-                    ctx.status = 0
-                return start_response(status, headers, exc_info)
-            try:
-                callback = interceptor(fn, self, environ, custom_start_response)
-            except Exception as e:
-                interceptor_error(
-                    500 , #해당 status 값은 에러 처리용으로만 사용됩니다.
-                    [e.__class__.__name__, str(e)]
-                )
-                raise
-            return callback
-
-        return trace
-
-    AppClass.__call__ = wrapper(original_call)
-
-
-    """ 
-    Odoo 16+ HttpDispatcher.handle_error 패치
-    """
-    Dispatcher = getattr(module.http, 'HttpDispatcher', None)
-
-    if Dispatcher:
-        original_handle_error = Dispatcher.handle_error
-
-        def wrapper(fn):
-            @trace_handler(fn)
-            def trace(self,exception):
-                ctx = TraceContextManager.getLocalContext()
-                interceptor_error(
-                    500,  # 해당 status 값은 에러 처리용으로만 사용됩니다.
-                    [exception.__class__.__name__,
-                     str(exception)],
-                    ctx=ctx
-                )
-
-                callback = fn(self, exception)
-                return callback
-
-            return trace
-        Dispatcher.handle_error = wrapper(Dispatcher.handle_error)