whatap-python 1.8.5__tar.gz → 1.8.7__tar.gz

{whatap_python-1.8.5 → whatap_python-1.8.7}/PKG-INFO

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

{whatap_python-1.8.5 → whatap_python-1.8.7}/setup.py

@@ -18,7 +18,7 @@ setup(name=build.name,
       author_email='admin@whatap.io',
       license='Whatap License',
       url='https://www.whatap.io',
-      packages=find_packages(),
+      packages=find_packages(exclude=('sample','sample.*')),
       package_data={
           'whatap': ['LICENSE', '*.rst', '*.conf', '*.json', 'agent/*/*/whatap_python']
       },

{whatap_python-1.8.5 → whatap_python-1.8.7}/whatap/__init__.py

@@ -48,33 +48,41 @@ LOG_FILE_NAME = 'whatap-hook.log'
 
 isFrappeCommands = "get-frappe-commands" in sys.argv if hasattr(sys, "argv") else False
 
-def read_ignore_whatap_stdout():
-    ignore_whatap_stdout = 'false'
+def preview_whatap_conf(option_name:str):
     home = os.environ.get('WHATAP_HOME', '.')
     whatap_config = os.path.join(home, 'whatap.conf')
+
+
+    """
+    현재 preview_whatap_conf 를 사용중인 옵션
+    - ignore_whatap_stdout (False)
+    - standalone_enabled (False)
+    - open_file_descriptor_enabled (False)
+    """
+    value = 'false'
     try:
         with open(whatap_config) as f:
             for raw in f:
                 line = raw.strip()
                 if not line or line.startswith('#'):
                     continue
-                if line.startswith('ignore_whatap_stdout'):
+                if line.startswith(option_name):
                     parts = line.split('=', 1)
                     if len(parts) == 2:
-                        ignore_whatap_stdout = parts[1].strip()
+                        value = parts[1].strip()
                     break
-        return ignore_whatap_stdout
+        return value
 
     except FileNotFoundError:
-        return ignore_whatap_stdout
+        return value
 
     except Exception as e:
         print(f'WHATAP: config parse error ({e!r})')
-        return ignore_whatap_stdout
+        return value
 
 
 
-ignore_whatap_stdout = read_ignore_whatap_stdout()
+ignore_whatap_stdout = preview_whatap_conf("ignore_whatap_stdout")
 
 
 
@@ -329,6 +337,14 @@ def hooks(home):
                                                       'trace',
                                                       'mod',
                                                       key)}
+
+            if conf.standalone_enabled:
+                if conf.standalone_type == 'multiple-transaction':
+                    from whatap.trace.mod.standalone_multiple import instrument_standalone_multiple
+                    instrument_standalone_multiple()
+                else:
+                    from whatap.trace.mod.standalone_single import instrument_standalone_single
+                    instrument_standalone_single()
         
         except Exception as e:
             logging.debug(e, extra={'id': 'PLUGIN ERROR'})
@@ -354,9 +370,11 @@ def agent():
     if write_file(home, home.lower(), whatap_home):
         os.environ['WHATAP_HOME'] = whatap_home
         
-        # t = threading.Thread(target=go)
-        # t.setDaemon(True)
-        # t.start()
+        whatap_code_start = preview_whatap_conf("whatap_code_start")
+        if whatap_code_start == 'true':
+            t = threading.Thread(target=go)
+            t.setDaemon(True)
+            t.start()
         config(home)
 
 ARCH = {

whatap_python-1.8.7/whatap/build.py

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

{whatap_python-1.8.5 → whatap_python-1.8.7}/whatap/conf/configuration.py

@@ -1,5 +1,6 @@
 Configuration = {
     "dev": False,
+    "whatap_code_start": False,
     "ignore_whatap_stdout" : False,
     "net_udp_port": "6600",
     "web_static_content_extensions": "js, htm, html, gif, png, jpg, css, swf, ico",
@@ -50,6 +51,10 @@ Configuration = {
 	"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,

whatap_python-1.8.7/whatap/counter/__init__.py

@@ -0,0 +1,9 @@
+from .counter_manager import CounterMgr  # CounterMgr 클래스 import
+from whatap import preview_whatap_conf
+
+open_file_descriptor_enabled = preview_whatap_conf("open_file_descriptor_enabled")
+
+if open_file_descriptor_enabled != 'false':
+    mgr = CounterMgr()
+    mgr.setDaemon(True)
+    mgr.start()

{whatap_python-1.8.5 → whatap_python-1.8.7}/whatap/scripts/__init__.py

@@ -1,11 +1,12 @@
 import os
 import re
+import time
 from functools import wraps
 
 import sys, threading
 
 from whatap import check_whatap_home, ROOT_DIR, init_config, update_config, \
-    batch_agent, AGENT_NAME, go, configPort
+    batch_agent, AGENT_NAME, go, configPort, preview_whatap_conf
 
 
 def whatap_command(func):
@@ -73,6 +74,9 @@ def start_agent():
 
     try:
         go(opts={'whatap.port': str(port)})
+        standalone_enabled = preview_whatap_conf("standalone_enabled")
+        if standalone_enabled == 'true':
+            time.sleep(1)
     except Exception as e:
         print('WHATAP: AGENT ERROR: {}'.format(e))
         print('WHATAP: continue to start user application')

{whatap_python-1.8.5 → whatap_python-1.8.7}/whatap/trace/mod/application_wsgi.py

@@ -444,22 +444,39 @@ def addQuoteList(arg_list):
 
     return tuple(quoted_list)
 
+def neo4jQuery(query,paremeter):
+    transformed_query = query
+
+    for key, value in paremeter.items():
+        placeholder = f"${key}"
+        replacement = f"'{str(value)}'"
+        transformed_query = transformed_query.replace(placeholder, replacement)
+
+    return transformed_query
 
 def interceptor_db_execute(fn, db_info, *args, **kwargs):
     ctx = TraceContextManager.getLocalContext()
     # sendDebugProfile(ctx, 'interceptor_db_execute step -1')
     self = args[0]
+    db_type = db_info.get('type')
     query = None
-    if len(args) > 2 and type(args[2]) == dict and args[2]:
-        try:
-            query = args[1] % addQuoteDict(args[2])
-        except Exception as e:
-            pass
-    if len(args) > 2 and type(args[2]) in (list, tuple) and args[2]:
+
+    if db_type == "neo4j":
         try:
-            query = args[1] % addQuoteList(args[2])
+            query = neo4jQuery(args[1], kwargs)
         except Exception as e:
             pass
+    else:
+        if len(args) > 2 and type(args[2]) == dict and args[2]:
+            try:
+                query = args[1] % addQuoteDict(args[2])
+            except Exception as e:
+                pass
+        if len(args) > 2 and type(args[2]) in (list, tuple) and args[2]:
+            try:
+                query = args[1] % addQuoteList(args[2])
+            except Exception as e:
+                pass
     try:
         if not query:
             query = args[1].decode()

whatap_python-1.8.7/whatap/trace/mod/database_neo4j.py

@@ -0,0 +1,126 @@
+from whatap.trace import get_dict
+from whatap.trace.mod.application_wsgi import (
+    trace_handler,
+    interceptor_db_con,
+    interceptor_db_execute,
+    interceptor_db_close
+)
+db_info = {}
+
+def get_db_info(session):
+    db_info = {'type' : 'neo4j'}
+
+    pool = getattr(session, '_pool', None)
+
+    host = None
+    port = None
+    user = None
+    db_name = None
+
+    try:
+        if pool:
+            addr = getattr(pool, 'address', getattr(pool, '_address', None))
+            if addr:
+                host, port = addr[0], addr[1]
+    except Exception:
+        pass
+    db_info["host"] = f"{host}:{port}"
+
+    try:
+        if pool:
+            auth_token = pool.get_auth()
+            if auth_token:
+                user = getattr(auth_token, 'principal', None)
+    except Exception as e:
+        pass
+
+    if user == None:
+        db_info["user"] = "neo4j"
+    else:
+        db_info["user"] = user
+
+    try:
+        session_config = getattr(session, '_config', None)
+        if session_config:
+            db_name = getattr(session_config, 'database', None)
+    except Exception:
+        pass
+
+    if db_name == None:
+        db_info["dbname"] = "default"
+    else:
+        db_info["dbname"] = db_name
+
+
+
+    return db_info
+
+
+
+
+def instrument_neo4j(module):
+    orig = module.Session.run
+
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(session, *args, **kwargs):
+            db_info = get_db_info(session)
+            try:
+                setattr(session, 'rowcount', -1)
+            except Exception as e:
+                raise e
+            callback = interceptor_db_execute(fn, db_info, session, *args, **kwargs)
+
+            return callback
+        return trace
+
+    module.Session.run = wrapper(orig)
+
+
+
+
+    orig = module.Session.close
+
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(session, *args, **kwargs):
+            callback = interceptor_db_close(fn, session ,*args, **kwargs)
+            return callback
+        return trace
+
+    module.Session.close = wrapper(orig)
+
+
+
+
+
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(tx, *args, **kwargs):
+            session = None
+            try:
+                session = tx._on_closed.__self__
+            except AttributeError:
+                return fn(tx, *args, **kwargs)
+
+            db_info = get_db_info(session)
+            try:
+                setattr(tx, 'rowcount', -1)
+            except Exception:
+                pass
+            callback = interceptor_db_execute(fn, db_info, tx, *args, **kwargs)
+            return callback
+
+        return trace
+
+    tx_classes_to_patch = ['Transaction', 'ManagedTransaction', 'BoltTransaction']
+
+    for class_name in tx_classes_to_patch:
+        if hasattr(module, class_name):
+            TxClass = getattr(module, class_name)
+            if hasattr(TxClass, 'run'):
+                original_run = getattr(TxClass, 'run')
+                setattr(TxClass, 'run', wrapper(original_run))
+
+
+

whatap_python-1.8.7/whatap/trace/mod/standalone_multiple.py

@@ -0,0 +1,278 @@
+import sys
+import atexit
+import time
+import traceback
+
+import whatap.net.async_sender as async_sender
+
+from functools import wraps
+
+from whatap.conf.configure import Configure as conf
+from whatap.util.date_util import DateUtil
+from whatap.trace.trace_context import TraceContext
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.net.packet_type_enum import PacketTypeEnum
+from whatap.trace.mod.application_wsgi import trace_handler
+from whatap import logging
+
+def trace_handler(fn, start=False, preload=None):
+    def handler(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if preload:
+                preload(*args, **kwargs)
+
+            ctx = TraceContextManager.getLocalContext()
+            if not start and not ctx:
+                return fn(*args, **kwargs)
+            try:
+                callback = func(*args, **kwargs)
+            except Exception as e:
+                if ctx and ctx.error_step == e:
+                    ctx.error_step = None
+                    raise e
+                raise
+            else:
+                if ctx and ctx.error_step:
+                    e = ctx.error_step
+                    ctx.error_step = None
+                    raise e
+                return callback
+
+        return wrapper
+
+    return handler
+
+def load_transaction_patterns():
+    raw = conf.standalone_transaction_patterns
+    patterns = set(entry.strip() for entry in raw.split(",") if entry.strip())
+
+    return patterns
+
+
+def shutdown_agent():
+
+    start_time = time.time()
+
+    while not async_sender.q.empty():
+        if time.time() - start_time > 3.0:
+            break
+        time.sleep(0.1)
+
+    if async_sender.q.empty():
+        return
+    else:
+        remaining_items = async_sender.q.qsize()
+
+def end_interceptor(ctx):
+    if not ctx:
+        return
+
+    if conf.dev:
+        logging.debug(f'end   transaction id(seq): {ctx.id}', extra={'id': 'WA112'})
+        print(f'end   transaction id(seq): {ctx.id}', dict(extra={'id': 'WA112'}))
+
+    start_time = DateUtil.nowSystem()
+    ctx.start_time = start_time
+
+    datas = [ctx.host, ctx.service_name, ctx.mtid, ctx.mdepth, ctx.mcaller_txid,
+             ctx.mcaller_pcode, ctx.mcaller_spec, str(ctx.mcaller_url_hash), ctx.mcaller_poid, ctx.status]
+
+    ctx.elapsed = DateUtil.nowSystem() - start_time
+
+    async_sender.send_packet(PacketTypeEnum.TX_END, ctx, datas)
+
+
+def start_interceptor(ctx):
+    if conf.dev:
+        logging.debug(f'start transaction id(seq): {ctx.id}', extra={'id': 'WA111'})
+        print(f'start transaction id(seq): {ctx.id}', dict(extra={'id': 'WA111'}))
+
+    start_time = DateUtil.nowSystem()
+    ctx.start_time = start_time
+
+    datas = [ctx.host, ctx.service_name, ctx.remoteIp, ctx.userAgentString,
+             ctx.referer, ctx.userid, ctx.isStaticContents, ctx.http_method]
+
+    async_sender.send_packet(PacketTypeEnum.TX_START, ctx, datas)
+
+def error_interceptor(error_msg,error_type,ctx):
+    if not ctx:
+        ctx = TraceContextManager.getLocalContext()
+    if not ctx:
+        return
+    if not ctx.error:
+        ctx.error = 1
+
+    error = ''
+    errors = []
+    errors.append(error_type)
+    errors.append(error_msg)
+
+    frame = sys._current_frames().get(ctx.thread.ident)
+    if not frame:
+        return
+
+    for stack in traceback.extract_stack(frame):
+        line = stack[0]
+        line_num = stack[1]
+        method_name = stack[2]
+
+        if line.find('/whatap/trace') > -1 or line.find(
+                '/threading.py') > -1:
+            continue
+        error += '{} ({}:{})\n'.format(method_name, line, line_num)
+
+    errors.append(error)
+
+    async_sender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors)
+
+    if conf.profile_exception_stack:
+        desc = '\n'.join(errors)
+        datas = [' ', ' ', desc]
+        ctx.start_time = DateUtil.nowSystem()
+        async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+
+def instrument_standalone_multiple():
+    atexit.register(shutdown_agent)
+
+    patterns = load_transaction_patterns()
+    targets_to_patch = {tuple(entry.split(":", 1)) for entry in patterns}
+
+    tracked_methods = set()
+    tracked_funcs = set()
+    modules = set()
+
+
+    for entry in patterns:
+        mod, target = entry.split(":", 1)
+        if "." in target:
+            cls, mtd = target.split(".", 1)
+            tracked_methods.add((mod, cls, mtd))
+        else:
+            func = target
+            tracked_funcs.add((mod, func))
+
+        modules.add(mod)
+
+    def wrapper(fn, module_name, target_name):
+        @trace_handler(fn, start=True)
+        def trace(*args, **kwargs):
+            prev_ctx = TraceContextManager.getLocalContext()
+            ctx = TraceContext()
+            ctx.service_name = f"{module_name}:{target_name}"
+            start_interceptor(ctx)
+            try:
+                callback = fn(*args, **kwargs)
+                return callback
+            except Exception as e:
+                error_msg = str(e)
+                error_type = e.__class__.__name__
+                error_interceptor(error_msg,error_type,ctx)
+                raise e
+            finally:
+                end_interceptor(ctx)
+                TraceContextManager.setLocalContext(prev_ctx)
+
+        return trace
+
+
+
+    patching_queue = []
+    sys_trace_current_service_name = None
+
+    def trace_and_patch_profiler(frame, event, arg):
+        global sys_trace_current_service_name
+
+        if not targets_to_patch and not patching_queue:
+            pass
+
+        module_name = frame.f_globals.get("__name__")
+        if module_name not in (modules) or event not in ("call", "return","exception"):
+            return trace_and_patch_profiler
+
+        fn_name = frame.f_code.co_name
+        is_method = "self" in frame.f_locals
+
+        is_target = False
+        full_target_name = fn_name
+        target_tuple = None
+
+        if is_method:
+            cls_name = type(frame.f_locals["self"]).__name__
+            full_target_name = f"{cls_name}.{fn_name}"
+            if (module_name, cls_name, fn_name) in tracked_methods:
+                is_target = True
+                target_tuple = (module_name, full_target_name)
+        else:
+            if (module_name, fn_name) in tracked_funcs:
+                is_target = True
+                target_tuple = (module_name, full_target_name)
+
+        if target_tuple in targets_to_patch:
+            if event == "call":
+                if not is_target:
+                    return trace_and_patch_profiler
+
+                prev_ctx = TraceContextManager.getLocalContext()
+                if prev_ctx:
+                    patching_queue.append(prev_ctx)
+
+                ctx = TraceContext()
+                ctx.service_name = f"{module_name}:{full_target_name}"
+                sys_trace_current_service_name = ctx.service_name
+
+                TraceContextManager.setLocalContext(ctx)
+                start_interceptor(ctx)
+
+                try:
+                    module_obj = sys.modules[module_name]
+                    if is_method:
+                        cls_name, mtd_name = target_tuple[1].split('.', 1)
+                        cls_obj = getattr(module_obj, cls_name)
+                        fn = getattr(cls_obj, mtd_name)
+                        wrapped_fn = wrapper(fn, module_name, target_tuple[1])
+                        setattr(cls_obj, mtd_name, wrapped_fn)
+                    else:
+                        func_name = target_tuple[1]
+                        fn = getattr(module_obj, func_name)
+                        wrapped_fn = wrapper(fn, module_name, func_name)
+                        setattr(module_obj, func_name, wrapped_fn)
+
+                    targets_to_patch.remove(target_tuple)
+
+
+
+                except (AttributeError, KeyError) as e:
+                    if target_tuple in targets_to_patch:
+                        targets_to_patch.remove(target_tuple)
+
+        if event == "return":
+            ctx = TraceContextManager.getLocalContext()
+            if ctx and sys_trace_current_service_name == f"{module_name}:{full_target_name}":
+                end_interceptor(ctx)
+                if patching_queue:
+                    prev_ctx = patching_queue.pop()
+                    TraceContextManager.setLocalContext(prev_ctx)
+                    sys_trace_current_service_name = prev_ctx.service_name
+                else:
+                    if not(targets_to_patch):
+                        sys.settrace(None)
+
+        if event == "exception":
+            ctx = TraceContextManager.getLocalContext()
+            if ctx and sys_trace_current_service_name == f"{module_name}:{full_target_name}":
+                exc_type, exc_value , tb = arg
+                error_interceptor(exc_value,exc_type,ctx)
+                end_interceptor(ctx)
+                if patching_queue:
+                    prev_ctx = patching_queue.pop()
+                    TraceContextManager.setLocalContext(prev_ctx)
+                    sys_trace_current_service_name = prev_ctx.service_name
+                else:
+                    if not (targets_to_patch):
+                        sys.settrace(None)
+
+        return trace_and_patch_profiler
+
+    sys.settrace(trace_and_patch_profiler)