def record_exception(exc_info):
# Record the details of any exception ignoring status codes which
# have been configured to be ignored.
import tornado.web
exc = exc_info[0]
value = exc_info[1]
# Not an error so we just return.
if exc is tornado.web.Finish:
return
if exc is tornado.web.HTTPError:
if ignore_status_code(value.status_code):
return
transaction = retrieve_current_transaction()
if transaction:
transaction.record_exception(*exc_info)
else:
# If we are not in a transaction we record the exception to the default
# application specified in the agent configuration.
application = application_instance()
if application and application.enabled:
application.record_exception(*exc_info)
def record_exception(exc_info):
# Record the details of any exception ignoring status codes which
# have been configured to be ignored.
import tornado.web
exc = exc_info[0]
value = exc_info[1]
# Not an error so we just return.
if exc is tornado.web.Finish:
return
if exc is tornado.web.HTTPError:
if ignore_status_code(value.status_code):
return
transaction = retrieve_current_transaction()
if transaction:
transaction.record_exception(*exc_info)
else:
# If we are not in a transaction we record the exception to the default
# application specified in the agent configuration.
application = application_instance()
if application and application.enabled:
application.record_exception(*exc_info)
def initiate_request_monitoring(request):
# Creates a new transaction and associates it with the request.
# We always use the default application specified in the agent
# configuration.
application = application_instance()
# We need to fake up a WSGI like environ dictionary with the key
# bits of information we need.
environ = request_environment(request)
# We now start recording the actual web transaction.
purge_current_transaction()
transaction = WebTransaction(application, environ)
if not transaction.enabled:
return None
transaction.__enter__()
# Immediately purge the transaction from the cache, so we don't associate
# Tornado internals inappropriately with this transaction.
purge_current_transaction()
# We also need to add a reference to the request object in to the
# transaction object so we can later access it in a deferred. We
# need to use a weakref to avoid an object cycle which may prevent
# cleanup of the transaction.
transaction._nr_current_request = weakref.ref(request)
# Records state of transaction
transaction._is_finalized = False
transaction._ref_count = 0
# For requests that complete normally, a transaction can only be closed
# after the `finish()` method is called on both the `_ServerRequestAdapter`
# and the `RequestHandler`.
transaction._request_handler_finalize = False
transaction._server_adapter_finalize = False
# Record framework information for generation of framework metrics.
import tornado
if hasattr(tornado, 'version_info'):
version = '.'.join(map(str, tornado.version_info))
else:
version = None
transaction.add_framework_info('Tornado/ASYNC', version)
return transaction
def initiate_request_monitoring(request):
# Creates a new transaction and associates it with the request.
# We always use the default application specified in the agent
# configuration.
application = application_instance()
# We need to fake up a WSGI like environ dictionary with the key
# bits of information we need.
environ = request_environment(request)
# We now start recording the actual web transaction.
purge_current_transaction()
transaction = WebTransaction(application, environ)
if not transaction.enabled:
return None
transaction.__enter__()
# Immediately purge the transaction from the cache, so we don't associate
# Tornado internals inappropriately with this transaction.
purge_current_transaction()
# We also need to add a reference to the request object in to the
# transaction object so we can later access it in a deferred. We
# need to use a weakref to avoid an object cycle which may prevent
# cleanup of the transaction.
transaction._nr_current_request = weakref.ref(request)
# Records state of transaction
transaction._is_finalized = False
transaction._ref_count = 0
# For server requests We only allow the transaction to be closed when
# either 'finish' or 'on_connection_close' is called on an
# associated HTTPMessageDelegate.
transaction._can_finalize = False
# Record framework information for generation of framework metrics.
import tornado
if hasattr(tornado, 'version_info'):
version = '.'.join(map(str, tornado.version_info))
else:
version = None
transaction.add_framework_info('Tornado/ASYNC', version)
return transaction
def initiate_request_monitoring(request):
# Creates a new transaction and associates it with the request.
# We always use the default application specified in the agent
# configuration.
application = application_instance()
# We need to fake up a WSGI like environ dictionary with the key
# bits of information we need.
environ = request_environment(application, request)
# We now start recording the actual web transaction.
purge_current_transaction()
transaction = WebTransaction(application, environ)
transaction.__enter__()
# Immediately purge the transaction from the cache, so we don't associate
# Tornado internals inappropriately with this transaction.
purge_current_transaction()
# We also need to add a reference to the request object in to the
# transaction object so we can later access it in a deferred. We
# need to use a weakref to avoid an object cycle which may prevent
# cleanup of the transaction.
transaction._nr_current_request = weakref.ref(request)
# Records state of transaction
transaction._is_finalized = False
transaction._ref_count = 0
# For server requests We only allow the transaction to be closed when
# either 'finish' or 'on_connection_close' is called on an
# associated HTTPMessageDelegate.
transaction._can_finalize = False
# Record framework information for generation of framework metrics.
import tornado
if hasattr(tornado, 'version_info'):
version = '.'.join(map(str, tornado.version_info))
else:
version = None
transaction.add_framework_info('Tornado/ASYNC', version)
return transaction
def initiate_request_monitoring(request):
# Creates a new transaction and associates it with the request.
# We always use the default application specified in the agent
# configuration.
application = application_instance()
# We need to fake up a WSGI like environ dictionary with the key
# bits of information we need.
environ = request_environment(application, request)
# We now start recording the actual web transaction. Bail out though
# if it turns out that recording of transactions is not enabled.
transaction = WebTransaction(application, environ)
if not transaction.enabled:
return
if tornado_settings.debug.transaction_monitoring:
global _last_transaction_activation
_last_transaction_activation = ''.join(traceback.format_stack()[:-1])
transaction.__enter__()
request._nr_transaction = transaction
request._nr_wait_function_trace = None
request._nr_request_finished = False
# We also need to add a reference to the request object in to the
# transaction object so we can later access it in a deferred. We
# need to use a weakref to avoid an object cycle which may prevent
# cleanup of the transaction.
transaction._nr_current_request = weakref.ref(request)
# Record framework information for generation of framework metrics.
import tornado
if hasattr(tornado, 'version_info'):
version = '.'.join(map(str, tornado.version_info))
else:
version = None
transaction.add_framework_info('Tornado/ASYNC', version)
return transaction
def initiate_request_monitoring(request):
# Creates a new transaction and associates it with the request.
# We always use the default application specified in the agent
# configuration.
application = application_instance()
# We need to fake up a WSGI like environ dictionary with the key
# bits of information we need.
environ = request_environment(application, request)
# We now start recording the actual web transaction. Bail out though
# if it turns out that recording of transactions is not enabled.
transaction = WebTransaction(application, environ)
if not transaction.enabled:
return
if tornado_settings.debug.transaction_monitoring:
global _last_transaction_activation
_last_transaction_activation = ''.join(traceback.format_stack()[:-1])
transaction.__enter__()
request._nr_transaction = transaction
request._nr_wait_function_trace = None
request._nr_request_finished = False
# We also need to add a reference to the request object in to the
# transaction object so we can later access it in a deferred. We
# need to use a weakref to avoid an object cycle which may prevent
# cleanup of the transaction.
transaction._nr_current_request = weakref.ref(request)
# Record framework information for generation of framework metrics.
import tornado
if hasattr(tornado, 'version_info'):
version = '.'.join(map(str, tornado.version_info))
else:
version = None
transaction.add_framework_info('Tornado/ASYNC', version)
return transaction
