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 process_cross_trace(headers):
"""
"""
if headers is None:
headers = {}
# sunyan: hack begin!
#from py_zipkin import zipkin
#headers.update(zipkin.create_http_headers_for_new_span())
#print("new headers>>>>>>")
#for k, v in headers.items():
# print("k:{0}".format(k))
# print("v:{0}".format(v))
#print("new headers<<<<<<")
# sunyan: hack end!
tracker = current_tracker()
if not tracker or not tracker.enabled:
return headers
if not tracker.settings.transaction_tracer.enabled:
return headers
headers['X-Tingyun-Id'] = tracker.settings.x_tingyun_id % (
tracker._tingyun_id, tracker.generate_trace_id())
return headers
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 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 rollback(self):
"""
:return:
"""
tracker = current_tracker()
if not tracker:
return self.connection.rollback()
with DatabaseTracker(tracker, 'ROLLBACK', dbtype, module):
return self.connection.rollback()
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):
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)
def commit(self):
"""
:return:
"""
tracker = current_tracker()
if not tracker:
return self.connection.commit()
with DatabaseTracker(tracker, 'COMMIT', dbtype, module):
return self.connection.commit()
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):
return self.cursor.executemany(sql, *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)
def callproc(self, procname, *args, **kwargs):
"""
:param procname:
:param args:
:param kwargs:
:return:
"""
tracker = current_tracker()
if not tracker:
return self.cursor.callproc(procname, *args, **kwargs)
with DatabaseTracker(tracker, 'CALL %s' % procname, dbtype,
module):
return self.cursor.callproc(procname, *args, **kwargs)
def _wrapper(wrapped, instance, args, kwargs):
"""
:param wrapped:
:param instance:
:param args:
:param kwargs:
:return:
"""
tracker = current_tracker()
if not tracker:
return wrapped(*args, **kwargs)
tracker.set_tracker_name(callable_name(wrapped), priority=priority)
with FunctionTracker(tracker, callable_name(wrapped)):
return wrapped(*args, **kwargs)
def handle_exception_wrapper(wrapped, instance, args, kwargs):
"""used to trace the exception errors.
:param wrapped:
:param instance:
:param args:
:param kwargs:
:return:
"""
tracker = current_tracker()
if not tracker:
return wrapped(*args, **kwargs)
# just record the exception info
tracker.record_exception()
return wrapped(*args, **kwargs)
def wrapper(wrapped, instance, args, kwargs):
console.info("args===>")
console.info(args)
console.info("args<===")
tracker = current_tracker()
console.info("wsgi_wrapper_inline>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
console.info("current_tracker:1: %s" % tracker)
if tracker:
console.info("current_tracker:2: None")
console.info("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
return wrapped(*args, **kwargs)
environ, start_response = parse_wsgi_protocol(target, *args, **kwargs)
disable_agent = environ.get(AGENT_REQUEST_SWITCH, None)
if disable_agent:
console.debug("Current trace is disabled with http request environment. %s", environ)
return wrapped(*args, **kwargs)
tracker = Tracer(proxy_instance(), environ, framework)
tracker.generate_trace_id()
tracker.start_work()
def _start_response(status, response_headers, *args):
# deal the response header/data
process_header(tracker, response_headers)
tracker.deal_response(status, response_headers, *args)
_write = start_response(status, response_headers, *args)
return _write
result = []
try:
tracker.set_tracker_name(callable_name(wrapped), priority=1)
application = function_trace_wrapper(wrapped)
console.info("current_tracker:2: %s" % tracker)
with FunctionTracker(tracker, name='Application', group='Python.WSGI'):
result = TingYunWSGIBrowserRumMiddleware(tracker, application, _start_response, environ)() # sunyan: 1
# result = application(environ, start_response)
console.info("wsgi_wrapper_inline<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
except:
console.exception("wsgi_entrance")
tracker.finish_work(*sys.exc_info())
raise
return WSGIApplicationResponse(tracker, result)
def wrapper(wrapped, instance, args, kwargs):
incoming_message = args[0][0]
msg = incoming_message.message
console.info("msg:")
console.info(msg)
ctxt = incoming_message.ctxt
console.info("ctxt:")
console.info(ctxt)
oslo_messaging_trace_id = ctxt['oslo_messaging_trace_id'] if 'oslo_messaging_trace_id' in ctxt else None
tracker = current_tracker()
console.info("oslo_messaging_wrapper_inline>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
console.info("current_tracker:1: %s" % tracker)
if tracker:
console.info("current_tracker:2: None")
console.info("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
return wrapped(*args, **kwargs)
environ = {
'k1': 'v1'
}
tracker = Tracer(proxy_instance(), environ, framework)
if oslo_messaging_trace_id is not None:
tracker._trace_id = oslo_messaging_trace_id
tracker.generate_trace_id()
tracker.start_work()
result = None
try:
tracker.set_tracker_name(callable_name(wrapped), priority=1)
with FunctionTracker(tracker, name='Application', group='Python.oslo_messaging', params=msg['args']):
result = wrapped(*args, **kwargs)
console.info("oslo_messaging_wrapper_inline<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
except:
console.exception("oslo_messaging_entrance")
tracker.finish_work(*sys.exc_info())
raise
else:
tracker.finish_work(None, None, None)
return result
def dynamic_wrapper(wrapped, instance, args, kwargs):
tracker = current_tracker()
if tracker is None:
return wrapped(*args, **kwargs)
_url = url
if callable(url):
if instance is not None:
_url = url(instance, *args, **kwargs)
else:
_url = url(*args, **kwargs)
with ExternalTrace(tracker, library, _url, kwargs):
if not callable(params):
if callable(exception_wrapper):
return exception_wrapper(wrapped, _url, params, *args,
**kwargs)
return wrapped(*args, **kwargs)
else:
_args, _kwargs = params(*args, **kwargs)
if callable(exception_wrapper):
ret = exception_wrapper(wrapped, _url,
_kwargs.get("params"), *_args,
**_kwargs)
else:
ret = wrapped(*_args, **_kwargs)
try:
# for requests/urllib3
if hasattr(ret, 'headers'):
tracker._called_traced_data = eval(
ret.headers.get("X-Tingyun-Tx-Data", '{}'))
# for httplib2, note: the httplib2 will trans the upper case to lower case
if isinstance(ret, tuple):
tracker._called_traced_data = eval(ret[0].get(
"x-tingyun-tx-data", '{}'))
except Exception as err:
console.debug(err)
return ret
def pika_channel_publish_wrapper(wrapped, instance, args, kwargs):
try:
console.info('pika_channel_publish_wrapper before')
console.info(args)
console.info(kwargs)
tracker = current_tracker()
if not tracker:
return wrapped(*args, **kwargs)
tracker.set_tracker_name(callable_name(wrapped), priority=4)
with FunctionTracker(tracker, callable_name(wrapped), params=kwargs):
kwargs['body'] = json.dumps({
'pika_trace_id': tracker._trace_id,
'body': kwargs['body']
})
console.info('pika_channel_publish_wrapper after')
console.info(args)
console.info(kwargs)
return wrapped(*args, **kwargs)
except Exception as e:
console.exception("pika_channel_publish_wrapper error")
def wrapper(wrapped, instance, args, kwargs):
console.info('args:')
console.info(args)
console.info('kwargs:')
console.info(kwargs)
method = args[0]
header = args[1]
body = None
pika_trace_id = None
try:
wrapped_message = json.loads(args[2])
if 'pika_trace_id' in wrapped_message:
pika_trace_id = wrapped_message['pika_trace_id']
body = wrapped_message['body']
else:
body = args[2]
except Exception:
body = args[2]
args = (method, header, body)
params = {
#'method': str(method),
#'header': str(header),
'body': body
}
tracker = current_tracker()
console.info(
"pika_wrapper_inline>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
console.info("current_tracker:1: %s" % tracker)
if tracker:
console.info("current_tracker:2: None")
console.info("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
return wrapped(*args, **kwargs)
environ = {'k1': 'v1'}
tracker = Tracer(proxy_instance(), environ, framework)
if pika_trace_id is not None:
tracker._trace_id = pika_trace_id
tracker.generate_trace_id()
tracker.start_work()
result = None
try:
tracker.set_tracker_name(callable_name(wrapped), priority=1)
with FunctionTracker(tracker,
name='Application',
group='Python.pika',
params=params):
result = wrapped(*args, **kwargs)
console.info(
"pika_wrapper_inline<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
except:
console.exception("pika_wrapper_inline")
tracker.finish_work(*sys.exc_info())
raise
else:
tracker.finish_work(None, None, None)
return result
