NutriFlow — Observabilidad e Instrumentación en Producción

// Correlation ID por request — obligatorio en toda la stack
import pino from 'pino';
import crypto from 'crypto';

export const logger = pino({ level: 'info', formatters: { level: (label) => ({ level: label }) } });

export function requestContextMiddleware(req, res, next) {
  const requestId = req.headers['x-request-id'] ?? crypto.randomUUID();
  req.id  = requestId;
  req.log = logger.child({ requestId, service: 'checkout-service' });
  res.setHeader('x-request-id', requestId);
  next();
}

async function createSubscription(req: Request, dto: CreateSubscriptionDto) {
  const { log } = req;

  log.info({ event: 'subscription_create_started', clinicId: dto.clinicId,
    planId: dto.planId, amount: dto.amountCents }, 'subscription create started');

  try {
    const charge = await mercadopago.charge({ amount: dto.amountCents, token: dto.cardToken });

    log.info({ event: 'payment_succeeded', clinicId: dto.clinicId,
      chargeId: charge.id, provider: 'mercadopago', attempt: 1
    }, 'initial payment succeeded');

    return await db.createSubscription({ ...dto, chargeId: charge.id, status: 'active' });

  } catch (err) {
    log.warn({ event: 'payment_failed', clinicId: dto.clinicId,
      provider: 'mercadopago', errorCode: err.code,  // MP_INSUFFICIENT_FUNDS, MP_INVALID_CARD...
      errorType: err.type, attempt: 1
    }, 'initial payment failed');     // warn: degraded pero manejado
    throw err;
  }
}

// Worker nocturno — siempre loguear resumen al final
async function processExpiredSubscriptions() {
  const start = Date.now();
  let processed = 0, failed = 0;

  for (const sub of await db.findExpiring()) {
    try {
      await renewSubscription(sub.id);
      processed++;
    } catch (e) {
      failed++;
      logger.error({ event: 'subscription_renewal_error', subscriptionId: sub.id,
        errorCode: e.code }, 'renewal failed');
    }
  }

  logger.info({ event: 'worker_run_completed', processedCount: processed,
    failedCount: failed, durationMs: Date.now() - start }, 'worker finished');
}

import { Histogram, Counter, register } from 'prom-client';

// RED: Rate + Errors + Duration por endpoint
export const httpDuration = new Histogram({
  name: 'http_request_duration_seconds',
  help: 'Latencia de requests HTTP',
  labelNames: ['method', 'route', 'status_class'],  // '2xx' no '200' — cardinalidad fija
  buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5],
});

// RED específico de MercadoPago — dependencia externa crítica
export const mpDuration = new Histogram({
  name: 'mercadopago_request_duration_seconds',
  help: 'Latencia de llamadas al proveedor MercadoPago',
  labelNames: ['operation', 'status'],   // 'charge'|'refund' · 'success'|'failed'
  buckets: [0.1, 0.25, 0.5, 1, 1.5, 3, 5],
});

export const paymentTotal = new Counter({
  name: 'subscriptions_payment_total',
  help: 'Total de intentos de cobro por resultado',
  labelNames: ['status', 'error_code'],   // error_code: MP_INSUFFICIENT_FUNDS, etc.
});

export const workerErrors = new Counter({
  name: 'subscription_worker_errors_total',
  help: 'Errores del worker de renovación nocturna',
  labelNames: ['error_code'],
});

// NUNCA como label: userId, email, requestId, URL completa, mensaje de error libre

import { NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';

const sdk = new NodeSDK({
  serviceName: 'checkout-service',
  traceExporter: new OTLPTraceExporter({ url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT }),
  instrumentations: [getNodeAutoInstrumentations()],  // cubre HTTP, PG, Redis automáticamente
});
sdk.start();

import { trace, context } from '@opentelemetry/api';

const tracer = trace.getTracer('checkout-service');

async function createSubscription(req, dto) {
  return tracer.startActiveSpan('subscription.create', async (span) => {
    span.setAttributes({
      'clinic.id': dto.clinicId,
      'subscription.plan_id': dto.planId,
      'payment.amount_cents': dto.amountCents,
    });

    const charge = await tracer.startActiveSpan('mercadopago.charge', async (mpSpan) => {
      try {
        const result = await mercadopago.charge(dto);
        mpSpan.setAttributes({ 'mp.charge_id': result.id, 'mp.status': 'success' });
        return result;
      } catch (e) {
        mpSpan.setAttributes({ 'mp.error_code': e.code, 'mp.status': 'failed' });
        mpSpan.recordException(e);
        throw e;
      } finally {
        mpSpan.end();
      }
    });

    span.end();
    return charge;
  });
}