2024-03-15 10:23:01 INFO: Calling Stripe API to create payment intent
2024-03-15 10:23:02 ERROR: Stripe API returned 402 - Card declined
2024-03-15 10:23:02 INFO: Sending webhook to partner notification URL

import { randomUUID } from 'crypto';
import pino from 'pino';

const logger = pino({ level: 'info' });

// Middleware: generate or extract correlation ID
app.use((req, res, next) => {
  // Accept from upstream if it already exists
  const correlationId = req.headers['x-correlation-id'] as string
    || randomUUID();

  // Attach to request for downstream use
  req.correlationId = correlationId;

  // Set on response so the caller can see it too
  res.setHeader('x-correlation-id', correlationId);

  // Create a child logger with the ID baked in
  req.log = logger.child({ correlationId });

  next();
});

async function callPartnerAPI(
  req: Request,
  endpoint: string,
  payload: unknown
) {
  const start = Date.now();

  req.log.info({
    msg: 'Calling partner API',
    partner: 'fulfillment-service',
    endpoint,
  });

  const response = await fetch(endpoint, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-correlation-id': req.correlationId,  // Propagate!
      'Authorization': `Bearer ${process.env.PARTNER_API_KEY}`,
    },
    body: JSON.stringify(payload),
  });

  const duration = Date.now() - start;

  req.log.info({
    msg: 'Partner API responded',
    partner: 'fulfillment-service',
    endpoint,
    statusCode: response.status,
    duration,
  });

  return response;
}

import pino from 'pino';

const logger = pino({
  level: process.env.LOG_LEVEL || 'info',
  // Redact sensitive fields automatically
  redact: {
    paths: [
      'req.headers.authorization',
      'req.headers["x-api-key"]',
      'payload.creditCard',
      'payload.ssn',
      'payload.password',
      'response.body.token',
    ],
    censor: '[REDACTED]',
  },
  // Add service name to every log line
  base: {
    service: 'order-service',
    version: process.env.APP_VERSION || 'unknown',
  },
  // Customize serializers for request/response
  serializers: {
    req: pino.stdSerializers.req,
    res: pino.stdSerializers.res,
    err: pino.stdSerializers.err,
  },
});

export default logger;

// Good: log the shape
req.log.info({
  msg: 'Stripe API response',
  statusCode: 200,
  duration: 342,
  bodySize: JSON.stringify(responseBody).length,
  paymentIntentId: responseBody.id,
  paymentStatus: responseBody.status,
});

// Bad: log the full body
req.log.info({
  msg: 'Stripe API response',
  body: responseBody,  // Contains card details, customer email, etc.
});

import winston from 'winston';

const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  defaultMeta: {
    service: 'order-service',
    version: process.env.APP_VERSION || 'unknown',
  },
  transports: [
    new winston.transports.Console(),
    // In production: send to your log aggregator
    // new winston.transports.Http({ host: 'logs.example.com' }),
  ],
});

// Create child logger with correlation ID
function createRequestLogger(correlationId: string) {
  return logger.child({ correlationId });
}

export { logger, createRequestLogger };

app.post('/webhooks/stripe', async (req, res) => {
  const webhookId = req.headers['stripe-webhook-id'] as string;
  const correlationId = req.headers['x-correlation-id'] as string
    || randomUUID();

  const log = logger.child({ correlationId, webhookId, partner: 'stripe' });

  log.info({ msg: 'Webhook received', eventType: req.body.type });

  try {
    await processWebhookEvent(req.body, log);
    log.info({ msg: 'Webhook processed successfully' });
    res.status(200).json({ received: true });
  } catch (error) {
    log.error({
      msg: 'Webhook processing failed',
      err: error,
      eventType: req.body.type,
    });
    // Still respond 200 to prevent retries if processing is queued
    res.status(200).json({ received: true, queued: true });
  }
});