def wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
if hasattr(tracker, '_self_django_url_resolver_wrapped'):
return wrapped(*args, **kwargs)
# mark the top level(views maybe has inline local url resolver operate) url resolver. and use it as the
tracker._self_django_url_resolver_wrapped = True
def _wrapped(path):
with FunctionTracker(tracker, name=name, label=path):
result = wrapped(path)
if isinstance(type(result), tuple):
callback, callback_args, callback_kwargs = result
result = (wrap_view_handler(callback, priority=4),
callback_args, callback_kwargs)
else:
result.func = wrap_view_handler(result.func, priority=4)
return result
try:
return _wrapped(*args, **kwargs)
finally:
del tracker._self_django_url_resolver_wrapped
def wrap_exception(wrapped, action_url, parameters, *args, **kwargs):
"""
"""
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
url = action_url if not callable(action_url) else action_url(*args, **kwargs)
params = parameters if not callable(parameters) else parameters(*args, **kwargs)
http_status = 500
error_code = 0
params = parse_parameters(url, params)
try:
return wrapped(*args, **kwargs)
except TTransportException:
error_code = UNKNOWN_HOST_ERROR_CODE
tracker.record_external_error(url, error_code, http_status, sys.exc_info(), params)
raise
except TProtocolException:
error_code = ILLEGAL_RESPONSE_ERROR_CODE
tracker.record_external_error(url, error_code, http_status, sys.exc_info(), params)
raise
except Exception:
error_code = OTHER_ERROR_CODE
tracker.record_external_error(url, error_code, http_status, sys.exc_info(), params)
raise
def stop_request_tracer(request,
exc_type=None,
exc_val=None,
exc_tb=None,
segment=None):
"""
"""
tracer = getattr(request, '_self_tracer', None)
try:
if not tracer:
console.debug(
"tracker lost when trace the request call chain with async, this trace for function time"
" metric will be interrupted. %s",
''.join(traceback.format_stack()[:-1]))
return
# deal the case which the tracer hold by current request saved in thread cache
thread_tracer = current_tracker()
if tracer == thread_tracer:
tracer.finish_work(exc_type, exc_val, exc_tb, False)
else:
tracer.finish_work(exc_type, exc_val, exc_tb, True)
except Exception as err:
console.exception("Tornado raise error when stop the trace. %s, %s",
segment, err)
finally:
request._self_request_finished = True
request._self_tracer = None
request._self_async_function_tracker = None
def dynamic_wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
_name = name
_params = params
_label = label
_group = group
if callable(name):
if instance is not None:
_name = name(instance, *args, **kwargs)
else:
_name = name(*args, **kwargs)
elif name is None:
_name = callable_name(wrapped)
if callable(group):
if instance is not None:
_group = group(instance, *args, **kwargs)
else:
_group = group(*args, **kwargs)
with FunctionTracker(tracker, _name, _group, _label, _params) as ft:
try:
return wrapped(*args, **kwargs)
except:
ft.exception.append(tracker.record_exception(is_error=False))
raise
def execute(self, sql, *args, **kwargs):
"""
:param sql:
:param args:
:param kwargs:
:return:
"""
tracker = current_tracker()
if not tracker:
return self.cursor.execute(sql, *args, **kwargs)
with DatabaseTracker(tracker,
sql,
dbtype,
module,
self.connect_params,
self.cursor_params, (args, kwargs),
host=self.host,
port=self.port,
db_name=self.db_name) as dt:
try:
return self.cursor.execute(sql, *args, **kwargs)
except:
dt.exception = tracker.record_exception(is_error=False,
additional_msg=sql)
raise
def dynamic_wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
_name = name
_params = params
_label = label
_group = group
if callable(name):
if instance is not None:
_name = name(instance, *args, **kwargs)
else:
_name = name(*args, **kwargs)
elif name is None:
_name = callable_name(wrapped)
if callable(group):
if instance is not None:
_group = group(instance, *args, **kwargs)
else:
_group = group(*args, **kwargs)
with FunctionTracker(tracker, _name, _group, _label, _params):
return wrapped(*args, **kwargs)
def trace_resource_call(wrapped, instance, args, kwargs):
"""
:param wrapped:
:param instance:
:param args:
:param kwargs:
:return:
"""
method_mapping = {
'GET': 'read',
'POST': 'create',
'PUT': 'update',
'DELETE': 'delete'
}
def parse_request(request, *args, **kwargs):
return request
tracker = current_tracker()
if not tracker:
return wrapped(*args, **kwargs)
request = parse_request(*args, **kwargs)
method = request.method.upper()
# if invalid request method, use the origin request method
# And using high priority to set the metric name.
name = "%s.%s" % (callable_name(
instance.handler), method_mapping.get(method, method))
tracker.set_tracker_name(name=name, priority=5)
with FunctionTracker(tracker, name):
return wrapped(*args, **kwargs)
def wrap_exception(wrapped, action_url, parameters, *args, **kwargs):
"""
"""
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
url = action_url if not callable(action_url) else action_url(
*args, **kwargs)
params = parameters if not callable(parameters) else parameters(
*args, **kwargs)
http_status = 500
error_code = 0
params = parse_parameters(url, params)
try:
rtv = wrapped(*args, **kwargs)
except HTTPError as err:
http_status = getattr(err, "code") # equal to getcode()
error_code = OTHER_ERROR_CODE
tracker.record_external_error(url,
error_code,
http_status,
sys.exc_info(),
params,
module_name='urllib2')
raise
except URLError:
error_code = MALFORMED_URL_ERROR_CODE
tracker.record_external_error(url,
error_code,
http_status,
sys.exc_info(),
params,
module_name='urllib2')
raise
except Exception:
error_code = OTHER_ERROR_CODE
tracker.record_external_error(url,
error_code,
http_status,
sys.exc_info(),
params,
module_name='urllib2')
raise
http_status = rtv.getcode()
if http_status is not None and int(http_status) != 200:
tracker.record_external_error(url,
error_code,
int(http_status),
sys.exc_info(),
params,
module_name='urllib2')
return rtv
def literal_wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
with ExternalTrace(tracker, library, url, kwargs):
return wrapped(*args, **kwargs)
def create_node(self):
tracker = current_tracker()
if tracker:
tracker.external_time = self.duration
return ExternalNode(library=self.library, url=self.url, children=self.children, protocol=self.protocol,
start_time=self.start_time, end_time=self.end_time, duration=self.duration,
exclusive=self.exclusive, external_id=self.external_id)
def wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
with ErrorTrace(tracker, ignore_errors):
return wrapped(*args, **kwargs)
def wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
with FunctionTracker(tracker, name=name):
callback, param_dict = wrapped(*args, **kwargs)
return wrap_view_handler(callback, priority=priority), param_dict
def wrap_exception(wrapped, action_url, parameters, *args, **kwargs):
"""
"""
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
url = action_url if not callable(action_url) else action_url(
*args, **kwargs)
params = parameters if not callable(parameters) else parameters(
*args, **kwargs)
http_status = 500
error_code = 0
params = parse_parameters(url, params)
try:
rtv = wrapped(*args, **kwargs)
except ReadTimeout:
error_code = TIMEOUT_EXCEPTION_ERROR_CODE
tracker.record_external_error(url, error_code, http_status,
sys.exc_info(), params)
raise
except (ConnectTimeout, ConnectionError, SSLError):
error_code = CONNECT_EXCEPTION_ERROR_CODE
tracker.record_external_error(url, error_code, http_status,
sys.exc_info(), params)
raise
except (InvalidURL, URLRequired):
error_code = MALFORMED_URL_ERROR_CODE
tracker.record_external_error(url, error_code, http_status,
sys.exc_info(), params)
raise
except (InvalidSchema, MissingSchema):
error_code = CLIENT_PROTOCOL_ERROR_CODE
tracker.record_external_error(url, error_code, http_status,
sys.exc_info(), params)
raise
except (ChunkedEncodingError, ContentDecodingError, StreamConsumedError):
error_code = ILLEGAL_RESPONSE_ERROR_CODE
tracker.record_external_error(url, error_code, http_status,
sys.exc_info(), params)
raise
except Exception:
error_code = OTHER_ERROR_CODE
tracker.record_external_error(url, error_code, http_status,
sys.exc_info(), params)
raise
if int(getattr(rtv, 'status_code', 0)) != 200:
tracker.record_external_error(url, error_code,
getattr(rtv, 'status_code', 500),
sys.exc_info(), params)
return rtv
def trace_handler_request_exception(wrapped, instance, args, kwargs):
"""
"""
tracker = current_tracker()
if not tracker:
return wrapped(*args, **kwargs)
tracker.record_exception(*sys.exc_info())
return wrapped(*args, **kwargs)
def fetchmany(self, *args, **kwargs):
"""we do not capture the metric of execute result. this is small time used
:args:
:kwargs:
:return:
"""
tracker = current_tracker()
with FunctionTracker(tracker, callable(self.cursor.fetchone)):
return self.cursor.fetchmany(*args, **kwargs)
def create_node(self):
tracker = current_tracker()
if tracker:
tracker.db_time = self.duration
return DatabaseNode(dbapi=self.dbapi, sql=self.sql, children=self.children, start_time=self.start_time,
end_time=self.end_time, duration=self.duration, exclusive=self.exclusive,
dbtype=self.db_type, stack_trace=self.stack_trace, sql_format=self.sql_format,
connect_params=self.connect_params, cursor_params=self.cursor_params,
execute_params=self.execute_params, host=self.host, port=self.port, db_name=self.db_name)
def literal_wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
_name = name or callable_name(wrapped)
with FunctionTracker(tracker, _name, group, label, params):
return wrapped(*args, **kwargs)
def create_node(self):
"""
:return:
"""
tracker = current_tracker()
if tracker:
tracker.redis_time = self.duration
return RedisNode(command=self.command, children=self.children, start_time=self.start_time, host=self.host,
end_time=self.end_time, duration=self.duration, exclusive=self.exclusive, port=self.port,
db=self.db)
def trace_tornado_http_request(wrapped, instance, args, kwargs):
"""
"""
tracker = current_tracker()
if not tracker:
return wrapped(*args, **kwargs)
_url = parse_request_url(*args, **kwargs)
with ExternalTrace(tracker, "HTTPClient", _url):
return wrapped(*args, **kwargs)
def fetchall(self, *args, **kwargs):
"""this operation maybe spend more time. this is small time used
and the sql was executed. we can not take it
:args:
:kwargs:
:return:
"""
tracker = current_tracker()
with FunctionTracker(tracker, callable(self.cursor.fetchone)):
return self.cursor.fetchall(*args, **kwargs)
def rollback(self):
"""
:return:
"""
tracker = current_tracker()
if not tracker:
return self.connection.rollback()
with DatabaseTracker(tracker, 'ROLLBACK', dbtype, module, host=self.host, port=self.port,
db_name=self.db_name):
return self.connection.rollback()
def commit(self):
"""
:return:
"""
tracker = current_tracker()
if not tracker:
return self.connection.commit()
with DatabaseTracker(tracker, 'COMMIT', dbtype, module, host=self.host, port=self.port,
db_name=self.db_name):
return self.connection.commit()
def _do_comon_callback_wrap(wrapped, instance, args, kwargs):
"""
:return:
"""
tracker = current_tracker()
if not tracker:
console.debug("No tracker found for tracing %s", callable_name(wrapped))
return wrapped(*args, **kwargs)
with FunctionTracker(tracker, callable_name(wrapped)):
return wrapped(*args, **kwargs)
def literal_wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
if callable(server):
host, port, db = server(instance, *args, **kwargs)
else:
host, port, db = "Unknown", 0, 0
with RedisTrace(tracker, host, port, db, command):
return wrapped(*args, **kwargs)
def literal_wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
with ExternalTrace(tracker, library, url, kwargs) as et:
try:
return wrapped(*args, **kwargs)
except:
et.exception = tracker.record_exception(is_error=False)
raise
def literal_wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
if callable(server):
host, port, schema = server(instance, *args, **kwargs)
else:
host, port, schema = "Unknown", "Unknown", "Unknown"
with MongoTracker(tracker, host, port, schema, method):
return wrapped(*args, **kwargs)
def wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if not tracker:
return wrapped(*args, **kwargs)
tracker.set_tracker_name(callable_name(wrapped), priority=3)
with FunctionTracker(tracker, callable_name(wrapped)):
try:
return wrapped(*args, **kwargs)
except Exception as _:
tracker.record_exception()
raise
def executemany(self, sql, *args, **kwargs):
"""
:param sql:
:param args:
:param kwargs:
:return:
"""
tracker = current_tracker()
if not tracker:
return self.cursor.executemany(sql, *args, **kwargs)
with DatabaseTracker(tracker, sql, dbtype, module, host=self.host, port=self.port, db_name=self.db_name):
return self.cursor.executemany(sql, *args, **kwargs)
def wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
tracker.set_tracker_name(name, priority=priority)
with FunctionTracker(tracker, name=name):
try:
return wrapped(*args, **kwargs)
except: # Catch all
tracker.record_exception(ignore_errors=should_ignore)
raise
def wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
before_name = "%s.%s" % (tracker.name, tracker.group)
with FunctionTracker(tracker, name=name):
try:
return wrapped(*args, **kwargs)
finally:
after_name = "%s.%s" % (tracker.name, tracker.group)
if before_name == after_name and detect_name:
tracker.set_tracker_name(name, priority=2)
