Implementing a Timer Middleware

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.

Understanding Middleware

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.

Timer Example

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: 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. 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. 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.

Creating a Middleware File

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Adding an After Request Function

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

from flask import request, g
import time

# Function to add timing middleware to our app
def request_timing_logger(app):
    # This function runs before each request
    @app.before_request
    def start_timer():
        # Save the current time when the request starts
        g.start_time = time.time()

    # This function runs after each request
    @app.after_request
    def log_request_info(response):
        # Calculate the duration of the request
        duration = time.time() - g.start_time
        # Print the request details and duration to the console
        print("-" * 60)
        print(f"Path: {request.path} | Method: {request.method} | Duration: {duration:.4f} seconds")
        print("-" * 60)
        return response

from flask import request, g
import time

# Function to add timing middleware to our app
def request_timing_logger(app):
    # This function runs before each request
    @app.before_request
    def start_timer():
        # Save the current time when the request starts
        g.start_time = time.time()

    # This function runs after each request
    @app.after_request
    def log_request_info(response):
        # Calculate the duration of the request
        duration = time.time() - g.start_time
        # Print the request details and duration to the console
        print("-" * 60)
        print(f"Path: {request.path} | Method: {request.method} | Duration: {duration:.4f} seconds")
        print("-" * 60)
        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.