whatap-python 2.0.2rc1__tar.gz → 2.0.3rc1__tar.gz

{whatap_python-2.0.2rc1 → whatap_python-2.0.3rc1}/PKG-INFO

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

{whatap_python-2.0.2rc1 → whatap_python-2.0.3rc1}/whatap/__init__.py

@@ -301,9 +301,45 @@ from whatap.trace.trace_module_definition import DEFINITION, IMPORT_HOOKS, \
     PLUGIN
 
 
+def _build_ignore_instrumentation_set():
+    """whatap.conf 의 ignore_instrumentation_set 값을 정규화하여 반환.
+    Configure.load() 가 _set 접미사 키를 콤마 split 해 list 로 만들지만,
+    환경변수/직접 setProperty 등 다른 경로로 들어온 경우(str)도 함께 처리한다.
+    """
+    raw = getattr(conf, 'ignore_instrumentation_set', None) or []
+    if isinstance(raw, str):
+        raw = raw.split(',')
+    return {str(item).strip().lower() for item in raw if item and str(item).strip()}
+
+
+def _is_instrumentation_ignored(definition_key, ignore_set):
+    """DEFINITION 키(예: 'database.redis', 'logging')가 무시 대상인지 판정.
+
+    매칭 규칙(셋 중 하나라도 맞으면 True):
+      1) 키 전체가 일치        예: 'database.redis' == 'database.redis'
+      2) 카테고리(점 앞)와 일치  예: 'database'        → 'database.*' 모두
+      3) 라이브러리(점 뒤)와 일치 예: 'redis'           → 'database.redis'
+    """
+    if not ignore_set:
+        return False
+    key_lower = definition_key.lower()
+    if key_lower in ignore_set:
+        return True
+    if '.' in key_lower:
+        category, lib = key_lower.split('.', 1)
+        if category in ignore_set or lib in ignore_set:
+            return True
+    return False
+
+
 def hooks(home):
+    ignore_set = _build_ignore_instrumentation_set()
+    skipped_keys = []
     try:
         for key, value_list in DEFINITION.items():
+            if _is_instrumentation_ignored(key, ignore_set):
+                skipped_keys.append(key)
+                continue
             for value in value_list:
                 if len(value) >= 3 and isinstance(value[2], str):
                     module_path = value[2]
@@ -318,7 +354,14 @@ def hooks(home):
         logging.debug(e, extra={'id': 'MODULE ERROR'})
     finally:
         try:
-            if conf.trace_logging_enabled:
+            if skipped_keys:
+                logging.debug(
+                    'WHATAP: ignore_instrumentation_set skipped: {}'.format(
+                        ','.join(skipped_keys)),
+                    extra={'id': 'WA_IGN'})
+
+            if conf.trace_logging_enabled and not _is_instrumentation_ignored(
+                    'logging', ignore_set):
                 logging_module = sys.modules.get("logging")
                 from whatap.trace.mod.logging import instrument_logging
                 instrument_logging(logging_module)
@@ -535,12 +578,47 @@ def go(batch=False, opts={}, llm=False):
         label = 'LLM golang module' if llm else 'golang module'
 
         if sys.platform == 'win32':
-            DETACHED_PROCESS = 0x00000008
+            # SESSIONNAME 환경변수는 NSSM이 부모 세션에서 상속받아 부정확함
+            # ProcessIdToSessionId로 실제 프로세스 세션 ID 확인
+            try:
+                import ctypes
+                _sid = ctypes.c_ulong(0)
+                ctypes.windll.kernel32.ProcessIdToSessionId(
+                    ctypes.windll.kernel32.GetCurrentProcessId(),
+                    ctypes.byref(_sid)
+                )
+                is_session0 = (_sid.value == 0)
+            except Exception:
+                is_session0 = not os.environ.get('SESSIONNAME')
+
             cmd_args.append('foreground')
-            process = subprocess.Popen(cmd_args,
-                                       cwd=home_path, env=newenv,
-                                       creationflags=DETACHED_PROCESS,
-                                       stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+            if is_session0:
+                # Session 0에서만 WHATAP_FOREGROUND=1 추가 주입.
+                # IsAnInteractiveSession()이 false로 떨어지는 경로에서
+                # foreground CLI 인자를 보강하는 안전망.
+                newenv['WHATAP_FOREGROUND'] = '1'
+
+                # Session 0에서는 PIPE를 읽지 않으면 버퍼 고갈로 Go 프로세스가 블로킹됨
+                # 로그 파일로 리디렉션
+                # CREATE_NO_WINDOW: Session 0 서비스 컨텍스트에 적합한 플래그
+                CREATE_NO_WINDOW = 0x08000000
+                log_dir = os.path.join(home_path, 'logs')
+                go_log_path = os.path.join(log_dir, AGENT_NAME + '.log')
+                try:
+                    go_out = open(go_log_path, 'ab')
+                except Exception:
+                    go_out = subprocess.DEVNULL
+                process = subprocess.Popen(cmd_args,
+                                           cwd=home_path, env=newenv,
+                                           creationflags=CREATE_NO_WINDOW,
+                                           stdout=go_out, stderr=go_out)
+            else:
+                DETACHED_PROCESS = 0x00000008
+                process = subprocess.Popen(cmd_args,
+                                           cwd=home_path, env=newenv,
+                                           creationflags=DETACHED_PROCESS,
+                                           stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         else:
             process = subprocess.Popen(cmd_args,
                                        cwd=home_path, env=newenv,
@@ -549,8 +627,11 @@ def go(batch=False, opts={}, llm=False):
 
         time.sleep(0.5)
         if process.poll() is not None:
-            stdouts, errs = process.communicate()
-            whatap_print("executed {} ".format(label), str(stdouts,"utf8"), str(errs, "utf8"))
+            if sys.platform == 'win32' and is_session0:
+                whatap_print("executed {} (exit code: {}, log: {})".format(label, process.returncode, go_log_path))
+            else:
+                stdouts, errs = process.communicate()
+                whatap_print("executed {} ".format(label), str(stdouts,"utf8"), str(errs, "utf8"))
         else:
             write_file(home, file_name, str(process.pid))
             whatap_print("executed {} in background (PID: {})".format(label, process.pid))

whatap_python-2.0.3rc1/whatap/build.py

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

{whatap_python-2.0.2rc1 → whatap_python-2.0.3rc1}/whatap/conf/configuration.py

@@ -19,6 +19,13 @@ Configuration = {
     "trace_ignore_url_prefix": None,
     "trace_websocket_enabled": False,
 
+    # 자동 계측에서 제외할 라이브러리 목록(콤마 구분).
+    #   - DEFINITION 키 전체:   database.redis, llm.openai
+    #   - 카테고리만:          database  (database.* 전부 스킵)
+    #   - 라이브러리 이름만:    redis, openai, django  (해당 키만 스킵)
+    # 예: ignore_instrumentation_set=redis,openai,application.django
+    "ignore_instrumentation_set": [],
+
     "llm_api_hosts": "",
 
     "debug": False,

{whatap_python-2.0.2rc1 → whatap_python-2.0.3rc1}/whatap/counter/tasks/llm_log_sink_task.py

@@ -82,6 +82,8 @@ class LlmLogSinkTask(object):
 
         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'})
 

{whatap_python-2.0.2rc1 → whatap_python-2.0.3rc1}/whatap/net/async_sender.py

@@ -12,6 +12,9 @@ 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,
@@ -48,13 +51,25 @@ def send_llm_relaypack( packbytes):
         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:
-            packet_env = q.get()
+            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:
-                time.sleep(0.1)
                 continue
             sendType,params = packet_env
             if sendType == SendType.DATAS:
@@ -66,6 +81,8 @@ def startWhatapThread():
             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()

{whatap_python-2.0.2rc1 → whatap_python-2.0.3rc1}/whatap/net/udp_session.py

@@ -28,7 +28,9 @@ class UdpSession(object):
     s = None
     llm_s = None
     buffer_arr = []
+    llm_buffer_arr = []
     thread_lock = threading.Lock()
+    llm_thread_lock = threading.Lock()
     socket_lock = threading.Lock()
     read_timeout = 5
 
@@ -344,7 +346,8 @@ class UdpSession(object):
 
     @classmethod
     def send_llm_relaypack(cls, packbytes):
-        """LLM 데이터를 LLM Go Agent 소켓으로만 직접 전송. APM 소켓으로는 보내지 않음."""
+        """LLM 데이터를 LLM Go Agent 소켓으로 버퍼링 후 전송. 48KB 누적 시 자동 flush.
+        명시적 flush는 flush_llm_buffer()를 사용한다."""
         if not packbytes:
             return
         if not cls.llm_s:
@@ -358,7 +361,33 @@ class UdpSession(object):
             dout.writeByte(PacketTypeEnum.RELAY_PACK)
             dout.writeInt(PacketEnum.PACKET_VERSION)
             dout.writeIntBytes(packbytes)
-            cls.llm_s.send(dout.toByteArray())
+            entry = dout.toByteArray()
+
+            with cls.llm_thread_lock:
+                current_size = sum(len(x) for x in cls.llm_buffer_arr)
+                if cls.llm_buffer_arr and current_size + len(entry) > PacketEnum.PACKET_BUFFER_SIZE:
+                    cls._flush_llm_buffer_locked()
+                cls.llm_buffer_arr.append(entry)
+        except Exception as e:
+            logging.debug(e, extra={'id': 'WA921'}, exc_info=True)
+
+    @classmethod
+    def flush_llm_buffer(cls):
+        """LLM 버퍼에 남아있는 데이터를 즉시 전송한다. idle/트랜잭션 경계에서 호출."""
+        if not cls.llm_s:
+            return
+        with cls.llm_thread_lock:
+            cls._flush_llm_buffer_locked()
+
+    @classmethod
+    def _flush_llm_buffer_locked(cls):
+        """llm_thread_lock을 이미 보유한 상태에서 호출되어야 한다."""
+        if not cls.llm_buffer_arr:
+            return
+        sendbuf = b''.join(cls.llm_buffer_arr)
+        cls.llm_buffer_arr = []
+        try:
+            cls.llm_s.send(sendbuf)
         except ConnectionRefusedError:
             cls.udp_llm()
         except Exception as e:

whatap_python-2.0.3rc1/whatap/trace/mod/application/fastapi/__init__.py

@@ -0,0 +1,31 @@
+"""FastAPI / Starlette ASGI 계측 패키지.
+
+외부 공개 심볼 — 변경 금지:
+  - instrument_applications  (trace_module_definition.py)
+  - instrument               (trace_module_definition.py)
+  - instrument_util          (trace_module_definition.py)
+  - interceptor_error_log    (whatap/__init__.py)
+
+모듈 구성:
+  scope            scope/headers 파싱 + ctx 주입 (parse_headers, client_ip,
+                   resolve_user_id, populate_ctx)
+  transaction      TX 라이프사이클 (is_ignored, begin, finish)
+  endpoint         route template · 쿠키 · SSE 래핑 (upgrade_service_name,
+                   write_whatap_cookie, wrap_streaming_response)
+  exception_log    interceptor_error_log
+  instrumentation  훅 엔트리 3 개 (instrument_applications / instrument /
+                   instrument_util)
+"""
+from whatap.trace.mod.application.fastapi.exception_log import interceptor_error_log
+from whatap.trace.mod.application.fastapi.instrumentation import (
+    instrument,
+    instrument_applications,
+    instrument_util,
+)
+
+__all__ = [
+    'instrument_applications',
+    'instrument',
+    'instrument_util',
+    'interceptor_error_log',
+]

whatap_python-2.0.3rc1/whatap/trace/mod/application/fastapi/endpoint.py

@@ -0,0 +1,73 @@
+"""엔드포인트 도달 시에만 유효한 메타 / 응답 보강.
+
+TX 라이프사이클에는 관여하지 않는다 (transaction.py 전담).
+"""
+import logging as logging_module
+import sys
+
+from whatap.conf.configure import Configure as conf
+from whatap.trace.trace_error import interceptor_step_error
+from whatap.util import bit_util
+from whatap.util.userid_util import UseridUtil
+
+logger = logging_module.getLogger(__name__)
+
+
+def upgrade_service_name(ctx, dependant):
+    """raw path(/items/42) → route template(/items/{item_id})."""
+    if dependant is None:
+        return
+    path = getattr(dependant, 'path', None)
+    if path:
+        ctx.service_name = path
+
+
+def write_whatap_cookie(environ, response, raw_user_id):
+    """응답 객체에 WhaTap userid 쿠키 기록. 조건 미충족 시 no-op."""
+    if response is None or not raw_user_id:
+        return
+    if not conf.trace_user_enabled or conf.trace_user_using_ip:
+        return
+    if conf.user_header_ticket:
+        return
+
+    cookie = environ.get('cookie') if environ else None
+    if (cookie
+            and cookie.find(UseridUtil.WHATAP_R) >= 0
+            and cookie.find(raw_user_id) >= 0):
+        return
+
+    try:
+        response.set_cookie(
+            key=UseridUtil.WHATAP_R,
+            value=raw_user_id,
+            max_age=bit_util.INT_MAX_VALUE,
+            path='/',
+            domain=conf.trace_user_cookie_domain,
+        )
+    except Exception:
+        _, exc, _ = sys.exc_info()
+        logger.debug('A503', 10, str(exc))
+
+
+def wrap_streaming_response(callback):
+    """StreamingResponse body_iterator 에 step-error 포착 래퍼 장착."""
+    try:
+        from fastapi.responses import StreamingResponse
+    except ImportError:
+        return callback
+    if not isinstance(callback, StreamingResponse):
+        return callback
+
+    original = callback.body_iterator
+
+    async def _traced():
+        try:
+            async for chunk in original:
+                yield chunk
+        except Exception as exc:
+            interceptor_step_error(exc)
+            raise
+
+    callback.body_iterator = _traced()
+    return callback

whatap_python-2.0.3rc1/whatap/trace/mod/application/fastapi/exception_log.py

@@ -0,0 +1,63 @@
+"""엔드포인트 실행 중 발생한 unhandled exception 을 LogSink 로 전송.
+
+외부(whatap/__init__.py)가 `interceptor_error_log` 이름으로 직접 import 하므로
+함수명 · 시그니처 변경 금지.
+"""
+import inspect
+import linecache
+import sys
+import traceback
+
+from whatap.conf.configure import Configure as conf
+import whatap.io as whatapio
+import whatap.net.async_sender as async_sender
+import whatap.pack.logSinkPack as logSinkPack
+from whatap.util.date_util import DateUtil
+
+
+def interceptor_error_log(trxid, e, fn, args, kwargs):
+    if conf.log_unhandled_exception == 'false':
+        return
+
+    error_class = ''
+    if e.args:
+        error_class = str(e.args[0])
+    elif hasattr(e, 'detail'):
+        error_class = getattr(e, 'detail')
+
+    _, _, tb = sys.exc_info()
+    last_filename = last_lineno = last_globals = None
+    for frame, lineno in traceback.walk_tb(tb):
+        last_filename = frame.f_code.co_filename
+        last_lineno = lineno
+        last_globals = frame.f_globals
+
+    fields = {
+        'errorClass': error_class,
+        'args': str(inspect.getcallargs(fn, *args, **kwargs)),
+    }
+    content = ''
+    if last_filename and last_lineno:
+        fields['filename'] = last_filename
+        fields['lineno'] = last_lineno
+        linecache.checkcache(last_filename)
+        for i, line in enumerate(linecache.getlines(last_filename, last_globals)):
+            if i == last_lineno - 1 and len(line.lstrip()) > 2:
+                indent = len(line) - len(line.lstrip())
+                content += ''.join(['-' * (indent - 1) + '>', line.lstrip()])
+            else:
+                content += line
+
+    pack = logSinkPack.getLogSinkPack(
+        t=DateUtil.now(),
+        category='UnhandledException',
+        tags={'@txid': trxid},
+        fields=fields,
+        line=DateUtil.now(),
+        content=content,
+    )
+    pack.pcode = conf.PCODE
+
+    buf = whatapio.DataOutputX()
+    buf.writePack(pack, None)
+    async_sender.send_relaypack(buf.toByteArray())

whatap_python-2.0.3rc1/whatap/trace/mod/application/fastapi/instrumentation.py

@@ -0,0 +1,204 @@
+"""FastAPI 훅 엔트리포인트 — 3 개 모듈 함수.
+
+  - instrument_applications : fastapi.applications.FastAPI.__call__
+      ASGI 진입점. scope 파싱 → ctx 주입 → begin → wrapped_send → finish.
+      미들웨어 early-return / 404 / 405 / CORS preflight 등 엔드포인트
+      미도달 응답도 이 지점에서 캡처된다.
+  - instrument              : fastapi.routing.run_endpoint_function
+      엔드포인트 도달 시 route template / setUserId 쿠키 / SSE body wrap /
+      unhandled exception 로깅. TX 라이프사이클에는 관여하지 않는다.
+  - instrument_util         : fastapi.dependencies.utils.solve_dependencies
+      엔드포인트에서 쓰기 위한 request / response 를 dependant 에
+      `__whatap__` dict 로 부착.
+"""
+from copy import copy
+
+from whatap.trace.mod.application.fastapi import endpoint, scope, transaction
+from whatap.trace.mod.application.fastapi.exception_log import interceptor_error_log
+from whatap.trace.trace_context import TraceContext, TraceContextManager
+from whatap.trace.trace_error import interceptor_step_error
+from whatap.trace.trace_handler import async_trace_handler, trace_handler
+
+_WHATAP_DICT = '__whatap__'
+_DEPENDANT = 'dependant'
+_REQUEST = 'request'
+_RESPONSE = 'response'
+_REMOTE_ADDR = 'remoteAddr'
+
+
+# ── FastAPI.__call__ : TX 생명주기 전담 ────────────────────────
+
+def instrument_applications(module):
+    def wrapper(fn):
+        async def trace(instance, asgi_scope, receive, send):
+            if asgi_scope.get('type') != 'http':
+                await fn(instance, asgi_scope, receive, send)
+                return
+
+            headers = scope.parse_headers(asgi_scope)
+            ctx = TraceContext()
+            scope.populate_ctx(ctx, asgi_scope, headers)
+
+            if transaction.is_ignored(ctx.service_name):
+                ctx.is_ignored = True
+                try:
+                    await fn(instance, asgi_scope, receive, send)
+                finally:
+                    TraceContextManager.end(ctx.id)
+                return
+
+            transaction.begin(ctx)
+
+            status_holder = [0]
+            original_send = send
+
+            async def wrapped_send(message):
+                if message and message.get('type') == 'http.response.start':
+                    try:
+                        status_holder[0] = int(message.get('status') or 0)
+                    except (TypeError, ValueError):
+                        pass
+                await original_send(message)
+
+            try:
+                await fn(instance, asgi_scope, receive, wrapped_send)
+            except Exception as exc:
+                # 하위(endpoint wrapper)에서 이미 step_error 를 발사했으면
+                # ctx.error == 1. TX_ERROR 중복 방지를 위해 여기서는 스킵.
+                if not ctx.error:
+                    interceptor_step_error(exc)
+                raise
+            finally:
+                try:
+                    transaction.finish(ctx, asgi_scope, headers, status_holder[0])
+                finally:
+                    TraceContextManager.end(ctx.id)
+
+        return trace
+
+    module.FastAPI.__call__ = wrapper(module.FastAPI.__call__)
+
+
+# ── run_endpoint_function : endpoint 메타 보강만 ──────────────
+
+def instrument(module):
+    def wrapper(fn):
+        @trace_handler(fn, True)
+        def trace(*args, **kwargs):
+            dependant = kwargs[_DEPENDANT] = copy(kwargs[_DEPENDANT])
+            if kwargs.get('is_coroutine'):
+                dependant.call = _wrap_async_endpoint(dependant.call, dependant)
+            else:
+                dependant.call = _wrap_sync_endpoint(dependant.call, dependant)
+            return fn(*args, **kwargs)
+
+        return trace
+
+    if hasattr(module, 'run_endpoint_function'):
+        module.run_endpoint_function = wrapper(module.run_endpoint_function)
+
+
+def _wrap_sync_endpoint(fn, dependant):
+    @trace_handler(fn, True)
+    def trace(*args, **kwargs):
+        if not hasattr(dependant, _WHATAP_DICT):
+            return fn(*args, **kwargs)
+        whatap_dict = _pop_whatap_dict(dependant)
+        ctx = TraceContextManager.getLocalContext()
+        try:
+            _pre_endpoint(ctx, dependant, whatap_dict)
+            callback = fn(*args, **kwargs)
+            return _post_endpoint(ctx, whatap_dict, callback)
+        except Exception as exc:
+            interceptor_step_error(exc)
+            raise
+
+    return trace
+
+
+def _wrap_async_endpoint(fn, dependant):
+    @async_trace_handler(fn, True)
+    async def trace(*args, **kwargs):
+        if not hasattr(dependant, _WHATAP_DICT):
+            return await fn(*args, **kwargs)
+        whatap_dict = _pop_whatap_dict(dependant)
+        ctx = TraceContextManager.getLocalContext()
+        try:
+            _pre_endpoint(ctx, dependant, whatap_dict)
+            callback = await fn(*args, **kwargs)
+            return _post_endpoint(ctx, whatap_dict, callback)
+        except Exception as exc:
+            interceptor_step_error(exc)
+            if ctx is not None:
+                interceptor_error_log(ctx.id, exc, fn, args, kwargs)
+            raise
+
+    return trace
+
+
+def _pop_whatap_dict(dependant):
+    whatap_dict = getattr(dependant, _WHATAP_DICT)
+    try:
+        delattr(dependant, _WHATAP_DICT)
+    except Exception:
+        pass
+    return whatap_dict
+
+
+def _pre_endpoint(ctx, dependant, whatap_dict):
+    if ctx is None:
+        return
+    endpoint.upgrade_service_name(ctx, dependant)
+    if not ctx.remoteIp:
+        fb = whatap_dict.get(_REMOTE_ADDR)
+        if fb:
+            ctx.remoteIp = fb
+
+
+def _post_endpoint(ctx, whatap_dict, callback):
+    if ctx is None:
+        return callback
+    environ = whatap_dict.get('headers')
+    response = whatap_dict.get(_RESPONSE)
+    endpoint.write_whatap_cookie(
+        environ, response, getattr(ctx, '_rawuserid', ''),
+    )
+    return endpoint.wrap_streaming_response(callback)
+
+
+# ── solve_dependencies : whatap_dict 세팅 ─────────────────────
+
+def instrument_util(module):
+    def wrapper(fn):
+        async def trace(*args, **kwargs):
+            whatap_dict = None
+            if _DEPENDANT in kwargs:
+                whatap_dict = _attach_whatap_dict(kwargs)
+            ret = await fn(*args, **kwargs)
+            if whatap_dict is not None and hasattr(ret, '__len__') and len(ret) >= 4:
+                whatap_dict[_RESPONSE] = ret[3]
+            return ret
+
+        return trace
+
+    if hasattr(module, 'solve_dependencies'):
+        module.solve_dependencies = wrapper(module.solve_dependencies)
+
+
+def _attach_whatap_dict(kwargs):
+    dependant = kwargs[_DEPENDANT]
+    whatap_dict = {}
+    setattr(dependant, _WHATAP_DICT, whatap_dict)
+    request = kwargs.get(_REQUEST)
+    if request is not None:
+        if request.client is not None:
+            remote_addr = request.client.host
+        else:
+            remote_addr = request.headers.get('x-forwarded-for')
+        whatap_dict.update({
+            _REMOTE_ADDR: remote_addr,
+            'headers': copy(request.headers),
+            'cookies': copy(request.cookies),
+            'query_params': copy(request.query_params),
+        })
+    return whatap_dict