def exception_handler(exc, context):
if isinstance(exc, grpc.RpcError):
ex_type, ex, tb = sys.exc_info()
traceback.print_tb(tb)
return default_exception_handler(GRPCError(
detail=f"Error communicating with regitry: {exc.details()}"
), context)
else:
return default_exception_handler(exc, context)
def giro_exception_handler(exc, context):
"""
Returns the response that should be used for any given exception.
"""
exception_response = default_exception_handler(exc, context)
if not hasattr(exception_response, 'data'):
return exception_response
# Hide details from production users.
if 'detail' in exception_response.data and not settings.DEBUG:
del exception_response.data['detail']
# Default to unknown error.
error_code = ErrorCodes.UNKNOWN_ERROR
if hasattr(exc, 'err_code'):
error_code = exc.err_code
elif exc.__class__ in ERR_CODE_MAP:
error_code = ERR_CODE_MAP[exc.__class__]
exception_response.data['code'] = error_code
if hasattr(exc, 'status_code') and exc.status_code == 500:
logging.error(
'Internal Server Error was raised, logging a traceback...')
logging.error(traceback.format_exc(exc))
return exception_response
def exception_handler(exc, context):
if isinstance(exc, APIException):
details = exc.get_full_details()
details['result'] = details['code']
del details['code']
return Response(details, status=exc.status_code)
return default_exception_handler(exc, context)
def exception_handler(exc, context):
# Call REST framework's default exception handler first,
# to get the standard error response.
if isinstance(exc, BusinessException):
response = business_exception_handler(exc, context)
else:
response = default_exception_handler(exc, context)
return response
def exception_handler(exc, context):
response = default_exception_handler(exc, context)
if isinstance(exc, ValidationError) and isinstance(exc.detail, list):
content = {
'validation_errors': exc.detail,
'HTTP-STATUS': exc.status_code
}
response.content = json.dumps(content)
response.status_code = 200
return response
def exception_handler(exc, context):
# Get the standard error response
response = default_exception_handler(exc, context)
if response is None:
if isinstance(exc, ProtectedError):
response = handle_protected_error(exc, context)
elif isinstance(exc, db.IntegrityError):
response = Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)
else:
logger.exception("Caught unhandled exception", exc_info=exc)
return response
def exception_handler(exc, context):
"""
Django REST handles 4xx exceptions itself, so they don't get logged to the
'django.request' logger by default. This exception handler logs them as if
Django was handling them then calls the default Django REST handler. This
makes the project logging behavior more consistent (both 4xx's and 5xx's
are sent to the 'django.request' logger)
"""
res = default_exception_handler(exc, context)
if res is not None and is_client_error(res.status_code):
request = context['request']
logger.warn(
'%s (params: %s) (data: %s) (response: %s)', request.path,
request.query_params, request.data, res.data,
extra={
'status_code': res.status_code, 'request': request
}
)
return res
def exception_handler(exc, context):
"""Default exception handler
Extends the functionality of REST Framework exception handler
(:py:func:`rest_framework.views.exception_handler`) by adding statusCode
field, name of the error and cleaning up ValidationError response data.
"""
response = default_exception_handler(exc, context)
if response is not None:
name = exc.__class__.__name__
if isinstance(exc, ValidationError):
response.data = {'fields': response.data}
# ValidationError is renamed to InvalidRequestData, although these
# two errors are not the same
name = 'InvalidRequestData'
response.data['name'] = name
response.data['statusCode'] = response.status_code
return response
def exception_handler(exc, context):
"""
Django REST handles 4xx exceptions itself, so they don't get logged to the
'django.request' logger by default. This exception handler logs them as if
Django was handling them then calls the default Django REST handler. This
makes the project logging behavior more consistent (both 4xx's and 5xx's
are sent to the 'django.request' logger)
"""
res = default_exception_handler(exc, context)
if res is not None and is_client_error(res.status_code):
request = context['request']
logger.warn('%s (params: %s) (data: %s) (response: %s)',
request.path,
request.query_params,
request.data,
res.data,
extra={
'status_code': res.status_code,
'request': request
})
return res
def custom_exception_handler(exc, context):
exc_type, exc_value, exc_traceback = sys.exc_info()
callstack = '\n'.join(traceback.format_tb(exc_traceback))
errorlist = []
errorlist.append('\n\nRequest URL: %s' % str(context['request']._request))
errorlist.append('Error type: %s' % exc_type)
errorlist.append('Error value: %s' % exc_value)
errorlist.append('Payload: %s' % str(context['request'].query_params))
errorlist.append('Message: %s' % exc.message)
errorlist.append('----Call stack----\n %s' % callstack)
errorlist.append('------Locals------\n %s' %
str(context['request']._request.__dict__))
errormsg = '\n'.join(errorlist)
logger.error(errormsg)
original_response = default_exception_handler(exc, context)
if original_response is not None:
return original_response
return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR,
data=exc.message,
content_type='application/json')
def exception_handler(e, context):
response = default_exception_handler(e, context)
if response is not None:
response.data['status_code'] = response.status_code
return response