Why Logging with structured formats in Node.js? - Purpose & Use Cases

The Big Idea

What if your logs could talk back and tell you exactly what went wrong, instantly?

The Scenario

Imagine you run a busy online store. When something goes wrong, you check your logs, but they are just long lines of text with no clear order or details. Finding the exact problem feels like searching for a needle in a haystack.

The Problem

Manual logs are slow to read and easy to misunderstand. Without structure, you waste time guessing what each line means. Errors get missed, and fixing issues takes longer, frustrating both you and your customers.

The Solution

Logging with structured formats organizes your logs into clear, consistent pieces like JSON. This makes it easy to search, filter, and understand what happened, so you can fix problems faster and keep your system running smoothly.

Before vs After

✗ Before

console.log('Error at user login: invalid password');

✓ After

console.log(JSON.stringify({event: 'login_error', reason: 'invalid_password', userId: 123}));

What It Enables

Structured logging lets you quickly find and fix issues by turning messy text into clear, searchable data.

Real Life Example

A developer notices many failed logins. With structured logs, they filter all login errors in seconds and spot a bug causing password checks to fail, fixing it before customers complain.

Key Takeaways

Manual logs are hard to read and slow to debug.

Structured formats organize logs for easy searching and understanding.

This speeds up problem-solving and improves system reliability.

Practice

1. What is the main benefit of using structured logging in Node.js applications?

easy

A. Logs are stored as plain text without any format.

B. Logs are only saved in memory and not written to files.

C. Logs are encrypted automatically for security.

D. Logs are saved in a clear, organized JSON format for easy reading and processing.

Solution

1. Step 1: Understand structured logging

   Structured logging means saving logs in a format like JSON that is easy to read and parse.

2. Step 2: Identify the benefit

   This format helps both humans and tools quickly understand log data.

3. Final Answer:

   Logs are saved in a clear, organized JSON format for easy reading and processing. -> Option D

4. Quick Check:

   Structured logging = JSON format logs [OK]

Hint: Structured logs use JSON for clarity and easy parsing [OK]

Common Mistakes:

• Thinking logs are encrypted by default
• Confusing plain text logs with structured logs
• Assuming logs are only stored in memory

2. Which of the following is the correct way to create a logger using the pino library in Node.js?

easy

A. const logger = require('pino')();

B. const logger = new pino.Logger();

C. const logger = pino.create();

D. const logger = require('pino').createLogger();

Solution

1. Step 1: Recall pino import syntax

   The pino library is imported using require('pino'), which returns a function.

2. Step 2: Create logger instance

   Calling this function with () creates the logger instance: require('pino')()

3. Final Answer:

   const logger = require('pino')(); -> Option A

4. Quick Check:

   pino logger created by calling require('pino')() [OK]

Hint: Use require('pino')() to create logger instance [OK]

Common Mistakes:

• Using createLogger() which does not exist
• Trying to use new keyword with pino
• Calling pino.create() which is invalid

3. What will be the output of the following Node.js code using pino?

const pino = require('pino');
const logger = pino();
logger.info({ user: 'alice', action: 'login' }, 'User action');

medium

A. User action: user=alice, action=login

B. {"level":30,"time":<timestamp>,"msg":"User action","user":"alice","action":"login"}

C. {"message":"User action","user":"alice","action":"login"}

D. Error: Missing log level

Solution

1. Step 1: Understand pino.info() output format

   pino logs messages as JSON with fields like level, time, msg, and any extra data.

2. Step 2: Analyze given code

   Calling logger.info with an object and message logs JSON with level 30 (info), timestamp, msg, and object keys.

3. Final Answer:

   {"level":30,"time":<timestamp>,"msg":"User action","user":"alice","action":"login"} -> Option B

4. Quick Check:

   pino logs JSON with level and message [OK]

Hint: pino logs JSON with level, time, msg, and extra data [OK]

Common Mistakes:

• Expecting plain text output instead of JSON
• Confusing message key name
• Thinking log level is missing

4. Identify the error in this code snippet using pino for structured logging:

const pino = require('pino');
const logger = pino();
logger.info('User logged in', { user: 'bob' });

medium

A. The order of arguments is incorrect; the object should come first.

B. Missing semicolon after require statement.

C. pino() must be called with configuration object.

D. logger.info cannot accept two arguments.

Solution

1. Step 1: Check pino.info argument order

   pino expects the first argument as an object with extra data, second as message string.

2. Step 2: Analyze given code

   The code passes message string first, then object, which is reversed and causes wrong output.

3. Final Answer:

   The order of arguments is incorrect; the object should come first. -> Option A

4. Quick Check:

   pino.info(object, message) argument order [OK]

Hint: Pass object first, then message string to logger.info [OK]

Common Mistakes:

• Swapping message and object arguments
• Thinking semicolon is mandatory for correctness
• Assuming pino() needs config always

5. You want to log user events with structured logs including user ID, event type, and timestamp using pino. Which code snippet correctly logs this data ensuring timestamp is included in the JSON output?

hard

A. logger.info({ userId: 123, event: 'click' }, 'User event at ' + new Date());

B. logger.info('User event', { userId: 123, event: 'click', timestamp: Date.now() });

C. logger.info({ userId: 123, event: 'click', time: new Date().toISOString() }, 'User event');

D. logger.info({ userId: 123, event: 'click', timestamp: Date.now() });

Solution

1. Step 1: Ensure correct argument order and timestamp format

   pino expects object first, then message string. Timestamp should be ISO string for readability.

2. Step 2: Check each option

   logger.info({ userId: 123, event: 'click', time: new Date().toISOString() }, 'User event'); passes object with userId, event, and ISO timestamp, then message string. This is correct.

3. Final Answer:

   logger.info({ userId: 123, event: 'click', time: new Date().toISOString() }, 'User event'); -> Option C

4. Quick Check:

   Object first with ISO timestamp, then message [OK]

Hint: Pass object with ISO timestamp first, then message string [OK]

Common Mistakes:

• Swapping message and object arguments
• Using Date.now() without formatting
• Concatenating message and timestamp in string