def _nr_wrap_GeneratedProtocolMessageType(wrapped, instance, args, kwargs):
wrapped(*args, **kwargs)
instance.SerializeToString = FunctionTraceWrapper(
instance.SerializeToString)
instance.FromString = staticmethod(FunctionTraceWrapper(
instance.FromString))
def wrap_exception_handler(wrapped, instance, args, kwargs):
if is_coroutine_function(wrapped):
return wrap_exception_handler_async(FunctionTraceWrapper(wrapped)(*args, **kwargs), bind_exc(*args, **kwargs))
else:
with ContextOf(request=bind_request(*args, **kwargs)):
response = FunctionTraceWrapper(wrapped)(*args, **kwargs)
record_response_error(response, bind_exc(*args, **kwargs))
return response
def wrap_middleware(wrapped, instance, args, kwargs):
result = wrapped(*args, **kwargs)
dispatch_func = getattr(result, "dispatch_func", None)
name = dispatch_func and callable_name(dispatch_func)
return FunctionTraceWrapper(result, name=name)
def close(self):
if self.closed:
return
if self.response_trace:
self.response_trace.__exit__(None, None, None)
self.response_trace = None
try:
with FunctionTrace(name='Finalize', group='Python/WSGI'):
if isinstance(self.generator, _WSGIApplicationMiddleware):
self.generator.close()
elif hasattr(self.generator, 'close'):
FunctionTraceWrapper(self.generator.close)()
except: # Catch all
self.transaction.__exit__(*sys.exc_info())
raise
else:
self.transaction.__exit__(None, None, None)
self.transaction._sent_end = time.time()
finally:
self.closed = True
def wrap_run_endpoint_function(wrapped, instance, args, kwargs):
trace = current_trace()
if trace and trace.transaction:
dependant = kwargs["dependant"]
name = callable_name(dependant.call)
trace.transaction.set_transaction_name(name)
if not kwargs["is_coroutine"]:
dependant = kwargs["dependant"] = copy(dependant)
dependant.call = use_context(trace)(FunctionTraceWrapper(
dependant.call))
return wrapped(*args, **kwargs)
else:
return FunctionTraceWrapper(wrapped, name=name)(*args, **kwargs)
return wrapped(*args, **kwargs)
def wrap_route(wrapped, instance, args, kwargs):
path, endpoint, args, kwargs = bind_endpoint(*args, **kwargs)
endpoint = FunctionTraceWrapper(endpoint)
# Starlette name detection gets a bit confused with our wrappers
# so the get_name function should be called and the result should
# be cached on the wrapper.
try:
if not hasattr(endpoint, "__name__"):
from starlette.routing import get_name
endpoint.__name__ = get_name(endpoint.__wrapped__)
except Exception:
pass
endpoint = route_naming_wrapper(endpoint)
return wrapped(path, endpoint, *args, **kwargs)
def _nr_wrapper_Blueprint_teardown_request_(wrapped, instance, args, kwargs):
def _params(f, *args, **kwargs):
return f, args, kwargs
f, _args, _kwargs = _params(*args, **kwargs)
f = FunctionTraceWrapper(f)
return wrapped(f, *_args, **_kwargs)
def _nr_wrapper_Flask_after_request_(wrapped, instance, args, kwargs):
def _params(f, *args, **kwargs):
return f, args, kwargs
f, _args, _kwargs = _params(*args, **kwargs)
f = FunctionTraceWrapper(f)
return wrapped(f, *_args, **_kwargs)
def _nr_wrapper_Flask_teardown_appcontext_(wrapped, instance, args, kwargs):
def _params(f, *args, **kwargs):
return f, args, kwargs
f, _args, _kwargs = _params(*args, **kwargs)
f = FunctionTraceWrapper(f)
return wrapped(f, *_args, **_kwargs)
def _wrapper(wrapped, instance, args, kwargs):
transaction = current_transaction()
if transaction is None:
return wrapped(*args, **kwargs)
transaction.set_transaction_name(name, priority=2)
return FunctionTraceWrapper(wrapped, name=name)(*args, **kwargs)
def callback_wrapper(wrapped, instance, args, kwargs):
name = callable_name(wrapped)
transaction = current_transaction(active_only=False)
if transaction and (transaction.ignore_transaction
or transaction.stopped):
return wrapped(*args, **kwargs)
elif transaction:
return FunctionTraceWrapper(wrapped, name=name)(*args,
**kwargs)
else:
if hasattr(channel, '_nr_disable_txn_tracing'):
return wrapped(*args, **kwargs)
# Keyword arguments are unknown since this is a user
# defined callback
exchange = 'Unknown'
routing_key = None
headers = None
reply_to = None
correlation_id = None
unknown_kwargs = False
if not kwargs:
method, properties = args[1:3]
exchange = method.exchange or 'Default'
routing_key = getattr(method, 'routing_key', None)
if properties is not None:
headers = getattr(properties, 'headers', None)
reply_to = getattr(properties, 'reply_to', None)
correlation_id = getattr(properties, 'correlation_id',
None)
else:
unknown_kwargs = True
with MessageTransaction(application=application_instance(),
library='RabbitMQ',
destination_type='Exchange',
destination_name=exchange,
routing_key=routing_key,
headers=headers,
queue_name=queue,
reply_to=reply_to,
correlation_id=correlation_id,
source=wrapped) as mt:
# Improve transaction naming
_new_txn_name = 'RabbitMQ/Exchange/%s/%s' % (exchange,
name)
mt.set_transaction_name(_new_txn_name, group='Message')
# Record that something went horribly wrong
if unknown_kwargs:
m = mt._transaction_metrics.get(KWARGS_ERROR, 0)
mt._transaction_metrics[KWARGS_ERROR] = m + 1
return wrapped(*args, **kwargs)
def __enter__(self):
FunctionTraceWrapper(self.__wrapped__.__enter__)()
# Must return a reference to self as otherwise will be
# returning the inner connection object. If 'as' is used
# with the 'with' statement this will mean no longer
# using the wrapped connection object and nothing will be
# tracked.
return self
def _nr_wrapper_Flask_before_request_wrapped_(wrapped, instance, args, kwargs):
transaction = current_transaction()
if transaction is None:
return wrapped(*args, **kwargs)
name = callable_name(wrapped)
transaction.set_transaction_name(name)
return FunctionTraceWrapper(wrapped, name=name)(*args, **kwargs)
def wrapper_Resource_method(wrapped, instance, args, kwargs):
transaction = current_transaction()
if transaction is None:
return wrapped(*args, **kwargs)
name = callable_name(wrapped)
transaction.set_transaction_name(name)
return FunctionTraceWrapper(wrapped, name=name)(*args, **kwargs)
def inner_fn_wrapper(inner_fn, instance, args, kwargs):
transaction = current_transaction()
if transaction is None or name is None:
return inner_fn(*args, **kwargs)
transaction.set_transaction_name(name, group, priority=5)
# django's exception handling will record errors here
return FunctionTraceWrapper(inner_fn, name=name, group=group)(*args,
**kwargs)
def wrap_run_endpoint_function(wrapped, instance, args, kwargs):
trace = current_trace()
if trace and trace.transaction:
dependant = kwargs["dependant"]
name = callable_name(dependant.call)
trace.transaction.set_transaction_name(name)
dependant = kwargs["dependant"] = copy(dependant)
dependant.call = FunctionTraceWrapper(dependant.call)
return wrapped(*args, **kwargs)
return wrapped(*args, **kwargs)
def handler_wrapper(wrapped, instance, args, kwargs):
transaction = current_transaction()
# Name the web transaction after the handler function.
name = callable_name(wrapped)
transaction.set_transaction_name(name=name)
# Track how long is spent in the handler and record any exceptions
# except those which are used for controlling the actions of the
# application.
return FunctionTraceWrapper(wrapped, name=name)(*args, **kwargs)
def wrap_trailing_middleware(middleware):
# Wrapper to be applied to trailing middleware executed
# after the view handler. Records the time spent in the
# middleware as separate function node. Transaction is never
# named after these middleware.
#
# The middleware if a class method would already be
# bound at this point, so is safe to determine the name
# when it is being wrapped rather than on each
# invocation.
for wrapped in middleware:
yield FunctionTraceWrapper(wrapped, name=callable_name(wrapped))
def _nr_wrapper_Flask_handle_exception_(wrapped, instance, args, kwargs):
transaction = current_transaction()
if transaction is None:
return wrapped(*args, **kwargs)
# The Flask.handle_exception() method is always called in the
# context of the except clause of the try block. We can therefore
# rely on grabbing current exception details so we have access to
# the addition stack trace information.
notice_error(status_code=status_code)
name = callable_name(wrapped)
return FunctionTraceWrapper(wrapped, name=name)(*args, **kwargs)
def _nr_wrapper_Flask_handle_http_exception_(wrapped, instance, args, kwargs):
transaction = current_transaction()
if transaction is None:
return wrapped(*args, **kwargs)
name = callable_name(wrapped)
# Because we use priority=1, this name will only be used in cases
# where an error handler was called without an actual request
# handler having already being called.
transaction.set_transaction_name(name, priority=1)
return FunctionTraceWrapper(wrapped, name=name)(*args, **kwargs)
def _nr_wrapper_django_template_base_InclusionNode_render_(
wrapped, instance, args, kwargs):
if wrapped.__self__ is None:
return wrapped(*args, **kwargs)
file_name = getattr(wrapped.__self__, '_nr_file_name', None)
if file_name is None:
return wrapped(*args, **kwargs)
name = wrapped.__self__._nr_file_name
return FunctionTraceWrapper(wrapped, name=name,
group='Template/Include')(*args, **kwargs)
def _nr_wrapper_django_inclusion_tag_wrapper_(wrapped, instance, args, kwargs):
name = hasattr(wrapped, '__name__') and wrapped.__name__
if name is None:
return wrapped(*args, **kwargs)
qualname = callable_name(wrapped)
tags = django_settings.instrumentation.templates.inclusion_tag
if '*' not in tags and name not in tags and qualname not in tags:
return wrapped(*args, **kwargs)
return FunctionTraceWrapper(wrapped, name=name,
group='Template/Tag')(*args, **kwargs)
def get(self, status, default=None):
transaction = current_transaction()
if transaction is None:
return self.__wrapped__.get(status, default)
handler = self.__wrapped__.get(status)
if handler:
name = callable_name(handler)
transaction.set_transaction_name(name, priority=1)
handler = FunctionTraceWrapper(handler, name=name)
else:
transaction.set_transaction_name(str(status),
group='StatusCode', priority=1)
return handler or default
def _nr_wrapper_Flask_try_trigger_before_first_request_functions_(wrapped, instance, args, kwargs):
transaction = current_transaction()
if transaction is None:
return wrapped(*args, **kwargs)
if not instance.before_first_request_funcs:
return wrapped(*args, **kwargs)
if instance._got_first_request:
return wrapped(*args, **kwargs)
name = callable_name(wrapped)
transaction.set_transaction_name(name)
return FunctionTraceWrapper(wrapped, name=name)(*args, **kwargs)
def wrapper(wrapped, instance, args, kwargs):
transaction = current_transaction()
if transaction is None:
return wrapped(*args, **kwargs)
def _wrapped(request, resolver, exc_info):
transaction.set_transaction_name(name, priority=1)
notice_error(exc_info)
try:
return wrapped(request, resolver, exc_info)
except: # Catch all
notice_error()
raise
return FunctionTraceWrapper(_wrapped, name=name)(*args, **kwargs)
def callback_wrapper(callback, _instance, _args, _kwargs):
transaction = current_transaction()
if transaction is None:
return callback(*_args, **_kwargs)
if not _kwargs:
method, properties = _args[1:3]
start_time = getattr(callback_wrapper, '_nr_start_time', None)
_add_consume_rabbitmq_trace(transaction,
method=method,
properties=properties,
nr_start_time=start_time,
queue_name=queue)
else:
m = transaction._transaction_metrics.get(KWARGS_ERROR, 0)
transaction._transaction_metrics[KWARGS_ERROR] = m + 1
name = callable_name(callback)
return FunctionTraceWrapper(callback, name=name)(*_args, **_kwargs)
def _test():
FunctionTraceWrapper(func)(*args)
def wrap_route(wrapped, instance, args, kwargs):
path, endpoint, args, kwargs = bind_endpoint(*args, **kwargs)
endpoint = route_naming_wrapper(FunctionTraceWrapper(endpoint))
return wrapped(path, endpoint, *args, **kwargs)
def error_middleware_wrapper(wrapped, instance, args, kwargs):
transaction = current_transaction()
if transaction:
transaction.set_transaction_name(callable_name(wrapped), priority=1)
return FunctionTraceWrapper(wrapped)(*args, **kwargs)
def _nr_wrapper_BaseCommand___init___(wrapped, instance, args, kwargs):
instance.handle = FunctionTraceWrapper(instance.handle)
if hasattr(instance, 'handle_noargs'):
instance.handle_noargs = FunctionTraceWrapper(instance.handle_noargs)
return wrapped(*args, **kwargs)
