書名： Python Microservices Development
作者名： Tarek Ziadé
本章字數(shù)： 420字
更新時間： 2021-07-02 18:54:23

Custom error handler

When your code does not handle an exception, Flask returns an HTTP 500 response without providing any specific information, like the traceback. Producing a generic error is a safe default behavior to avoid leaking any private information to the users in the error body.

The default 500 response is a simple HTML page along with the right status code:

$ curl http://localhost:5000/api 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> 
<title>500 Internal Server Error</title> 
<h1>Internal Server Error</h1> 
<p>The server encountered an internal error and was unable to complete your request.  Either the server is overloaded or there is an error in the application.</p>

When implementing microservices using JSON, it's a good practice to make sure that every response sent to the clients, including any exception, is JSON formatted. Consumers of your microservice will expect every response to be machine-parseable.

Flask lets you customize the app error handling via a couple of functions. The first one is the @app.errorhandler decorator, which works like @app.route. But instead of providing an endpoint, the decorator links a function to a specific error code.

In the following example, we use it to connect a function that will return a JSON-formatted error when Flask returns a 500 server response (any code exception):

    from flask import Flask, jsonify

    app = Flask(__name__) 
 
    @app.errorhandler(500) 
    def error_handling(error): 
        return jsonify({'Error': str(error)}, 500) 
 
    @app.route('/api') 
    def my_microservice(): 
        raise TypeError("Some Exception") 
 
    if __name__ == '__main__': 
        app.run()

Flask will call this error view no matter what exception the code raises.

However, in case your application issues an HTTP 404 or any other 4xx or 5xx response, you will be back to the default HTML responses that Flask sends.

To make sure your app sends JSON for every 4xx and 50x, we need to register that function to each error code.

One place where you can find the list of errors is in the abort.mapping dict. In the following code snippet, we register the error_handling function to every error using app.register_error_handler, which is similar to the @app.errorhandler decorator:

    from flask import Flask, jsonify, abort 
    from werkzeug.exceptions import HTTPException, default_exceptions
 
    def JsonApp(app): 
        def error_handling(error): 
            if isinstance(error, HTTPException): 
                result = {'code': error.code, 'description': 
                           error.description, 'message': str(error)} 
            else: 
                description = abort.mapping[500].description 
                result = {'code': 500, 'description': description, 
                          'message': str(error)} 
 
            resp = jsonify(result) 
            resp.status_code = result['code'] 
            return resp 
 
        for code in default_exceptions.keys(): 
            app.register_error_handler(code, error_handling) 
 
        return app 
 
    app = JsonApp(Flask(__name__)) 
 
    @app.route('/api') 
    def my_microservice(): 
        raise TypeError("Some Exception") 
 
    if __name__ == '__main__': 
        app.run()

The JsonApp function wraps a Flask app instance, and sets up the custom JSON error handler for every 4xx and 50x error that might occur.

官术网_书友最值得收藏!

Python Microservices Development

Custom error handler