Welcome to another course on building web apps with Flask. In this lesson, we will explore the concept of middleware, learn why it is essential in web applications, and implement a custom middleware to log request timing in Flask. By the end of this lesson, you will understand:

• What middleware is and its role in web development.
• How to create middleware using Flask's before_request and after_request decorators.
• How to integrate a middleware into your Flask application.

Through a practical example, you’ll gain hands-on experience in using middleware to monitor the performance of your web application.

Middleware is a piece of software that acts during web request processing. In web development, middleware processes requests before they reach the main application logic or modify responses before they are sent to the client. Tasks such as logging, authentication, and request timing are commonly handled by middleware.

In Flask, middleware is often implemented using the before_request and after_request decorators. These decorators allow you to attach functions that execute before and after each request, respectively.

Let's make this more concrete with an example. Imagine you want to measure how long it takes for your web server to process a request. By creating a timing middleware, you can log the duration of each request automatically.

Here’s what we will do:

1. Record the Start Time: Before processing the request, we'll use the before_request decorator to record the current time. This marks when the request first hits the server.
2. Record the End Time: After processing the request, we'll use the after_request decorator to record the current time again. This marks when the server has finished processing the request and is about to send the response back.
3. Calculate and Log the Duration: By subtracting the start time from the end time, we can calculate the duration of the request. We will then log this information, including the request path and method.

By the end of this section, you will have a middleware that helps you monitor and log the request processing time for your web application.

To get started with our timing middleware, we'll first organize our code in a structured manner. Let's create a new directory called /middlewares within your Flask project. Within this directory, we also create a file named request_timing_logger.py. This will be the foundation for our middleware that measures how long each request takes to process.

Python
Copy to clipboard
1from flask import request, g
2import time
3
4# Function to add timing middleware to our app
5def request_timing_logger(app):
6    # We'll add timing functions here...
7

In this initial setup, we import the necessary components from Flask: request and g. The request object allows us to access details about the incoming HTTP request, and the g object is used to store data that's specific to each request, making it available across different functions during that request's lifecycle. We also bring in the time module, which provides the ability to measure time intervals—key to our task of timing requests. The function request_timing_logger will serve as a container for our timing logic, which we'll build out in the next steps.

With our file set up, the next step is to record the precise moment when each request begins processing. This timing information is essential for calculating the total duration of the request.

Python
Copy to clipboard
1from flask import request, g
2import time
3
4# Function to add timing middleware to our app
5def request_timing_logger(app):
6    # This function runs before each request
7    @app.before_request
8    def start_timer():
9        # Save the current time when the request starts
10        g.start_time = time.time()

Inside the request_timing_logger function, we employ Flask's before_request decorator to register a function named start_timer. This function captures the current time right when the request starts and stores it in g.start_time. The g object is crucial here because it provides a way to keep track of this start time uniquely for each request, ensuring no overlap or confusion between concurrent requests.

To complete our middleware, we'll also need to compute how long each request took and subsequently log the details. This logging provides visibility into each request's performance and helps us monitor and optimize our application.

Python
Copy to clipboard
1from flask import request, g
2import time
3
4# Function to add timing middleware to our app
5def request_timing_logger(app):
6    # This function runs before each request
7    @app.before_request
8    def start_timer():
9        # Save the current time when the request starts
10        g.start_time = time.time()
11
12    # This function runs after each request
13    @app.after_request
14    def log_request_info(response):
15        # Calculate the duration of the request
16        duration = time.time() - g.start_time
17        # Print the request details and duration to the console
18        print("-" * 60)
19        print(f"Path: {request.path} | Method: {request.method} | Duration: {duration:.4f} seconds")
20        print("-" * 60)
21        return response

We add a new function, log_request_info, using Flask's after_request decorator. This ensures that the function executes just after the request is processed but before the response is sent to the client. Here, we calculate the duration of the request by subtracting the start time stored in g.start_time from the current time. We then print this duration along with the request's path and method, formatting the output for clarity. This setup allows us to have a detailed log of how long each request takes, which is invaluable for performance tuning.

Next, let's integrate this middleware into our application. We will pass our Flask app instance to the request_timing_logger function that we defined earlier.

Here is what your main application file, app/app.py, should look like:

Python
Copy to clipboard
1from flask import Flask
2from controllers.todo_controller import todo_controller
3from middlewares.request_timing_logger import request_timing_logger  # Import the timing middleware function
4from models import db
5from config import Config
6
7app = Flask(__name__)
8
9app.config.from_object(Config)
10
11db.init_app(app)
12
13with app.app_context():
14    db.create_all()
15
16# Attach the middleware to the Flask app
17request_timing_logger(app)
18
19app.register_blueprint(todo_controller)
20
21if __name__ == '__main__':
22    app.run(host='0.0.0.0', port=3000, debug=True)

By adding the line request_timing_logger(app), we attach our custom middleware to the Flask application. This means that for every request, the start_timer function will run before the request is processed, and the log_request_info function will run after the response is generated. This allows us to log the duration of each request, providing valuable insight into the performance of our web application.

From now on, when you run the app and make a request, such as a GET request to /, you will see an extra output similar to this in the console:

Plain text
Copy to clipboard
1------------------------------------------------------------
2Path: / | Method: GET | Duration: 0.0351 seconds
3------------------------------------------------------------

This output confirms that your request-timing middleware is functioning correctly. It logs the time it took to process each request, along with the request path and method.

During this request, the request-timing middleware performed the following actions:

1. Start Time Recording: As soon as the request was received, the start_timer function, triggered by the before_request decorator, stored the current time in the g object. This marked the start of request processing.

2. End Time Recording and Logging: After the request was processed and right before the response was sent back to the client, the log_request_info function, triggered by the after_request decorator, calculated the duration by subtracting the recorded start time from the current time. It then logged this duration, along with the request path and method, to the console for monitoring purposes.

Congratulations on completing this lesson! You’ve unlocked the power of middleware in web applications by building your own request-timing logger middleware in Flask. You've mastered the use of before_request and after_request decorators to:

• Record Request Timings: Capture the start and end times of each request.
• Calculate Duration: Compute how long each request takes to process.
• Log Insights: Effectively log this valuable performance data for monitoring.

Now, it's time to take your new skills for a spin! Dive into the practice exercises to solidify your understanding.

You've got this! Happy coding!