def dispatch_request(self, msg):
loglevel = self._get_loglevel(msg)
logger.log(loglevel, '%s source=%s', msg.subject, msg.source)
start = time.time()
self.request_counts.incr(subject=msg.subject)
channel = ReplyChannel(msg, self)
service_name, func_name = msg.subject.rsplit('.', 1)
try:
service = self.container.installed_interfaces[service_name]
except KeyError:
logger.warning('unsupported service type: %s', service_name)
return
try:
service.handle_request(func_name, channel)
except Exception:
logger.exception('Request error:')
exc_info = sys.exc_info()
extra_info = {
'service': service_name,
'func_name': func_name,
'trace_id': trace.get_id(),
}
try:
self.container.error_hook(exc_info, extra=extra_info)
except:
logger.exception('error hook failure')
finally:
del exc_info
try:
channel.nack(True)
except:
logger.exception('failed to send automatic NACK')
finally:
elapsed = time.time() - start
logger.log(loglevel, 'subject=%s duration=%f (seconds)', msg.subject, elapsed)
def handle_request(self, channel):
interface_name, func_name = channel.request.subject.rsplit(".", 1)
try:
interface = self.installed_interfaces[interface_name]
except KeyError:
logger.warning("unsupported service type: %s", interface_name)
channel.nack(True)
return
try:
interface.handle_request(func_name, channel)
except Exception:
logger.exception("Request error:")
exc_info = sys.exc_info()
try:
self.error_hook(
exc_info,
extra={
"service": self.service_name,
"interface": interface_name,
"func_name": func_name,
"trace_id": trace.get_id(),
},
)
finally:
del exc_info
try:
channel.nack(True)
except:
logger.exception("failed to send automatic NACK")
def prepare_headers(self, headers, **extra_headers):
if headers:
headers.update(extra_headers)
else:
headers = extra_headers
headers.setdefault('trace_id', trace.get_id())
return headers
def handle_request(self, channel):
interface_name, func_name = channel.request.subject.rsplit('.', 1)
version = channel.request.version
if version:
version = semantic_version.Version(version)
try:
versions = self.installed_interfaces[interface_name]
except KeyError:
logger.warning('Unsupported interface: %s', interface_name)
channel.nack(True)
return
try:
interface = versions[version]
except KeyError:
logger.warning('Unsupported version: %s@%s', interface_name, version)
channel.nack(True)
return
try:
interface.handle_request(func_name, channel)
except Exception:
logger.exception('Request error:')
exc_info = sys.exc_info()
try:
self.error_hook(exc_info, extra={
'service': self.service_name,
'interface': interface_name,
'func_name': func_name,
'trace_id': trace.get_id(),
})
finally:
del exc_info
try:
channel.nack(True)
except:
logger.exception('failed to send automatic NACK')
def handle(self, request, rule, kwargs):
try:
self.container.http_request_hook(request, rule, kwargs)
handler = self.get_handler(request, rule)
if hasattr(handler, "dispatch"):
response = handler.dispatch(kwargs)
else:
response = handler(request, **kwargs)
if not isinstance(response, Response):
raise TypeError("%r is not a valid response - expected werkzeug.wrappers.Response instance" % response)
except MethodNotAllowed:
response = self.MethodNotAllowed().get_response(request.environ)
except HTTPException as e:
response = e.get_response(request.environ)
except Exception as e:
if hasattr(e, "to_http_response"):
response = e.to_http_response(request.environ)
else:
if not self.container.debug:
logger.exception("uncaught exception")
exc_info = sys.exc_info()
extra_info = {"url": request.url, "trace_id": trace.get_id(), "interface": self.__class__.__name__}
try:
self.container.error_hook(exc_info, extra=extra_info)
except:
logger.exception("error hook failure")
finally:
del exc_info
if self.container.debug:
raise
response = Response("", status=500)
return response
def handle(self, request, rule, kwargs):
try:
self.container.http_request_hook(request, rule, kwargs)
handler = self.get_handler(request, rule)
if hasattr(handler, "dispatch"):
response = handler.dispatch(kwargs)
else:
response = handler(request, **kwargs)
except MethodNotAllowed:
response = self.MethodNotAllowed().get_response(request.environ)
except HTTPException as e:
response = e.get_response(request.environ)
except Exception as e:
if hasattr(e, 'to_http_response'):
response = e.to_http_response(request.environ)
else:
if not self.container.debug:
logger.exception('uncaught exception')
exc_info = sys.exc_info()
extra_info = {
'url': request.url,
'trace_id': trace.get_id(),
'interface': self.__class__.__name__,
}
try:
self.container.error_hook(exc_info, extra=extra_info)
except:
logger.exception('error hook failure')
finally:
del exc_info
if self.container.debug:
raise
response = Response('', status=500)
return response
def dispatch_request(self, request):
logger.info('%s %s', request.method, request.path)
urls = self.url_map.bind_to_environ(request.environ)
request.urls = urls
try:
rule, kwargs = request.urls.match(return_rule=True)
handler = self.get_handler(request, rule)
if hasattr(handler, "dispatch"):
response = handler.dispatch(kwargs)
else:
response = handler(request, **kwargs)
except HTTPException as e:
response = e.get_response(request.environ)
except Exception as e:
if hasattr(e, 'to_http_response'):
response = e.to_http_response(request.environ)
else:
if not self.container.debug:
logger.exception('uncaught exception')
exc_info = sys.exc_info()
extra_info = {
'url': request.url,
'trace_id': trace.get_id(),
'interface': self.__class__.__name__,
}
try:
self.container.error_hook(exc_info, extra=extra_info)
except:
logger.exception('error hook failure')
finally:
del exc_info
if self.container.debug:
raise
response = Response('', status=500)
return response
def handle_request(self, channel):
interface_name, func_name = channel.request.subject.rsplit('.', 1)
try:
interface = self.installed_interfaces[interface_name]
except KeyError:
logger.warning('unsupported service type: %s', interface_name)
channel.nack(True)
return
try:
interface.handle_request(func_name, channel)
except Exception:
logger.exception('Request error:')
exc_info = sys.exc_info()
try:
self.error_hook(exc_info,
extra={
'service': self.service_name,
'interface': interface_name,
'func_name': func_name,
'trace_id': trace.get_id(),
})
finally:
del exc_info
try:
channel.nack(True)
except:
logger.exception('failed to send automatic NACK')
def prepare_headers(self, headers, **extra_headers):
if headers:
headers.update(extra_headers)
else:
headers = extra_headers
headers.setdefault('trace_id', trace.get_id())
return headers
def dispatch_request(self, request):
logger.info('%s %s', request.method, request.path)
urls = self.url_map.bind_to_environ(request.environ)
request.urls = urls
try:
rule, kwargs = request.urls.match(return_rule=True)
handler = self.get_handler(request, rule)
if hasattr(handler, "dispatch"):
response = handler.dispatch(kwargs)
else:
response = handler(request, **kwargs)
except HTTPException as e:
response = e.get_response(request.environ)
except Exception as e:
if hasattr(e, 'to_http_response'):
response = e.to_http_response(request.environ)
else:
if not self.container.debug:
logger.exception('uncaught exception')
exc_info = sys.exc_info()
extra_info = {
'url': request.url,
'trace_id': trace.get_id(),
'interface': self.__class__.__name__,
}
try:
self.container.error_hook(exc_info, extra=extra_info)
except:
logger.exception('error hook failure')
finally:
del exc_info
if self.container.debug:
raise
response = Response('', status=500)
return response
def emit_event(self, event_type, payload, headers=None, **kwargs):
headers = headers or {}
headers.setdefault('trace_id', trace.get_id())
event = Event(event_type,
payload,
source=self.identity,
headers=headers)
self.events.emit(event, **kwargs)
def dispatch_request(self, request):
trace.set_id()
logger.info('%s %s', request.method, request.path)
urls = self.url_map.bind_to_environ(request.environ)
request.urls = urls
try:
rule, kwargs = request.urls.match(method=request.method, return_rule=True)
except NotFound:
response = self.NotFound().get_response(request.environ)
except MethodNotAllowed:
response = self.MethodNotAllowed().get_response(request.environ)
except HTTPException as ex:
response = ex.get_response(request.environ)
else:
response = self.handle(request, rule, kwargs)
response.headers['X-Trace-Id'] = trace.get_id()
return response
def dispatch_request(self, request):
trace.set_id()
logger.info('%s %s', request.method, request.path)
urls = self.url_map.bind_to_environ(request.environ)
request.urls = urls
try:
rule, kwargs = request.urls.match(method=request.method, return_rule=True)
except NotFound:
response = self.NotFound().get_response(request.environ)
except MethodNotAllowed:
response = self.MethodNotAllowed().get_response(request.environ)
except HTTPException as ex:
response = ex.get_response(request.environ)
else:
response = self.handle(request, rule, kwargs)
response.headers['X-Trace-Id'] = trace.get_id()
return response
def dispatch_request(self, request):
if self.request_trace_id_header:
trace_id = request.headers.get(self.request_trace_id_header)
else:
trace_id = None
trace.set_id(trace_id)
logger.info("%s %s", request.method, request.path)
urls = self.url_map.bind_to_environ(request.environ)
request.urls = urls
try:
rule, kwargs = request.urls.match(method=request.method, return_rule=True)
except NotFound:
response = self.NotFound().get_response(request.environ)
except MethodNotAllowed:
response = self.MethodNotAllowed().get_response(request.environ)
except HTTPException as ex:
response = ex.get_response(request.environ)
else:
response = self.handle(request, rule, kwargs)
response.headers[self.response_trace_id_header] = trace.get_id()
return response
def handle(self, request, rule, kwargs):
try:
self.container.http_request_hook(request, rule, kwargs)
handler = self.get_handler(request, rule)
if hasattr(handler, "dispatch"):
response = handler.dispatch(kwargs)
else:
response = handler(request, **kwargs)
if not isinstance(response, Response):
raise TypeError(
'%r is not a valid response - expected werkzeug.wrappers.Response instance'
% response)
except MethodNotAllowed:
response = self.MethodNotAllowed().get_response(request.environ)
except HTTPException as e:
response = e.get_response(request.environ)
except Exception as e:
if hasattr(e, 'to_http_response'):
response = e.to_http_response(request.environ)
else:
if not self.container.debug:
logger.exception('uncaught exception')
exc_info = sys.exc_info()
extra_info = {
'url': request.url,
'trace_id': trace.get_id(),
'interface': self.__class__.__name__,
}
try:
self.container.error_hook(exc_info, extra=extra_info)
except:
logger.exception('error hook failure')
finally:
del exc_info
if self.container.debug:
raise
response = Response('', status=500)
return response
def on_error(self, exc_info, **kwargs):
newrelic.agent.add_custom_parameter('trace_id', trace.get_id())
newrelic.agent.record_exception(exc_info)
def wrapped(*args, **kwargs):
newrelic.agent.add_custom_parameter('trace_id', trace.get_id())
return func(*args, **kwargs)
def get_trace_id(self):
return trace.get_id()
def wrapped(*args, **kwargs):
newrelic.agent.add_custom_parameter('trace_id', trace.get_id())
return func(*args, **kwargs)
def on_error(self, exc_info, **kwargs):
newrelic.agent.add_custom_parameter('trace_id', trace.get_id())
newrelic.agent.record_exception(exc_info)
def emit_event(self, event_type, payload, headers=None, **kwargs):
headers = headers or {}
headers.setdefault('trace_id', trace.get_id())
event = Event(event_type, payload, source=self.identity, headers=headers)
self.events.emit(event, **kwargs)
def on_http_request(self, request, rule, kwargs):
newrelic.agent.set_transaction_name("%s %s" % (request.method, rule))
newrelic.agent.add_custom_parameter('trace_id', trace.get_id())
def get_trace_id(self):
return trace.get_id()
def test_trace_id_propagates_via_deferred_rpc(self):
trace_id = trace.get_id()
self.assertEqual(trace_id, self.client.get_trace_id.defer().get())
def on_http_request(self, request, rule, kwargs):
newrelic.agent.set_transaction_name("%s %s" % (request.method, rule))
newrelic.agent.add_custom_parameter('trace_id', trace.get_id())
def prepare_headers(self, headers):
headers = headers or {}
headers.setdefault('trace_id', trace.get_id())
return headers
def set_trace_id_to_response(response):
response.headers[self.response_trace_id_header] = trace.get_id()
return response
def prepare_headers(self, headers):
headers = headers or {}
headers.setdefault('trace_id', trace.get_id())
return headers
def test_trace_id_propagates_via_deferred_rpc(self):
trace_id = trace.get_id()
self.assertEqual(trace_id, self.client.get_trace_id.defer().get())
