Building web apps is all about making sure users don’t wait forever for a response. Handling long-running requests in Express.js is a key part of this. Sometimes, things take longer than we expect, and we don’t want folks stuck in limbo. That’s why setting up request timeouts in your app is a solid move. It helps keep your server agile and responsive.

Request timeouts are like little guards for your server. They shout “time is up!” when a request takes too long. This is super useful when dealing with routes that might hang, leaving the browser clueless about what’s going on. Imagine a situation where a route handler doesn’t call back or send a response—yep, the client will be left waiting forever. Not cool, right?

So, how do we set these timeouts in Express.js? Well, you can whip up some middleware to set a timeout for incoming requests. Take a peek at this simple setup:

const express = require('express');
const app = express();
const port = 3000;

// Middleware for request timeout
app.use((req, res, next) => {
    res.setTimeout(2000, () => {
        console.log('Request has timed out.');
        res.sendStatus(408); // Sending 408 Request Timeout status code
    });
    next();
});

app.get('/', (req, res) => {
    // This route might take time to respond
});

app.listen(port, () => {
    console.log(`Server listening on port ${port}`);
});

In this example, the res.setTimeout method is doing its magic by setting a timeout of 2 seconds for all the incoming requests. If things aren’t done within this timeframe, the server sends a 408 Request Timeout status code, letting the client know that their request took too long.

Sometimes, different routes need different treatments. Maybe one is a slowpoke while the other is a speedster. You can set timeouts for specific routes right in their handlers. Check this out:

app.get('/api/slow-route', (req, res) => {
    req.setTimeout(5000, () => {
        res.status(408).send('Request timeout');
    });
    
    // Simulating a slooooow response
    setTimeout(() => {
        res.send('Hello, World!');
    }, 10000); 
});

Here, /api/slow-route gets a special timeout of 5 seconds. If it doesn’t respond in time, the server sends a timeout error back.

There’s another way to handle timeouts—using the connect-timeout middleware. This tool is like the Swiss Army knife for handling timeouts in Express.js. Here’s how you use it:

const express = require('express');
const timeout = require('connect-timeout');
const app = express();
const port = 3000;

app.use(timeout('5s')); // Setting a global timeout of 5 seconds

app.use((req, res, next) => {
    if (!res.headersSent) {
        res.status(408).send('Request timeout');
    }
});

app.get('/', (req, res) => {
    setTimeout(() => {
        res.send('Hello, World!');
    }, 10000); // Simulating slow response
});

app.listen(port, () => {
    console.log(`Server listening on port ${port}`);
});

This middleware pops a timeout warning if the request dawdles too long. Then, you can step in and tell the client what’s up.

But sometimes, it’s not just about the request. You might also need to handle socket timeouts. This happens when there’s no data flowing over the connection for a while. Here’s how you do it in Express.js:

const express = require('express');
const app = express();
const port = 3000;

const server = app.listen(port, () => {
    console.log(`Server listening on port ${port}`);
});

server.setTimeout(5000, (socket) => {
    console.log('Socket timed out.');
    socket.destroy();
});

In this setup, if the socket sits idle for 5 seconds, it gets closed. It’s like telling the socket, “Move it or lose it.”

Now, a few best practices can make a world of difference when handling request timeouts:

• Pick the Right Timeout Value: Think about how long a response should reasonably take. Too low, and you’ll cut off legit requests. Too high, and you miss the point.
• Handle Timeout Errors Gracefully: Make sure you’re sending reasonable status codes and logging these errors for your developers to analyze later.
• Cancel Long-Running Tasks: This is key—if a request times out, it’s often smart to cancel the underlying task. It saves resources and keeps things smooth.

Wrapping this up, implementing request timeouts in your Express.js apps is pretty straightforward, but it makes a big difference. With the right timeouts and error handling in place, you ensure your app isn’t leaving anyone hanging. Whether using middleware or setting timeouts in route handlers, find the sweet spot that keeps your application humming.