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)