Response time tracking middleware in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this Express middleware log?

Consider this Express middleware that tracks response time. What will it log to the console when a request is made?

Express

function responseTimeLogger(req, res, next) {
  const start = Date.now();
  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`Request took ${duration}ms`);
  });
  next();
}

A Logs the time in milliseconds before the request starts processing

B Logs the time in milliseconds it took to handle the request after the response finishes

C Logs the time in seconds it took to handle the request immediately when middleware runs

D Logs the time in milliseconds it took to handle the request before calling next()

💡 Hint

Think about when the 'finish' event on the response object happens.

The middleware records the start time, then waits for the 'finish' event on the response, which means the response has been sent. It then calculates the difference to find how long the request took.

📝 Syntax

intermediate

Identify the syntax error in this response time middleware

Which option correctly fixes the syntax error in this Express middleware code?

Express

function responseTime(req, res, next) {
  const start = Date.now()
  res.on('finish', () => {
    const duration = Date.now() - start
    console.log('Response time: ' + duration + 'ms')
  });
  next()
}

A Change the arrow function to a regular function to fix the syntax error

B Replace res.on with res.once to fix the syntax error

C Add a semicolon after next() to fix the syntax error

D Add a closing parenthesis after the res.on callback function before calling next()

💡 Hint

Check the parentheses balance around the res.on callback.

The res.on callback function is missing a closing parenthesis before next() is called, causing a syntax error.

🔧 Debug

advanced

Why does this middleware log zero for response time?

This middleware always logs 'Request took 0ms' even for slow requests. Why?

Express

function responseTime(req, res, next) {
  const start = Date.now();
  next();
  const duration = Date.now() - start;
  console.log(`Request took ${duration}ms`);
}

A Because the duration is calculated immediately after next(), before response finishes

B Because Date.now() returns time in seconds, not milliseconds

C Because next() blocks the event loop until response finishes

D Because the middleware does not listen to the 'close' event on res

💡 Hint

Think about when next() returns and when the response actually finishes.

Calling next() passes control to the next middleware but does not wait for the response to finish. The duration is measured immediately after next(), so it is near zero.

🧠 Conceptual

advanced

What is the best event to track response completion in Express middleware?

Which event on the response object should you listen to in order to accurately measure when the response has fully finished sending?

A 'close' event

B 'end' event

C 'finish' event

D 'data' event

💡 Hint

This event signals that all response data has been flushed.

The 'finish' event is emitted when the response has been sent completely. 'end' and 'data' are for readable streams, and 'close' can happen on errors or aborts.

❓ state_output

expert

What is the value of res.locals.duration after this middleware runs?

Given this middleware that tracks response time and stores it in res.locals, what will be the value of res.locals.duration after the response finishes?

Express

function responseTimeMiddleware(req, res, next) {
  const start = Date.now();
  res.on('finish', () => {
    res.locals.duration = Date.now() - start;
  });
  next();
}

// Assume this middleware is used in an Express app and a request takes 150ms to complete.

A Approximately 150 (milliseconds)

B Undefined, because res.locals is not set synchronously

C 0, because duration is calculated before response finishes

D NaN, because Date.now() returns a string

💡 Hint

res.locals can be set asynchronously inside event handlers.

The duration is calculated inside the 'finish' event handler, which runs after the response completes. So res.locals.duration will hold the actual time in milliseconds, about 150.

Practice

1. What is the main purpose of response time tracking middleware in Express?

easy

A. To measure how long each HTTP request takes to complete

B. To modify the request body before processing

C. To handle errors and send error responses

D. To serve static files like images and CSS

Solution

1. Step 1: Understand middleware role

   Response time tracking middleware measures the duration of requests.

2. Step 2: Identify main purpose

   It tracks how long the server takes to respond to each request.

3. Final Answer:

   To measure how long each HTTP request takes to complete -> Option A

4. Quick Check:

   Response time tracking = measuring request duration [OK]

Hint: Middleware timing tracks request duration, not request content [OK]

Common Mistakes:

• Confusing response time tracking with error handling
• Thinking it modifies request data
• Assuming it serves static files

2. Which of the following is the correct way to start measuring time in an Express middleware?

easy

A. const start = setTimeout();

B. const start = Date.now();

C. const start = process.hrtime();

D. const start = new Date().toString();

Solution

1. Step 1: Identify time measurement method

   Date.now() returns the current timestamp in milliseconds, suitable for timing.

2. Step 2: Check other options

   new Date().toString() returns a string, not a number; process.hrtime() returns a tuple, more complex; setTimeout() is for delays, not time capture.

3. Final Answer:

   const start = Date.now(); -> Option B

4. Quick Check:

   Use Date.now() for simple timestamps [OK]

Hint: Use Date.now() for simple time stamps in middleware [OK]

Common Mistakes:

• Using new Date().toString() which returns a string
• Confusing process.hrtime() with Date.now()
• Using setTimeout() incorrectly for timing

3. Given this middleware snippet, what will be logged?

app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`Request took ${duration}ms`);
  });
  next();
});

medium

A. Logs the time before the request starts processing

B. Logs the time repeatedly during the request

C. Logs the time taken for each request after response finishes

D. Does not log anything because of missing next()

Solution

1. Step 1: Understand event listener on 'finish'

   The 'finish' event triggers after the response is sent, so timing is complete.

2. Step 2: Calculate duration and log

   Duration is current time minus start time, logged once per request.

3. Final Answer:

   Logs the time taken for each request after response finishes -> Option C

4. Quick Check:

   res.on('finish') logs after response ends [OK]

Hint: res.on('finish') runs after response ends for timing [OK]

Common Mistakes:

• Thinking it logs before request processing
• Assuming multiple logs during request
• Forgetting to call next() to continue middleware chain

4. Identify the error in this response time middleware:

app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`Request took ${duration}ms`);
  });
});

medium

A. Logging inside middleware is not allowed

B. Using Date.now() instead of process.hrtime() causes error

C. res.on('finish') should be res.on('end')

D. Missing call to next(), so request hangs

Solution

1. Step 1: Check middleware flow

   Middleware must call next() to pass control; missing here causes request to hang.

2. Step 2: Validate event and logging

   res.on('finish') is correct event; Date.now() is valid; logging is allowed.

3. Final Answer:

   Missing call to next(), so request hangs -> Option D

4. Quick Check:

   Always call next() in middleware [OK]

Hint: Always call next() to continue middleware chain [OK]

Common Mistakes:

• Forgetting next() call
• Confusing 'finish' with 'end' event
• Thinking Date.now() causes errors

5. You want to log the response time in milliseconds to the console using the format Request took ${duration}ms. Which middleware code correctly does this?

hard

A. app.use((req, res, next) => {
const start = Date.now();
res.on('finish', () => {
const duration = Date.now() - start;
console.log(`Request took ${duration}ms`);
});
next();
});

B. app.use((req, res, next) => {
const start = Date.now();
const duration = Date.now() - start;
console.log(`Request took ${duration}ms`);
next();
});

C. app.use((req, res, next) => {
const start = Date.now();
console.log(`Request took ${Date.now() - start}ms`);
next();
});

D. app.use((req, res, next) => {
const start = Date.now();
res.on('close', () => {
const duration = Date.now() - start;
console.log(`Request took ${duration}ms`);
});
next();
});

Solution

1. Step 1: Understand logging timing

   To capture the full request processing time, record the start time, call next(), and log the duration in the 'finish' event handler which fires after the response is sent.

2. Step 2: Analyze incorrect approaches

   Logging right after starting the timer yields nearly 0ms because handlers haven't executed yet. The 'close' event relates to connection closure, not response completion, and may not fire reliably for timing.

3. Final Answer:

   Uses res.on('finish') to log accurate request duration -> Option A

4. Quick Check:

   res.on('finish') ensures complete request timing [OK]

Hint: Log duration in 'finish' event after response completes [OK]

Common Mistakes:

• Logging before calling next() (duration ~0ms)
• Using 'close' event instead of 'finish'
• Not waiting for response to finish