whatap-python 2.1.0__py3-none-any.whl

whatap/__main__.py

@@ -0,0 +1,4 @@
+from whatap import agent
+
+if __name__ == '__main__':
+    agent()

whatap/bootstrap/sitecustomize.py

@@ -0,0 +1,19 @@
+import sys, os
+
+try:
+    from whatap import agent
+    agent()
+except ModuleNotFoundError:
+    pythonpath = os.environ.get('PYTHONPATH')
+    if pythonpath and os.path.basename(pythonpath) == "bootstrap":
+        pythonpath,_ = os.path.split(pythonpath)
+        pythonpath,_ = os.path.split(pythonpath)
+        
+        sys.path.append(pythonpath)
+        try:
+            from whatap import agent
+            agent()
+        except ModuleNotFoundError:
+            #final fail
+            pass
+            

whatap/build.py

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

whatap/conf/configuration.py

@@ -0,0 +1,280 @@
+Configuration = {
+    "dev": False,
+    "whatap_code_start": False,
+    "ignore_whatap_stdout" : False,
+    "apm_enabled": False,
+    "llm_enabled": False,
+    "net_udp_port": "6600",
+    "force_net_udp_port": False,
+    "web_static_content_extensions": "js, htm, html, gif, png, jpg, css, swf, ico",
+
+    "trace_auto_normalize_enabled": True,
+    "trace_user_enabled": True,
+    "trace_user_using_ip": True,
+    "trace_logging_enabled": False,
+    "trace_logging_mtid_enabled": False,
+    "trace_loguru_enabled": False,
+    "trace_loguru_mtid_enabled": False,
+    "trace_ignore_url_set": [],
+    "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,
+    "query_string_enabled": False,
+    "query_string_urls": "",
+
+    "profile_dbc_close": False,
+    "profile_http_header_enabled": False,
+    "profile_http_parameter_enabled": False,
+    "profile_sql_param_enabled": False,
+    "hook_method_patterns": "",
+
+    "mtrace_rate": 10,
+    "mtrace_spec": '',
+    "mtrace_send_url_length": 80,
+
+    "_trace_mtrace_caller_key": "x-wtap-mst",
+    "_trace_mtrace_callee_key": "x-wtap-tx",
+    "_trace_mtrace_info_key": "x-wtap-sp1",
+    "_trace_mtrace_ip": "x-wtap-ip",
+    "_trace_mtrace_caller_poid_key": "x-wtap-po",
+
+    "stat_enabled": False,
+    "stat_domain_enabled": False,
+    "stat_domain_max_count": 7000,
+    "stat_mtrace_enabled": False,
+    "stat_mtrace_max_count": 7000,
+    "stat_login_enabled": False,
+    "stat_login_max_count": 7000,
+    "stat_referer_enabled": False,
+    "stat_referer_max_count": 7000,
+
+	"stat_tx_max_count": 5000,
+	"stat_sql_max_count": 5000,
+	"stat_httpc_max_count": 5000,
+	"stat_error_max_count": 1000,
+	"stat_useragent_max_count": 500,
+
+    "standalone_enabled" : False,
+    "standalone_type" : "single-transaction",
+    "standalone_transaction_patterns" : "",
+
+    "user_header_ticket_enabled": False,
+    "user_header_ticket":"",
+    "trace_user_cookie_limit":2048,
+    "trace_user_cookie_domain":"",
+    "profile_exception_stack": False,
+
+    # "whatap_server_host": "127.0.0.1/127.0.0.1",
+    # "whatap_server_port": 6600,
+    # "mode": "whatap_dev",
+    # "debug": False,
+    # "license": None,
+    # "counter_enabled": True,
+    # "stat_enabled": True,
+    # "active_stack_enabled": True,
+    # "trx_profile_enabled": True,
+    # "trx_profile_sql_enabled": True,
+    # "trx_profile_httpc_enabled": True,
+    # "trx_profile_max_time": 300000,
+    # "trx_profile_max_count": 10000,
+    # "prepared_sql_max": 5001,
+    # "debug_prepared_sql": False,
+    # "trace_service_name_header_key": None,
+    # "trace_service_name_key": None,
+    # "web_static_content_extensions": "js, htm, html, gif, png, jpg, css, txt",
+    # "trace_auto_service_enabled": False,
+    # "trace_auto_service_backstack_enabled": True,
+    # "trace_background_socket_enabled": True,
+    # "trace_activeserivce_yellow_time": 3000,
+    # "trace_activeservice_red_time": 8000,
+    # "trace_activeservice_hang_time": 6000,
+    # "trace_intertx_enabled": True,
+    # "trace_error_callstack_depth": 50,
+    # "trace_active_callstack_depth": 50,
+    # "_trace_intertx_caller_pcode_key": "x-wtap-pcode",
+    # "_trace_intertx_caller_oid_key": "x-wtap-oid",
+    # "_trace_intertx_caller_seq_key": "x-wtap-seq",
+    # "_trace_intertx_call_url_key": "x-wtap-url",
+    # "trace_httpc_normalize_urls": "",
+    # "trace_httpc_normalize_enabled": True,
+    # "trace_normalize_enabled": True,
+    # "log_ignore_set": None,
+    # "tcp_connection_timeout": 60000,
+    # "tcp_so_timeout": 60000,
+    # "net_send_max_bytes": 5 * 1024 * 1024,
+    # "net_send_queue1_size": 512,
+    # "net_send_queue2_size": 1024,
+    # "hook_connection_open_patterns": "",
+    # "log_datasource_lookup_enabled": True,
+    "throttle_enabled": False,
+    "throttle_blocking_url": '',
+    "throttle_blocking_ip": '',
+    "throttle_blocked_forward": '',
+    "throttle_blocked_message": 'request blocked!!',
+    "throttle_limit": None,
+    "throttle_target_urls": '',
+    "throttle_passing_url": '',
+    "throttle_passing_url_prefix": '',
+    "throttle_rejected_forward": '',
+    "throttle_rejected_message": "too many request!!",
+    "reject_event_enabled": False,
+    # "profile_http_querystring_enabled": False,
+    # "profile_http_header_enabled": False,
+    # "profile_http_parameter_enabled": False,
+    # "profile_http_parameter_url_prefix": "/",
+    # "profile_http_header_url_prefix": "/",
+    # "profile_connection_open_enabled": True,
+    # "profile_step_max_count": 1024,
+    # "hook_method_patterns": "",
+    # "hook_method_access_public_enabled": True,
+    # "hook_method_access_protected_enabled": True,
+    # "hook_method_access_private_enabled": False,
+    # "hook_method_access_none_enabled": True,
+    # "hook_method_ignore_prefixes": "get,set",
+    # "hook_method_ignore_classes": "",
+    # "profile_method_enabled": True,
+    # "hook_service_patterns": "",
+    # "hook_httpc_patterns": "",
+    # "hook_httpc_info_patterns": "",
+    # "hook_jdbc_pstmt_classes": "",
+    # "hook_jdbc_stmt_classes": "",
+    # "hook_jdbc_rs_classes": "",
+    # "hook_jdbc_wrapping_driver_patterns": "",
+    # "hook_context_classes": "javax/naming/InitialContext",
+    # "hook_jsp_patterns": "",
+    # "hook_trace_helper_start_patterns": "",
+    # "hook_trace_helper_end_patterns": "",
+    # "hook_dyna_ignore_count": 100,
+    #
+    # "profile_fullstack_max_lines": 0,
+    #
+    # "profile_step_normal_count": 800,
+    # "profile_step_heavy_count": 1000,
+    # "profile_step_max_count": 1024,
+    # "profile_step_heavy_time": 100,
+    #
+    # "boolean profile_sql_param_enabled": False,
+    # "profile_sql_resource_enabled": False,
+    # "profile_method_resource_enabled": False,
+    # "profile_httpc_resource_enabled": False,
+    # "_profile_prepare_sql": False,
+    # "profile_dbc_close": False,
+    #
+    "trace_http_client_ip_header_key": "",
+    # "trace_user_enabled": True,
+    # "trace_user_using_ip": False,
+    # "trace_user_using_type": 1,
+    # "trace_user_cookie_limit": 2048,
+    # "profile_error_jdbc_fetch_max": 10000,
+    # "profile_error_sql_time_max": 30000,
+    # "hook_direct_patch_classes": "",
+    # "_hook_serivce_enabled": True,
+    # "_hook_dbsql_enabled": True,
+    # "_hook_dbconn_enabled": True,
+    # "_hook_methods_enabled": True,
+    # "_hook_socket_enabled": True,
+    # "_hook_usertx_enabled": True,
+    # "log_rotation_enabled": True,
+    # "log_keep_days": 7,
+    # "thread_dump_enabled": False,
+    # "debug_cpu_enabled": False,
+    # "active_stack_always_do": False,
+    # "active_stack_callstack_interval_sec": 10,
+    # "realtime_interval_ms": 5000,
+    # "cipher_net_enabled": True,
+    # "cipher_level": 2,
+    # 'cypher_level': 128,
+    # "boot_redefine_size": 100,
+    # "counter_netstat_enabled": False,
+    # "counter_procfd_enabled": False,
+    # "counter_interval": 5000,
+    # "CONFIG_INITED": False,
+    # "_profile_position_httpc_hash": 0,
+    # "profile_position_httpc": "",
+    # "_profile_position_sql_hash": 0,
+    # "profile_position_sql": "",
+    # "_profile_position_method_hash": 0,
+    # "profile_position_method": "",
+    # "profile_position_depth": 50,
+    # "time_sync_interval_ms": 300000,
+    # "trace_active_transaction_yellow_time": 3000,
+    # "trace_active_transaction_red_time": 8000,
+    # "trace_active_transaction_hang_time": 30000,
+    # "realtime_user_thinktime_max": 300000,
+    # "service_port_enabled": False,
+    # 'log_pack_data': False,
+    # "active_stack_second": 10
+    "init_load_interval": 30000,
+    "session_read_timeout": 5000,
+    "reject_event_interval": 30000,
+    "master_agent_host" : "whatap-master-agent.whatap-monitoring.svc.cluster.local",
+    "master_agent_port" : 6600,
+    "unix_socket_enabled":False,
+    "unix_socket":"whatap.sock",
+    "debug_stack_enabled": False,
+    "log_unhandled_exception": 'false',
+    "threadstack_faulthandler": False,
+    "max_send_queue_size": 1000,
+    "open_file_descriptor_enabled": False,
+    "open_file_descriptor_interval":60,
+    "counter_thread_enabled": False,
+    "llm_net_udp_port": 6700,
+    "force_llm_net_udp_port": False,
+    "llm_model_pricing": "",
+    "llm_perf_sketch_enabled": True,
+    "llm_perf_sketch_k": 200,
+
+    # ── LLM Evaluation ──
+    # 평가 파이프라인 마스터 토글. false면 enqueue/worker가 동작하지 않음.
+    "llm_eval_enabled": False,
+    # judge LLM 호출 평가자의 샘플링 비율 (0.0 ~ 1.0).
+    #   1.0 (기본) — 모든 judge 평가자 항상 실행
+    #   0.1       — judge 평가자 10% 만 실행 (비용 1/10)
+    #   0.0       — judge 평가자 전부 skip
+    # 규칙 기반 평가자 (PIILeak / URLScan 등 USES_LLM_JUDGE=False) 는 영향 X.
+    # 결정론적 샘플링 — 같은 txid 는 항상 같은 결정.
+    "llm_eval_sample_rate": 1.0,
+    # 평가 큐 최대 크기. 초과 시 drop + LLM030 경고.
+    "llm_eval_buffer_limit": 1000,
+    # 평가자 실행에 쓸 ThreadPoolExecutor worker 수.
+    "llm_eval_workers": 4,
+    # judge LLM 1회 호출의 최대 대기 시간 (초). 초과 시 TimeoutError → judge_error
+    # 로 graceful degrade. user app 의 event loop 가 hang/backpressure 일 때
+    # 평가 워커가 무기한 블록되는 것을 차단. 0 또는 음수면 무제한 (legacy 동작).
+    "llm_eval_judge_timeout_sec": 30,
+    # judge LLM 호출도 기존 인스트루멘테이션 (intercept) 으로 추적할지 여부.
+    # False (기본): judge 호출은 intercept 우회 → 메트릭/logsink 에 안 잡힘.
+    #               (eval 결과 점수만 LlmStepEvalStatus + llm_eval_stat 로 송출)
+    # True       : judge 호출이 llm_step_status pack + 메트릭에 잡힘 (사용자 호출과 동일).
+    #               cost/token/latency 가시화. 메트릭 카운트 2배 증가 가능 (user + judge).
+    "llm_eval_track_judge_calls": False,
+    # 활성 평가자 csv. 미지정 (빈 값) 이면 default 3 종 자동 활성:
+    #   combined_judge, pii_leak, url_scan
+    # 개별 aspect evaluator (hallucination / answer_relevance / toxicity /
+    # prompt_injection / factuality) 는 combined_judge 가 1회 judge 호출로 이미
+    # 모두 산출하므로 default 에서 제외 — 명시 활성 시에만 별도 evaluator 가 추가
+    # judge 호출을 발생시킴.
+    #
+    # 가용 라벨 (각 라벨이 evaluator 1개 + 동명 stat 카테고리에 매핑):
+    #   combined_judge   — 1번의 LLM judge 호출로 5 의미 aspect 동시 평가
+    #                      (hallucination / answer_relevance / toxicity /
+    #                       prompt_injection / factuality)
+    #   pii_leak         — 정규식 + Luhn 으로 PII 노출 탐지 (LLM 호출 X)
+    #   url_scan         — URL 추출 + suspicious 패턴 매칭 (LLM 호출 X)
+    #   hallucination / answer_relevance / toxicity / prompt_injection / factuality
+    #                    — combined_judge 대신 개별 evaluator 만 쓰고 싶을 때
+    # 예: "combined_judge,pii_leak,url_scan"  (default 와 동일)
+    # 예: "pii_leak,url_scan"                 (정형 평가만, LLM judge 0회)
+    # 예: "hallucination,toxicity,pii_leak"   (개별 aspect — combined 대신)
+    "llm_eval_evaluators": "",
+}

whatap/conf/configure.py

@@ -0,0 +1,105 @@
+import os, time
+
+from whatap.conf.configuration import Configuration
+
+
+class Configure(object):
+    PCODE = 0
+    OID = 0
+    OKIND = 0
+    OKIND_NAME = os.environ.get("ENV_OKIND", "-".join(os.environ.get("POD_NAME", "").split("-")[0:-1]))
+    dev = False
+    net_udp_port = 6600
+    force_net_udp_port = False
+    last_loaded = 0
+    last_config_modified = 0
+    observers = []
+    POD_NAME = os.environ.get("POD_NAME") if os.environ.get('POD_NAME') else os.environ.get("PODNAME") if os.environ.get("PODNAME") else ''
+    license = None
+    max_send_queue_size = 2000
+
+    @classmethod
+    def init(cls, display=True):
+        if cls.last_loaded == 0:
+            cls.loadFromEnv()
+        cls.last_loaded = time.time()
+        return cls.load(display)
+
+    @classmethod
+    def loadFromEnv(cls):
+        for key, value in Configuration.items():
+            setattr(cls, key, value)
+        if not hasattr(cls, "license") and hasattr(cls, "accesskey"):
+            setattr(cls, "license", getattr(cls, "accesskey"))
+
+    @classmethod
+    def load(cls, display=True):
+        home = 'WHATAP_HOME'
+        try:
+            whatap_config = os.path.join(os.environ[home],os.environ['WHATAP_CONFIG'])
+            last_modified = os.path.getmtime(whatap_config)
+            if cls.last_config_modified >= last_modified:
+                return True
+            for key, value in os.environ.items():
+                setattr(cls, key, value)
+            
+            with open(whatap_config, 'r') as f:
+                for line in f:
+                    cls.last_config_modified = last_modified
+                    line_strip = line.strip()
+                    if not line_strip or line_strip.startswith('#'):
+                        continue
+                    try:
+                        key, value = line.split('=')
+                        key = key.strip()
+                        value = value.strip()
+                        if key and key.endswith("_set"):
+                            value = value.split(",")
+                        cls.setProperty(key, value)
+                    
+                    except Exception as e:
+                        print('WHATAP: ', e)
+                        continue
+            if not getattr(cls, "license", None) and getattr(cls, "accesskey", None):
+                setattr(cls, "license", getattr(cls, "accesskey"))
+            for callback in cls.observers:
+                callback()
+        except Exception as e:
+            from whatap import CONFIG_FILE_NAME, init_config
+            init_config(home)
+            return False
+        else:
+            return True
+        finally:
+            if display:
+                from whatap import Logger
+                Logger()
+            
+    @classmethod
+    def getProperty(cls, key, value=None):
+        if hasattr(cls, key):
+            return getattr(cls, key)
+        elif key in os.environ:
+            return os.environ[key]
+        else:
+            return value
+    
+    @classmethod
+    def setProperty(cls, name, value):
+        if hasattr(cls, name):
+            if isinstance(getattr(cls, name), bool) and str(value) != 'true':
+                value = False
+        
+        setattr(cls, name, value)
+    
+    def getStringSet(cls, key, default_value, deli):
+        l = list()
+        value = cls.getProperty(key, default_value)
+        if value:
+            for v in value.split(deli):
+                l.append(v)
+        return l
+
+    @classmethod
+    def addObserver(cls, callback):
+        cls.observers.append(callback)

whatap/conf/license.py

@@ -0,0 +1,49 @@
+import io
+
+from whatap.io.data_inputx import DataInputX
+from whatap.io.data_outputx import DataOutputX
+
+from whatap.util.hexa32 import Hexa32
+
+
+class Key(object):
+    def __init__(self):
+        self.pcode = None
+        self.security_key = io.BytesIO()
+
+    def __repr__(self):
+        to_str = '{0}: '.format(type(self).__name__)
+
+        res = []
+        for key, value in self.__dict__.items():
+            if type(value).__name__.find('bytes') > -1:
+                dout = DataOutputX()
+                dout.writeIntBytes(value)
+
+                if isinstance(value, bytes) or isinstance(value, bytearray):
+                    for o in value:
+                        if o > 128:
+                            o -= 256
+                        res.append(o)
+
+            to_str += '{0}={1}, '.format(key, res)
+        return to_str
+
+
+class License(object):
+    @staticmethod
+    def getKey(lic):
+        tokens = lic.split('-')
+        dout = DataOutputX(len(tokens) * 8)
+        for token in tokens:
+            dout.writeLong(Hexa32.toLong32(token))
+        key = Key()
+        din = DataInputX(dout.toByteArray())
+        key.pcode = din.readDecimal()
+        key.security_key = din.readBlob()
+        return key
+
+    @staticmethod
+    def getProjectCode(lic):
+        k = License.getKey(lic)
+        return k.pcode

whatap/counter/__init__.py

@@ -0,0 +1,14 @@
+from .counter_manager import CounterMgr  #CounterMgr 클래스 import
+from whatap import preview_whatap_conf
+
+counter_thread_enabled = preview_whatap_conf("counter_thread_enabled")
+
+if counter_thread_enabled != 'false':
+    mgr = CounterMgr()
+    mgr.setDaemon(True)
+    mgr.start()
+
+    from .tasks.llm_stat_task import LlmStatTask
+    llm_stat = LlmStatTask()
+    llm_stat.setDaemon(True)
+    llm_stat.start()

whatap/counter/counter_manager.py

@@ -0,0 +1,45 @@
+import time
+import logging
+from threading import Thread
+
+
+class CounterMgr(Thread):
+    _instance = None
+
+    def __init__(self):
+        super(CounterMgr, self).__init__()
+        self.tasks = list()
+        self._task_map = {}
+        self.last_executed = {}
+        CounterMgr._instance = self
+
+    def _register_tasks(self):
+        from .tasks import TASK_CLASSES
+        for cls in TASK_CLASSES:
+            task = cls()
+            self.tasks.append(task)
+            self._task_map[task.name()] = task
+            self.last_executed[task.name()] = 0
+
+    def run(self):
+        self._register_tasks()
+
+        while True:
+            current_time = time.time()
+            time.sleep(1)
+            for task in self.tasks:
+                last_executed_time = self.last_executed[task.name()]
+                interval = task.interval()
+
+                if current_time - last_executed_time >= interval:
+                    try:
+                        self.last_executed[task.name()] = current_time
+                        task.process()
+                    except Exception as e:
+                        logging.debug(e, extra={'id': 'WA181'}, exc_info=True)
+
+    @classmethod
+    def get_task(cls, name):
+        if cls._instance is None:
+            return None
+        return cls._instance._task_map.get(name)

whatap/counter/tasks/__init__.py

@@ -0,0 +1,3 @@
+from whatap.counter.tasks.openfiledescriptor import OpenFileDescriptorTask
+
+TASK_CLASSES = [OpenFileDescriptorTask]

whatap/counter/tasks/base_task.py

@@ -0,0 +1,26 @@
+import whatap.net.async_sender as async_sender
+import whatap.io as whatapio
+
+
+class BaseTask(object):
+    _llm_task = False
+
+    def name(self):
+        return self.__class__.__name__
+
+    def interval(self):
+        return 60
+
+    def process(self):
+        pass
+
+    def send_pack(self, pack):
+        from whatap.conf.configure import Configure as conf
+        pack.pcode = getattr(conf, 'PCODE', 0)
+        bout = whatapio.DataOutputX()
+        bout.writePack(pack, None)
+        packbytes = bout.toByteArray()
+        if self._llm_task:
+            async_sender.send_llm_relaypack(packbytes)
+        else:
+            async_sender.send_relaypack(packbytes)