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

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 from flask import request, g import time # Function to add timing middleware to our app def request_timing_logger(app): # We'll add timing functions here... from flask import request, g import time # Function to add timing middleware to our app def request_timing_logger(app): # We'll add timing functions here... 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.

Join the 1M+ learners on CodeSignal

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

Python

from flask import request, g
import time

# Function to add timing middleware to our app
def request_timing_logger(app):
    # We'll add timing functions here...

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()

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()

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

Python

from flask import Flask
from controllers.todo_controller import todo_controller
from middlewares.request_timing_logger import request_timing_logger  # Import the timing middleware function
from models import db
from config import Config

app = Flask(__name__)

app.config.from_object(Config)

db.init_app(app)

with app.app_context():
    db.create_all()

# Attach the middleware to the Flask app
request_timing_logger(app)

app.register_blueprint(todo_controller)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=3000, debug=True)

from flask import Flask
from controllers.todo_controller import todo_controller
from middlewares.request_timing_logger import request_timing_logger  # Import the timing middleware function
from models import db
from config import Config

app = Flask(__name__)

app.config.from_object(Config)

db.init_app(app)

with app.app_context():
    db.create_all()

# Attach the middleware to the Flask app
request_timing_logger(app)

app.register_blueprint(todo_controller)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=3000, debug=True)

text

------------------------------------------------------------
Path: / | Method: GET | Duration: 0.0351 seconds
------------------------------------------------------------

------------------------------------------------------------
Path: / | Method: GET | Duration: 0.0351 seconds
------------------------------------------------------------

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()

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

Python

from flask import Flask
from controllers.todo_controller import todo_controller
from middlewares.request_timing_logger import request_timing_logger  # Import the timing middleware function
from models import db
from config import Config

app = Flask(__name__)

app.config.from_object(Config)

db.init_app(app)

with app.app_context():
    db.create_all()

# Attach the middleware to the Flask app
request_timing_logger(app)

app.register_blueprint(todo_controller)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=3000, debug=True)

text

------------------------------------------------------------
Path: / | Method: GET | Duration: 0.0351 seconds
------------------------------------------------------------

Implementing a Timer Middleware

Understanding Middleware

Timer Example

Creating a Middleware File

Join the 1M+ learners on CodeSignal

Adding a Before Request Function

Adding an After Request Function

Setting Up the Middleware

Testing the Middleware

Summary and Next Steps