Мастер-класс по микросервисам на Node.js

// Пример простого микросервиса на Node.js (Express)
const express = require('express');
const app = express();
 
app.get('/api/data', async (req, res) => {
  // Имитация обращения к базе данных
  const data = await fetchDataFromDatabase();
  res.json(data);
});
 
app.listen(3000, () => console.log('Service is running on port 3000'));
 
async function fetchDataFromDatabase() {
  // Имитация задержки при обращении к базе данных
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ id: 1, name: 'Test' });
    }, 100);
  });
}

// Пример реализации Strangler Pattern с API Gateway
const express = require('express');
const httpProxy = require('http-proxy');
const app = express();
const proxy = httpProxy.createProxyServer();
 
// Маршрутизация запросов
app.use((req, res) => {
  // Новая функциональность идет в микросервис
  if (req.path.startsWith('/api/orders')) {
    proxy.web(req, res, { target: 'http://orders-service:3001' });
  } 
  // Все остальное остается в монолите
  else {
    proxy.web(req, res, { target: 'http://monolith:8080' });
  }
});
 
app.listen(3000, () => console.log('API Gateway is running on port 3000'));

// Упрощенный пример Saga паттерна
async function createOrderSaga(orderData, userId) {
  try {
    // Шаг 1: Создание заказа
    const order = await orderService.createOrder(orderData);
    
    try {
      // Шаг 2: Резервирование товаров на складе
      await inventoryService.reserveItems(order.items);
      
      try {
        // Шаг 3: Обработка платежа
        await paymentService.processPayment(userId, order.totalAmount);
        
        // Все операции успешны
        return { success: true, orderId: order.id };
      } catch (paymentError) {
        // Компенсирующее действие для шага 2
        await inventoryService.releaseItems(order.items);
        // Компенсирующее действие для шага 1
        await orderService.cancelOrder(order.id, 'Ошибка платежа');
        throw paymentError;
      }
    } catch (inventoryError) {
      // Компенсирующее действие для шага 1
      await orderService.cancelOrder(order.id, 'Нет в наличии');
      throw inventoryError;
    }
  } catch (error) {
    return { success: false, error: error.message };
  }
}

async function getUserProfile(userId) {
  // Параллельные запросы к разным сервисам
  const [userInfo, orderHistory, recommendations] = await Promise.all([
    userService.getBasicInfo(userId),
    orderService.getRecentOrders(userId, 5),
    recommendationService.getUserRecommendations(userId)
  ]);
  
  // Объединение результатов
  return {
    user: userInfo,
    recentOrders: orderHistory,
    recommendedProducts: recommendations
  };
}

// Producer: отправка события при изменении данных
function updateProductStock(productId, newQuantity) {
  // Обновление в базе данных
  db.products.update({ id: productId }, { quantity: newQuantity });
  
  // Публикация события
  eventBus.publish('inventory.product.updated', {
    productId,
    quantity: newQuantity,
    timestamp: Date.now()
  });
}
 
// Consumer: подписка на события
eventBus.subscribe('inventory.product.updated', async (event) => {
  // Обновление локальной копии данных в другом сервисе
  await localDb.productInfo.update(
    { productId: event.productId },
    { inStock: event.quantity > 0, lastUpdated: event.timestamp }
  );
});

// Типичный микросервис на Express.js
const express = require('express');
const app = express();
 
app.use(express.json());
 
app.get('/api/products', async (req, res) => {
  try {
    const products = await productRepository.findAll();
    res.json(products);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});
 
app.listen(3000, () => console.log('Service running on port 3000'));

// Аналогичный микросервис на Fastify
const fastify = require('fastify')();
 
const schema = {
  response: {
    200: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          id: { type: 'string' },
          name: { type: 'string' },
          price: { type: 'number' }
        }
      }
    }
  }
};
 
fastify.get('/api/products', { schema }, async (request, reply) => {
  const products = await productRepository.findAll();
  return products; // автоматическая сериализация и валидация
});
 
fastify.listen(3000, (err) => {
  if (err) throw err;
  console.log('Service running on port 3000');
});

# Базовый образ с Node.js
FROM node:16-alpine as builder
 
# Рабочая директория
WORKDIR /app
 
# Копирование package.json и package-lock.json
COPY package*.json ./
 
# Установка зависимостей
RUN npm ci --only=production
 
# Копирование исходного кода
COPY . .
 
# Многоэтапная сборка для уменьшения размера образа
FROM node:16-alpine
 
WORKDIR /app
 
# Копирование только необходимых файлов из предыдущего этапа
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
COPY --from=builder /app/dist ./dist
 
# Пользователь с ограниченными привилегиями
USER node
 
# Порт, который будет слушать приложение
EXPOSE 3000
 
# Команда запуска приложения
CMD ["node", "dist/index.js"]

// Простой API Gateway на Node.js с Express и http-proxy-middleware
const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const app = express();
 
// Аутентификация
app.use('/api', (req, res, next) => {
  const token = req.headers.authorization;
  if (!token) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  // Валидация токена...
  next();
});
 
// Маршрутизация к микросервисам
app.use('/api/products', createProxyMiddleware({ 
  target: 'http://product-service',
  changeOrigin: true,
  pathRewrite: {'^/api/products': '/'}
}));
 
app.use('/api/orders', createProxyMiddleware({ 
  target: 'http://order-service',
  changeOrigin: true,
  pathRewrite: {'^/api/orders': '/'}
}));
 
app.listen(8000, () => console.log('API Gateway running on port 8000'));

const Consul = require('consul');
const axios = require('axios');
 
const consul = new Consul({
  host: process.env.CONSUL_HOST || 'localhost',
  port: process.env.CONSUL_PORT || '8500'
});
 
// Регистрация сервиса
consul.agent.service.register({
  name: 'product-service',
  id: [INLINE]product-service-${process.env.POD_NAME}[/INLINE],
  address: process.env.POD_IP,
  port: 3000,
  check: {
    http: 'http://localhost:3000/health',
    interval: '10s'
  }
}, (err) => {
  if (err) throw err;
  console.log('Service registered with Consul');
});
 
// Поиск сервиса
async function callOrderService() {
  try {
    const services = await consul.catalog.service.nodes({
      service: 'order-service'
    });
    
    if (services.length === 0) {
      throw new Error('No order-service instances available');
    }
    
    const service = services[Math.floor(Math.random() * services.length)];
    const url = `http://${service.ServiceAddress}:${service.ServicePort}/api/orders`;
    
    return await axios.get(url);
  } catch (error) {
    console.error('Error calling order service:', error);
    throw error;
  }
}

// ecosystem.config.js для PM2
module.exports = {
  apps: [{
    name: "product-service",
    script: "./dist/index.js",
    instances: "max",  // Используем все доступные ядра CPU
    exec_mode: "cluster",
    watch: false,
    max_memory_restart: "300M",  // Перезапуск при утечках памяти
    env: {
      NODE_ENV: "production",
      PORT: 3000
    },
    // Важные настройки для продакшена
    exp_backoff_restart_delay: 100,  // Экспоненциальная задержка между рестартами
    kill_timeout: 5000,  // Время ожидания перед принудительным завершением
    listen_timeout: 3000 // Сколько ждать, пока сервис начнет слушать порт
  }]
};

// Использование встроенного модуля cluster без PM2
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
const express = require('express');
 
if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);
 
  // Создаем рабочий процесс для каждого ядра
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
 
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    // Заменяем упавший процесс новым
    cluster.fork();
  });
} else {
  // Рабочие процессы могут делить один порт
  const app = express();
  
  app.get('/', (req, res) => {
    res.send(`Hello from worker ${process.pid}`);
  });
  
  app.listen(3000, () => {
    console.log(`Worker ${process.pid} started`);
  });
}

// Пример оптимизированного маршрута с валидацией в Fastify
fastify.post('/api/orders', {
  schema: {
    body: {
      type: 'object',
      required: ['userId', 'items'],
      properties: {
        userId: { type: 'string', format: 'uuid' },
        items: { 
          type: 'array',
          items: {
            type: 'object',
            required: ['productId', 'quantity'],
            properties: {
              productId: { type: 'string' },
              quantity: { type: 'integer', minimum: 1 }
            }
          }
        }
      }
    },
    response: {
      200: {
        type: 'object',
        properties: {
          orderId: { type: 'string' },
          status: { type: 'string' }
        }
      }
    }
  }
}, async (request, reply) => {
  const { userId, items } = request.body;
  // Бизнес-логика...
  return { orderId: '12345', status: 'created' };
});

// Пример конфигурации NGINX для комбинированной балансировки
upstream backend_services {
    # Resource-based балансировка с учетом весов
    server backend1.example.com weight=3;
    server backend2.example.com weight=2;
    server backend3.example.com weight=1; # менее мощный инстанс
    
    least_conn; # в рамках весов используем least connections
}
 
upstream frontend_api {
    # Sticky sessions по хешу IP
    ip_hash;
    server frontend1.example.com;
    server frontend2.example.com;
    server frontend3.example.com;
}

// Пример настройки mTLS в Node.js
const https = require('https');
const fs = require('fs');
 
const options = {
  key: fs.readFileSync('service-key.pem'),
  cert: fs.readFileSync('service-cert.pem'),
  ca: fs.readFileSync('ca-cert.pem'),
  requestCert: true,  // Требуем сертификат от клиента
  rejectUnauthorized: true  // Отклоняем соединения без валидного сертификата
};
 
https.createServer(options, (req, res) => {
  // Доступ только для аутентифицированных клиентов
  const clientCert = req.socket.getPeerCertificate();
  
  if (req.client.authorized) {
    res.writeHead(200);
    res.end(`Здравствуй, ${clientCert.subject.CN}!`);
  } else {
    res.writeHead(401);
    res.end("Доступ запрещен. Требуется действительный клиентский сертификат.");
  }
}).listen(8443);

// Пример публикации события при изменении данных
async function updateProduct(productId, updates) {
  // Обновляем в собственной базе данных
  const updatedProduct = await productDb.collection('products').findOneAndUpdate(
    { _id: productId },
    { $set: updates },
    { returnDocument: 'after' }
  );
  
  // Публикуем событие для других сервисов
  await eventBus.publish('product.updated', {
    productId,
    changes: updates,
    currentState: updatedProduct,
    timestamp: Date.now()
  });
  
  return updatedProduct;
}
 
// В другом сервисе подписываемся на событие
eventBus.subscribe('product.updated', async (event) => {
  // Обновляем локальную копию продукта в базе данных сервиса
  await localDb.collection('product_cache').updateOne(
    { productId: event.productId },
    { $set: {
        name: event.currentState.name,
        price: event.currentState.price,
        available: event.currentState.stock > 0,
        lastUpdated: event.timestamp
      }
    },
    { upsert: true }
  );
});

// Клиент для получения конфигурации из Consul
const Consul = require('consul');
const consul = new Consul();
 
async function getConfig(serviceName, environment) {
  try {
    const result = await consul.kv.get(`config/${environment}/${serviceName}`);
    if (!result) {
      // Fallback к дефолтной конфигурации
      return consul.kv.get(`config/default/${serviceName}`);
    }
    return JSON.parse(result.Value);
  } catch (error) {
    console.error('Failed to load config:', error);
    // Возвращаем локальную конфигурацию при ошибке
    return require('./config.local.js');
  }
}
 
// Использование
async function startService() {
  const config = await getConfig('order-service', process.env.NODE_ENV);
  
  // Применяем конфигурацию
  app.listen(config.port, () => {
    console.log(`Service running on port ${config.port}`);
  });
}

// Пример синхронного вызова между сервисами с использованием axios
async function getProductDetails(productId) {
  try {
    const response = await axios.get(`http://product-service/api/products/${productId}`);
    return response.data;
  } catch (error) {
    console.error('Error fetching product details:', error.message);
    throw new Error('Unable to retrieve product information');
  }
}

// Пример асинхронной публикации события с использованием RabbitMQ
async function publishOrderCreatedEvent(order) {
  try {
    const channel = await rabbitConnection.createChannel();
    await channel.assertExchange('order-events', 'topic', { durable: true });
    
    const message = Buffer.from(JSON.stringify({
      orderId: order.id,
      userId: order.userId,
      items: order.items,
      totalAmount: order.totalAmount,
      timestamp: Date.now()
    }));
    
    channel.publish('order-events', 'order.created', message);
    console.log(`Event published: order.created for order ${order.id}`);
  } catch (error) {
    console.error('Failed to publish event:', error);
    // Сохраняем событие в локальную очередь для повторной отправки
    await outboxRepository.saveFailedEvent('order.created', order);
  }
}

// GraphQL резолвер, агрегирующий данные из нескольких микросервисов
const resolvers = {
  Query: {
    dashboard: async (_, { userId }, context) => {
      // Запускаем параллельные запросы к разным сервисам
      const [userInfo, orders, recommendations, notifications] = await Promise.all([
        userService.getUserInfo(userId),
        orderService.getRecentOrders(userId, 5),
        recommendationService.getPersonalizedItems(userId, 10),
        notificationService.getPendingNotifications(userId)
      ]);
      
      return {
        user: userInfo,
        recentOrders: orders,
        recommendations: recommendations,
        notifications: notifications
      };
    }
  }
};

// Обработчик сообщений из RabbitMQ
async function setupOrderEventsConsumer() {
  const connection = await amqp.connect('amqp://rabbitmq-service');
  const channel = await connection.createChannel();
  
  await channel.assertExchange('order-events', 'topic', { durable: true });
  const { queue } = await channel.assertQueue('inventory-order-updates', { durable: true });
  
  // Подписываемся на события создания и отмены заказов
  await channel.bindQueue(queue, 'order-events', 'order.created');
  await channel.bindQueue(queue, 'order-events', 'order.cancelled');
  
  channel.consume(queue, async (msg) => {
    try {
      const content = JSON.parse(msg.content.toString());
      const routingKey = msg.fields.routingKey;
      
      if (routingKey === 'order.created') {
        await inventoryService.reserveItems(content.items);
      } else if (routingKey === 'order.cancelled') {
        await inventoryService.releaseItems(content.items);
      }
      
      // Подтверждаем успешную обработку
      channel.ack(msg);
    } catch (error) {
      console.error('Error processing message:', error);
      // Решаем, возвращать ли сообщение в очередь
      if (error.retryable) {
        channel.nack(msg, false, true);
      } else {
        // Для неисправимых ошибок - отправляем в dead letter queue
        channel.nack(msg, false, false);
      }
    }
  });
  
  console.log('Order events consumer set up successfully');
}

// Реализация Circuit Breaker с использованием библиотеки opossum
const CircuitBreaker = require('opossum');
 
// Настраиваем Circuit Breaker для вызовов сервиса платежей
const paymentServiceBreaker = new CircuitBreaker(processPayment, {
  failureThreshold: 50,        // Процент ошибок для размыкания цепи
  resetTimeout: 10000,         // Время до полузамкнутого состояния (мс)
  timeout: 3000,               // Таймаут операции (мс)
  errorThresholdPercentage: 50 // Процент ошибок для срабатывания
});
 
// Добавляем обработчики событий
paymentServiceBreaker.on('open', () => {
  console.log('Circuit Breaker opened - payment service is unavailable');
  // Отправляем уведомление в систему мониторинга
  metrics.incrementCounter('circuit_breaker.payment_service.open');
});
 
paymentServiceBreaker.on('halfOpen', () => {
  console.log('Circuit Breaker half-open - testing payment service availability');
});
 
paymentServiceBreaker.on('close', () => {
  console.log('Circuit Breaker closed - payment service is operational again');
  metrics.incrementCounter('circuit_breaker.payment_service.close');
});
 
// Использование в обработчике запроса
async function chargeCustomer(userId, amount) {
  try {
    return await paymentServiceBreaker.fire(userId, amount);
  } catch (error) {
    if (error.type === 'CIRCUIT_OPEN') {
      // Цепь разомкнута, используем запасной вариант
      return await fallbackPaymentProcess(userId, amount);
    }
    throw error;
  }
}

// Упрощенный пример Event Store на Node.js
class EventStore {
  constructor(db) {
    this.db = db;
  }
 
  async saveEvent(streamId, eventType, data) {
    const event = {
      streamId,
      eventType,
      data,
      timestamp: Date.now(),
      version: await this.getNextVersion(streamId)
    };
    
    await this.db.collection('events').insertOne(event);
    // Публикация события для других сервисов
    await this.publishEvent(event);
    return event;
  }
  
  async getEvents(streamId) {
    return await this.db.collection('events')
      .find({ streamId })
      .sort({ version: 1 })
      .toArray();
  }
  
  async getNextVersion(streamId) {
    const latestEvent = await this.db.collection('events')
      .find({ streamId })
      .sort({ version: -1 })
      .limit(1)
      .toArray();
      
    return latestEvent.length ? latestEvent[0].version + 1 : 1;
  }
}

// Пример Saga с оркестрацией (упрощенно)
class OrderSagaOrchestrator {
  async createOrder(orderData) {
    const sagaId = uuidv4();
    const sagaLog = new SagaLog(sagaId);
    
    try {
      // Шаг 1: Создание заказа
      const order = await this.executeStep(
        sagaLog,
        'CREATE_ORDER',
        () => orderService.createOrder(orderData)
      );
      
      // Шаг 2: Резервирование товаров
      await this.executeStep(
        sagaLog,
        'RESERVE_INVENTORY',
        () => inventoryService.reserveItems(order.items),
        // Компенсирующее действие
        () => orderService.cancelOrder(order.id)
      );
      
      // Шаг 3: Обработка платежа
      await this.executeStep(
        sagaLog,
        'PROCESS_PAYMENT',
        () => paymentService.processPayment(orderData.userId, order.total),
        // Компенсирующее действие
        async () => {
          await inventoryService.releaseItems(order.items);
          await orderService.cancelOrder(order.id);
        }
      );
      
      return { success: true, orderId: order.id };
    } catch (error) {
      console.error(`Saga failed: ${error.message}`);
      return { success: false, error: error.message };
    }
  }
}

// Пример валидации запросов с JSON Schema в Fastify
const createOrderSchema = {
  body: {
    type: 'object',
    required: ['userId', 'items'],
    properties: {
      userId: { type: 'string', format: 'uuid' },
      items: { 
        type: 'array',
        minItems: 1,
        items: {
          type: 'object',
          required: ['productId', 'quantity'],
          properties: {
            productId: { type: 'string' },
            quantity: { type: 'integer', minimum: 1 }
          }
        }
      },
      shippingAddress: {
        type: 'object',
        required: ['country', 'city', 'street'],
        properties: {
          country: { type: 'string' },
          city: { type: 'string' },
          street: { type: 'string' },
          zipCode: { type: 'string' }
        }
      }
    }
  }
};
 
fastify.post('/orders', { schema: createOrderSchema }, async (request, reply) => {
  // Схема автоматически валидируется Fastify
  const result = await orderService.createOrder(request.body);
  return result;
});

// Пример интеграции с OpenTelemetry для распределенного трейсинга
const { NodeTracerProvider } = require('@opentelemetry/node');
const { SimpleSpanProcessor } = require('@opentelemetry/tracing');
const { JaegerExporter } = require('@opentelemetry/exporter-jaeger');
const { ExpressInstrumentation } = require('@opentelemetry/instrumentation-express');
const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http');
const { registerInstrumentations } = require('@opentelemetry/instrumentation');
 
// Инициализация провайдера трейсинга
const provider = new NodeTracerProvider();
 
// Настройка экспортера (в данном случае Jaeger)
const exporter = new JaegerExporter({
  serviceName: 'order-service',
  host: process.env.JAEGER_HOST || 'jaeger',
  port: process.env.JAEGER_PORT || 6832
});
 
// Регистрация процессора и экспортера
provider.addSpanProcessor(new SimpleSpanProcessor(exporter));
provider.register();
 
// Автоматическая инструментация популярных библиотек
registerInstrumentations({
  instrumentations: [
    new HttpInstrumentation(),
    new ExpressInstrumentation()
  ]
});
 
// Получение трейсера для создания своих спанов
const tracer = provider.getTracer('order-service-tracer');
 
// Пример создания кастомного спана
app.post('/api/orders', async (req, res) => {
  const span = tracer.startSpan('create_order');
  
  try {
    // Помечаем важные атрибуты для анализа
    span.setAttribute('user.id', req.body.userId);
    span.setAttribute('order.items.count', req.body.items.length);
    
    // Бизнес-логика обработки заказа...
    const result = await orderService.createOrder(req.body);
    
    span.setAttribute('order.id', result.orderId);
    span.setStatus({ code: SpanStatusCode.OK });
    res.json(result);
  } catch (error) {
    // Записываем ошибку в спан
    span.setStatus({
      code: SpanStatusCode.ERROR,
      message: error.message
    });
    span.recordException(error);
    res.status(500).json({ error: error.message });
  } finally {
    span.end();
  }
});

// Интеграция Prometheus в Node.js микросервис
const express = require('express');
const promClient = require('prom-client');
const app = express();
 
// Создаем реестр метрик
const register = new promClient.Registry();
promClient.collectDefaultMetrics({ register });
 
// Кастомные метрики
const httpRequestDurationMicroseconds = new promClient.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in microseconds',
  labelNames: ['method', 'route', 'status_code'],
  buckets: [0.01, 0.03, 0.1, 0.3, 0.5, 1, 3, 5, 10]
});
 
const orderCreationCounter = new promClient.Counter({
  name: 'orders_created_total',
  help: 'Total number of created orders'
});
 
register.registerMetric(httpRequestDurationMicroseconds);
register.registerMetric(orderCreationCounter);
 
// Middleware для измерения длительности HTTP-запросов
app.use((req, res, next) => {
  const end = httpRequestDurationMicroseconds.startTimer();
  
  res.on('finish', () => {
    end({
      method: req.method,
      route: req.route ? req.route.path : 'unknown',
      status_code: res.statusCode
    });
  });
  
  next();
});
 
// Эндпоинт для Prometheus скрейпера
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', register.contentType);
  res.end(await register.metrics());
});
 
// Бизнес-логика
app.post('/api/orders', async (req, res) => {
  try {
    const result = await orderService.createOrder(req.body);
    orderCreationCounter.inc(); // Инкрементируем счетчик созданных заказов
    res.json(result);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Настройка логирования с Winston и транспортом для ELK
const winston = require('winston');
require('winston-elasticsearch');
 
// Базовая конфигурация логгера
const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  defaultMeta: { 
    service: 'order-service',
    environment: process.env.NODE_ENV
  },
  transports: [
    // Консольный вывод для локальной разработки
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(),
        winston.format.simple()
      )
    }),
    // Отправка в Elasticsearch
    new winston.transports.Elasticsearch({
      level: 'info',
      clientOpts: {
        node: process.env.ELASTICSEARCH_URL || 'http://elasticsearch:9200',
        auth: {
          username: process.env.ELASTICSEARCH_USER,
          password: process.env.ELASTICSEARCH_PASSWORD
        }
      },
      indexPrefix: 'logs-order-service'
    })
  ]
});
 
// Интеграция с Express для логирования запросов
app.use((req, res, next) => {
  const start = Date.now();
  
  // Логируем входящий запрос
  logger.debug('Request received', {
    method: req.method,
    url: req.url,
    headers: req.headers,
    query: req.query,
    body: req.body
  });
  
  res.on('finish', () => {
    // Логируем результат запроса
    const duration = Date.now() - start;
    const logMethod = res.statusCode >= 400 ? 'error' : 'info';
    
    logger[logMethod]('Request completed', {
      method: req.method,
      url: req.url,
      statusCode: res.statusCode,
      duration,
      requestId: req.headers['x-request-id']
    });
  });
  
  next();
});
 
// Использование в бизнес-логике
async function processOrder(orderData) {
  logger.info('Processing order', { userId: orderData.userId });
  
  try {
    // Бизнес-логика...
    return result;
  } catch (error) {
    logger.error('Failed to process order', {
      error: error.message,
      stack: error.stack,
      orderData
    });
    throw error;
  }
}

// Пример настройки алертинга в Prometheus с Alertmanager
groups:
name: node-service-alerts
  rules:
  - alert: HighLatency
    expr: histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m])) > 1
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "High latency for {{ $labels.instance }}"
      description: "95th percentile latency is above 1s for {{ $labels.instance }}"
      
  - alert: HighErrorRate
    expr: sum(rate(http_request_total{status_code=~"5.."}[5m])) / sum(rate(http_request_total[5m])) > 0.05
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "High error rate detected"
      description: "Error rate is above 5% for the last 2 minutes"