Terminable middleware in Laravel - Mini Project: Build & Apply

Create a Terminable Middleware in Laravel

📖 Scenario: You are building a Laravel web application that needs to log the time taken to handle each HTTP request. You want to create middleware that runs both before and after the response is sent to the browser.

🎯 Goal: Build a terminable middleware in Laravel that logs the request start time before the request is handled and logs the total time taken after the response is sent.

📋 What You'll Learn

Create a middleware class named LogRequestTime

Add a property startTime to store the request start time

Implement the handle method to set startTime and pass the request to the next middleware

Implement the terminate method to calculate and log the total time taken

Register the middleware in app/Http/Kernel.php under the $middleware array

💡 Why This Matters

🌍 Real World

Logging request times helps monitor application performance and identify slow requests in real web applications.

💼 Career

Understanding terminable middleware is important for Laravel developers to run code after responses, useful for logging, cleanup, and analytics.

1

Create the middleware class with a startTime property

Create a middleware class named LogRequestTime in the app/Http/Middleware directory. Add a public property called startTime to store the request start time.

Laravel

<?php

namespace App\Http\Middleware;

class LogRequestTime
{
    // Your code here
}

Hint

Define a class with a public property named startTime.

2

Add the handle method to set startTime and pass the request

Inside the LogRequestTime class, add a public method handle that accepts $request and Closure $next. Set $this->startTime to the current time using microtime(true). Then return $next($request).

Laravel

<?php

namespace App\Http\Middleware;

class LogRequestTime
{
    public $startTime;

    // Add the handle method below
    // Your code here
}

Hint

The handle method runs before the request is processed. Use microtime(true) to get the current time.

3

Add the terminate method to log the total time taken

Add a public method terminate to the LogRequestTime class that accepts $request and $response. Calculate the total time by subtracting $this->startTime from the current time using microtime(true). Use Laravel's logger() helper to log the message: 'Request took ' . $totalTime . ' seconds.'.

Laravel

startTime = microtime(true);
        return $next($request);
    }

    // Add the terminate method below
    // Your code here
}

Hint

The terminate method runs after the response is sent. Use it to log the total time.

4

Register the LogRequestTime middleware in app/Http/Kernel.php

Open app/Http/Kernel.php. Add \App\Http\Middleware\LogRequestTime::class to the $middleware array to register it as global middleware.

Laravel

<?php

namespace App\Http;

use Illuminate\Foundation\Http\Kernel as HttpKernel;

class Kernel extends HttpKernel
{
    protected $middleware = [
        // Add the LogRequestTime middleware below
        // Your code here
    ];
}

Hint

Register the middleware globally by adding it to the $middleware array in the Kernel class.

Practice

1. What is the main purpose of terminable middleware in Laravel?

easy

A. To validate user input before processing

B. To modify the HTTP request before it reaches the controller

C. To handle database migrations automatically

D. To run code after the HTTP response has been sent to the user

Solution

1. Step 1: Understand middleware timing

   Terminable middleware runs after the response is sent, unlike regular middleware that runs before.

2. Step 2: Identify terminable middleware purpose

   It is used for tasks like logging or cleanup after response delivery.

3. Final Answer:

   To run code after the HTTP response has been sent to the user -> Option D

4. Quick Check:

   Terminable middleware = post-response code [OK]

Hint: Terminable middleware runs after response is sent [OK]

Common Mistakes:

• Confusing terminable middleware with regular middleware
• Thinking it runs before the controller
• Assuming it handles request validation

2. Which method must be implemented in a Laravel terminable middleware class?

easy

A. handle

B. process

C. terminate

D. finish

Solution

1. Step 1: Recall terminable middleware interface

   Terminable middleware requires a terminate method to run code after response.

2. Step 2: Differentiate from handle method

   handle runs before response, terminate runs after.

3. Final Answer:

   terminate -> Option C

4. Quick Check:

   Post-response method = terminate [OK]

Hint: Terminate method runs after response in terminable middleware [OK]

Common Mistakes:

• Using handle instead of terminate for post-response code
• Assuming process or finish are valid methods
• Not implementing terminate method at all

3. Given this terminable middleware code, what will be logged after the response is sent?

class LogAfterResponse {
    public function handle($request, Closure $next) {
        return $next($request);
    }
    public function terminate($request, $response) {
        Log::info('Response sent with status: ' . $response->status());
    }
}

medium

A. Logs the request URL before sending the response

B. Logs the response status code after sending the response

C. Throws an error because terminate method is missing parameters

D. Does nothing because terminate is not called automatically

Solution

1. Step 1: Analyze handle method

   The handle method passes the request to next middleware/controller without changes.

2. Step 2: Analyze terminate method

   After response is sent, terminate logs the response status code using Log::info.

3. Final Answer:

   Logs the response status code after sending the response -> Option B

4. Quick Check:

   terminate logs status post-response [OK]

Hint: Terminate runs after response, so logs status then [OK]

Common Mistakes:

• Thinking terminate runs before response
• Assuming terminate is not called automatically
• Confusing request and response parameters

4. Identify the error in this terminable middleware code:

class CleanupMiddleware {
    public function handle($request, Closure $next) {
        return $next($request);
    }
    public function terminate() {
        // cleanup code here
    }
}

medium

A. terminate method must accept $request and $response parameters

B. handle method must return a string, not a response

C. terminate method should be named handleTerminate

D. handle method must not call $next

Solution

1. Step 1: Check terminate method signature

   Terminable middleware's terminate method must accept both $request and $response parameters.

2. Step 2: Identify missing parameters

   The code's terminate method has no parameters, which will cause errors.

3. Final Answer:

   terminate method must accept $request and $response parameters -> Option A

4. Quick Check:

   terminate signature requires request and response [OK]

Hint: Terminate method needs both request and response parameters [OK]

Common Mistakes:

• Omitting parameters in terminate method
• Renaming terminate method incorrectly
• Misunderstanding handle method return type

5. You want to log the total time taken to process a request including after the response is sent. How would you implement this using terminable middleware?

class RequestTimer {
    protected $startTime;

    public function handle($request, Closure $next) {
        $this->startTime = microtime(true);
        return $next($request);
    }

    public function terminate($request, $response) {
        // What code should go here?
    }
}

hard

A. $duration = microtime(true) - $this->startTime;
\Log::info('Request took ' . $duration . ' seconds');

B. $duration = microtime(true) + $this->startTime;
\Log::info('Request took ' . $duration . ' seconds');

C. return $this->startTime; // terminate must return a value

D. Call $this->handle($request, $next) again inside terminate

Solution

1. Step 1: Calculate duration in terminate method

   Use current time minus stored start time to get total duration.

2. Step 2: Log the duration

   Use Log::info to record the time taken after response is sent.

3. Final Answer:

   $duration = microtime(true) - $this->startTime; \Log::info('Request took ' . $duration . ' seconds'); -> Option A

4. Quick Check:

   Duration = now - startTime, then log [OK]

Hint: Subtract start time from current time in terminate to get duration [OK]

Common Mistakes:

• Adding times instead of subtracting
• Returning values from terminate method
• Calling handle method inside terminate