def trace_thread_stack(self):
"""
:return:
"""
for tracker, thread_id, category, frame in knapsack().get_active_threads():
# top level node for profile
is_runnable = {"is_runnable": True}
top_node = ProfileTraceNode(category, "-", 'PythonProfileEntryFunc', 0, is_runnable)
father = top_node
self.current_profile.thread_count += 1
while frame:
code = frame.f_code
child = ProfileTraceNode(category, intern(code.co_filename), intern(code.co_name), frame.f_lineno,
is_runnable)
father.append_child(intern(code.co_name), child)
father = child
top_node.depth += 1
frame = frame.f_back
# mark it is runnable thread or not
if intern(intern(code.co_name)) in RUNNABLE_STATUS_FUNC:
is_runnable['is_runnable'] = False
break
if is_runnable['is_runnable']:
self.current_profile.total_runnable_count += 1
yield thread_id, category, top_node
def current_thread_id():
return knapsack().current_thread_id()
def current_tracker():
"""return current tracker in the thread
:return:
"""
return knapsack().current_tracker()
def drop_tracker(self):
if not self.enabled:
return self
knapsack().drop_tracker(self)
def save_tracker(self):
knapsack().save_tracker(self)
def __init__(self, proxy, enabled=None, framework="Python"):
"""
:param proxy: communication proxy instance to controller.
:return:
"""
self.framework = framework
self.proxy = proxy
self.enabled = False
self.rum_enabled = True # current transaction switch to control auto insert browser agent.
self._settings = None
self.thread_id = knapsack().current_thread_id()
self.background_task = False
self.start_time = 0
self.end_time = 0
self.queque_start = 0
self._queque_time = 0
self.trace_node = []
self.async_func_trace_time = 0 # millisecond
self._errors = []
self.external_error = []
self._custom_params = {}
self._slow_sql_nodes = []
self.http_method = "GET"
self.request_uri = None
self.http_status = 500
self.request_params = {}
self.header_params = {}
self.cookie_params = {}
self._priority = 0
self._group = None
self._name = None
self.apdex = 0
self._frozen_path = None
self.stack_trace_count = 0
self.explain_plan_count = 0
self.thread_name = "Unknown"
self.referer = ""
self._trace_guid = ""
self._trace_id = ""
self._tingyun_id = ""
self._called_traced_data = ""
self.call_tingyun_id = ""
self.call_req_id = ""
# -1 indicate it's not called the service.
self.db_time = -1
self.external_time = -1
self.redis_time = -1
self.memcache_time = -1
self.mongo_time = -1
# set the global switch of agent. the return application settings is download from server witch is merged
# with the local settings on server
# agent always be enabled if enabled in local settings. just not upload data when disabled by server.
global_settings = proxy.global_settings
if global_settings.enabled:
if enabled or (enabled is None and proxy.enabled):
self._settings = proxy.settings
if not self._settings:
self.proxy.activate()
self._settings = proxy.settings
if self._settings:
self.enabled = True
if self.enabled:
self._tingyun_id = self._settings.tingyunIdSecret
