Try to reraise exception from server handlers or otherwise allow logging them

[anuraaga]

We need to handle exceptions to be able to return a error response to the client, but most likely we should see if we can reraise it so the underlying ASGI (and maybe WSGI) servers can present it to the user, or otherwise allow logging it.

Will need to verify this works even though we finish the response. API-wise, ASGI at least allows us to finish the response and then raise the exception, and we would need to see how servers treat that. For WSGI, since the response is closed by finishing the iterable, it may not be possible and we'd need to consider manual logging instead.

#216

[valentimarco]

google library does this when an exception is raise:

_LOGGER = logging.getLogger(__name__)
...
def _call_behavior(
    rpc_event: cygrpc.BaseEvent,
    state: _RPCState,
    behavior: ArityAgnosticMethodHandler,
    argument: Any,
    request_deserializer: Optional[DeserializingFunction],
    send_response_callback: Optional[Callable[[ResponseType], None]] = None,
) -> Tuple[Union[ResponseType, Iterator[ResponseType]], bool]:
    from grpc import _create_servicer_context

    with _create_servicer_context(
        rpc_event, state, request_deserializer
    ) as context:
        try:
            response_or_iterator = None
            if send_response_callback is not None:
                response_or_iterator = behavior(
                    argument, context, send_response_callback
                )
            else:
                response_or_iterator = behavior(argument, context)
            return response_or_iterator, True
        except Exception as exception:  # pylint: disable=broad-except
            with state.condition:
                if state.aborted:
                    _abort(
                        state,
                        rpc_event.call,
                        cygrpc.StatusCode.unknown,
                        b"RPC Aborted",
                    )
                elif exception not in state.rpc_errors:
                    try:
                        details = "Exception calling application: {}".format(
                            exception
                        )
                    except Exception:  # pylint: disable=broad-except
                        details = (
                            "Calling application raised unprintable Exception!"
                        )
                        _LOGGER.exception(
                            traceback.format_exception(
                                type(exception),
                                exception,
                                exception.__traceback__,
                            )
                        )
                        traceback.print_exc()
                    _LOGGER.exception(details)
                    _abort(
                        state,
                        rpc_event.call,
                        cygrpc.StatusCode.unknown,
                        _common.encode(details),
                    )
            return None, False

[anuraaga]

Thanks for the reference! We'll probably need something similar for wsgi.

One more note, we should probably only do this for unrecognized exceptions - ConnectError are errors for the client from the server and I don't think should be logged, at least by default. @valentimarco let us know if that doesn't make sense.

[valentimarco]

like HTTPException of fastapi? in that case make sense