Performance monitoring basics in Express - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the Express module.

Express

const express = require('[1]');

Drag options to blanks, or click blank then click option'

Ahttp

Bpath

Cfs

Dexpress

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'http' instead of 'express' will import the Node.js HTTP module, not Express.

Using 'fs' or 'path' imports file system or path modules, unrelated to Express.

The Express module is imported using require('express'). This allows you to create an Express app.

2fill in blank

medium

Complete the code to create a new Express application instance.

Express

const app = [1]();

Drag options to blanks, or click blank then click option'

Ahttp

Bexpress

Crouter

Dserver

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'http' or 'server' will cause errors because they are not functions here.

Using 'router' is for routing, not creating the app instance.

Calling express() creates a new Express app instance to handle requests.

3fill in blank

hard

Fix the error in the code to log the response time using middleware.

Express

app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    console.log(`Response time: ${Date.now() - [1]ms`);
  });
  next();
});

Drag options to blanks, or click blank then click option'

AstartTime

Bres.start

Cstart

Dreq.start

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined variables like 'startTime' causes errors.

Using properties on req or res that don't exist will not work.

The variable start holds the start time. Subtracting it from the current time gives the response duration.

4fill in blank

hard

Fill both blanks to create a middleware that measures and logs request duration in milliseconds.

Express

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

Drag options to blanks, or click blank then click option'

Astart

Bbegin

Cfinish

Dclose

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'begin' instead of 'start' for the variable name is uncommon and may confuse.

Listening to 'close' event instead of 'finish' may not always indicate response completion.

The variable start stores the start time. The event 'finish' fires when the response is done, so logging then shows total request time.

5fill in blank

hard

Fill all three blanks to create a simple route that responds with 'OK' and logs the request method and URL.

Express

app.[1]('/status', (req, res) => {
  console.log(`[2] request to [3]`);
  res.send('OK');
});

Drag options to blanks, or click blank then click option'

Aget

BPOST

Creq.url

Dreq.method

Attempts:

3 left

💡 Hint

Common Mistakes

Using uppercase 'POST' in the method call causes errors; it should be lowercase 'get'.

Swapping req.method and req.url in the log message changes meaning.

The route uses get to handle GET requests. req.method gives the HTTP method, and req.url gives the requested URL.

Practice

1. What is the main purpose of performance monitoring in an Express app?

easy

A. To measure how fast the app responds to requests

B. To add new features to the app

C. To change the app's user interface

D. To store user data securely

Solution

1. Step 1: Understand performance monitoring

   Performance monitoring tracks how quickly the app handles requests.

2. Step 2: Identify the main goal

   The goal is to find slow parts and improve speed, not to add features or change UI.

3. Final Answer:

   To measure how fast the app responds to requests -> Option A

4. Quick Check:

   Performance monitoring = measure response speed [OK]

Hint: Performance monitoring = measuring app speed [OK]

Common Mistakes:

• Confusing performance monitoring with adding features
• Thinking it changes the user interface
• Assuming it stores user data

2. Which Express middleware code snippet correctly measures request duration?

easy

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

B. app.use((req, res, next) => { const start = Date.now(); next(); console.log(Date.now() - start); });

C. app.use((req, res) => { console.log('Request received'); });

D. app.use((req, res, next) => { console.log('Start'); next(); console.log('End'); });

Solution

1. Step 1: Check middleware timing logic

   app.use((req, res, next) => { const start = Date.now(); res.on('finish', () => { console.log(Date.now() - start); }); next(); }); starts timer, waits for response finish event, then logs duration correctly.

2. Step 2: Compare other options

   app.use((req, res, next) => { const start = Date.now(); next(); console.log(Date.now() - start); }); logs too early before response ends. Another option lacks next() call. The remaining option logs 'Start' and 'End' immediately, not duration.

3. Final Answer:

   app.use((req, res, next) => { const start = Date.now(); res.on('finish', () => { console.log(Date.now() - start); }); next(); }); -> Option A

4. Quick Check:

   Use 'res.on("finish")' to measure full request time [OK]

Hint: Use 'res.on("finish")' event to log after response ends [OK]

Common Mistakes:

• Logging time before response finishes
• Forgetting to call next() in middleware
• Not using response events to measure duration

3. Given this middleware, what will be logged when a request takes 150ms?

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

medium

A. No output logged

B. Response time: 0ms

C. Response time: NaN

D. Response time: 150ms

Solution

1. Step 1: Understand timer start and finish

   The timer starts at request start and logs when response finishes, so it measures full duration.

2. Step 2: Calculate logged time

   If request takes 150ms, logged time is approximately 150ms.

3. Final Answer:

   Response time: 150ms -> Option D

4. Quick Check:

   Timer logs actual elapsed time on 'finish' event [OK]

Hint: Logs time difference on response finish event [OK]

Common Mistakes:

• Assuming log happens immediately (0ms)
• Confusing timer start and end
• Expecting no output without console.log

4. Why does this middleware fail to log correct response time?

app.use((req, res, next) => {
  const start = Date.now();
  console.log(Date.now() - start);
  next();
});

medium

A. It logs after response ends, so time is too long

B. It logs before response finishes, so time is near zero

C. It uses wrong event to measure time

D. It does not call next(), so request hangs

Solution

1. Step 1: Analyze when logging happens

   Logging happens immediately after start, before response finishes, so duration is near zero.

2. Step 2: Check middleware flow

   next() is called, so request continues; no wrong event used; logging is too early.

3. Final Answer:

   It logs before response finishes, so time is near zero -> Option B

4. Quick Check:

   Log after response finish for correct timing [OK]

Hint: Log after response finishes, not before [OK]

Common Mistakes:

• Logging too early before response ends
• Forgetting to call next() (not here though)
• Using wrong event to measure time

5. You want to log slow requests taking over 500ms in Express. Which code correctly implements this?

hard

A. app.use((req, res) => { if (Date.now() > 500) console.log('Slow request'); });

B. app.use((req, res, next) => { const start = Date.now(); if (Date.now() - start > 500) console.log('Slow request'); next(); });

C. app.use((req, res, next) => { const start = Date.now(); res.on('finish', () => { if (Date.now() - start > 500) console.log('Slow request'); }); next(); });

D. app.use((req, res, next) => { console.log('Slow request'); next(); });

Solution

1. Step 1: Understand timing and event usage

   app.use((req, res, next) => { const start = Date.now(); res.on('finish', () => { if (Date.now() - start > 500) console.log('Slow request'); }); next(); }); measures time from request start to response finish, then checks if duration > 500ms.

2. Step 2: Check other options

   Other options either check time immediately (always near zero), use wrong conditions like Date.now() > 500, or log unconditionally for all requests.

3. Final Answer:

   app.use((req, res, next) => { const start = Date.now(); res.on('finish', () => { if (Date.now() - start > 500) console.log('Slow request'); }); next(); }); -> Option C

4. Quick Check:

   Check duration on 'finish' event, then log if slow [OK]

Hint: Check time after response finishes, then log if slow [OK]

Common Mistakes:

• Checking time too early (before response ends)
• Logging all requests as slow
• Not using 'finish' event to measure full duration