JSON Structured Logging — Build Observable Systems

1import pino from 'pino';
2
3const logger = pino({
4  level: process.env.LOG_LEVEL || 'info',
5  timestamp: pino.stdTimeFunctions.isoTime,
6
7  // Redact sensitive fields
8  redact: {
9    paths: [
10      'req.headers.authorization',
11      'req.headers.cookie',
12      'body.password',
13      'body.creditCard',
14    ],
15    censor: '[REDACTED]',
16  },
17
18  // Base fields included in every log entry
19  base: {
20    service: 'payment-service',
21    version: process.env.APP_VERSION || '0.0.0',
22    environment: process.env.NODE_ENV || 'development',
23  },
24
25  // Format for development readability
26  transport: process.env.NODE_ENV !== 'production'
27    ? { target: 'pino-pretty', options: { colorize: true } }
28    : undefined,
29});
30
31export default logger;

1import logger from './logger.js';
2
3app.post('/api/payments', async (req, res) => {
4  const requestLogger = logger.child({
5    request_id: req.headers['x-request-id'],
6    user_id: req.user?.id,
7  });
8
9  requestLogger.info({ amount: req.body.amount }, 'Payment initiated');
10
11  try {
12    const result = await processPayment(req.body);
13    requestLogger.info(
14      { txn_id: result.id, duration_ms: result.duration },
15      'Payment succeeded'
16    );
17    res.json({ success: true, txn_id: result.id });
18  } catch (err) {
19    requestLogger.error(
20      { error_code: err.code, error_message: err.message },
21      'Payment failed'
22    );
23    res.status(500).json({ error: 'Payment processing failed' });
24  }
25});

1import structlog
2import logging
3
4structlog.configure(
5    processors=[
6        structlog.contextvars.merge_contextvars,
7        structlog.processors.add_log_level,
8        structlog.processors.TimeStamper(fmt="iso"),
9        structlog.processors.StackInfoRenderer(),
10        structlog.processors.format_exc_info,
11        structlog.processors.JSONRenderer(),
12    ],
13    wrapper_class=structlog.make_filtering_bound_logger(logging.INFO),
14    context_class=dict,
15    logger_factory=structlog.PrintLoggerFactory(),
16)
17
18log = structlog.get_logger(service="user-service", version="1.2.0")

1from fastapi import FastAPI, Request
2import structlog
3
4app = FastAPI()
5log = structlog.get_logger()
6
7@app.middleware("http")
8async def logging_middleware(request: Request, call_next):
9    structlog.contextvars.clear_contextvars()
10    structlog.contextvars.bind_contextvars(
11        request_id=request.headers.get("x-request-id", "unknown"),
12        method=request.method,
13        path=request.url.path,
14    )
15    response = await call_next(request)
16    log.info("request_handled", status_code=response.status_code)
17    return response
18
19@app.post("/api/orders")
20async def create_order(order: OrderRequest):
21    log.info("order_created", order_id=order.id, total=order.total)
22    # Every log entry automatically includes request_id, method, path
23    return {"status": "created"}

1import { trace, context } from '@opentelemetry/api';
2import pino from 'pino';
3
4const logger = pino({
5  mixin() {
6    const span = trace.getSpan(context.active());
7    if (!span) return {};
8    const ctx = span.spanContext();
9    return {
10      trace_id: ctx.traceId,
11      span_id: ctx.spanId,
12      trace_flags: ctx.traceFlags,
13    };
14  },
15});
16
17// Now every log entry automatically includes trace_id and span_id
18// from the active OpenTelemetry context
19logger.info('Processing payment');
20// Output: {"level":"info","trace_id":"4bf92f35...","span_id":"00f067aa...",
21//          "message":"Processing payment"}

1const logger = pino({
2  redact: {
3    paths: [
4      'req.headers.authorization',
5      'req.headers.cookie',
6      'body.password',
7      'body.ssn',
8      'body.creditCard',
9      'body.*.token',     // nested token fields
10    ],
11    censor: '[REDACTED]',
12  },
13});
14
15// Input: { body: { password: "secret123", username: "alice" } }
16// Output: { body: { password: "[REDACTED]", username: "alice" } }

1# Find all errors in the last hour
2cat app.log | jq 'select(.level == "error")'
3
4# Slow requests (> 1 second)
5cat app.log | jq 'select(.duration_ms > 1000) | {path: .url, duration_ms, timestamp}'
6
7# Error rate by service
8cat app.log | jq -s '
9  group_by(.service) | map({
10    service: .[0].service,
11    total: length,
12    errors: [.[] | select(.level == "error")] | length
13  })'
14
15# Trace a single request across services
16cat app.log | jq 'select(.request_id == "req_01HXYZ9ABC")'
17
18# Top 10 slowest endpoints
19cat app.log | jq -s '
20  [.[] | select(.duration_ms)] |
21  sort_by(-.duration_ms) |
22  .[0:10] |
23  .[] | {url, duration_ms, timestamp}'