Cómo integrar Sentry en AWS Lambda y monitorear errores en producción

Cuando trabajamos con arquitecturas serverless, especialmente con AWS Lambda, es común descubrir que algo anda mal solo cuando los usuarios comienzan a abrir tickets de soporte. En ese momento, el siguiente paso suele ser revisar los logs en CloudWatch, invirtiendo varios minutos o incluso horas (me ha pasado) tratando de identificar qué fue exactamente lo que provocó el error. Es justo aquí donde Sentry entra en juego.

Sentry es una herramienta muy útil para el monitoreo de errores, ya que nos permite saber cuándo, dónde y por qué ocurrió un problema. Además, nos brinda el contexto necesario para entender el error y solucionarlo de forma rápida, sin depender únicamente de los logs.

En este post conoceremos un poco más sobre Sentry y veremos cómo integrarlo en AWS Lambda utilizando AWS CDK y TypeScript, paso a paso y de forma sencilla.

¿Que es Sentry?

Sentry es una plataforma de monitoreo de errores diseñada para ayudar a los desarrolladores a detectar, diagnosticar y resolver problemas rápidamente en sus aplicaciones. Funciona tanto para aplicaciones web, móviles y en la nube, permitiendo identificar errores de forma temprana y mantener una alta calidad del software.

En arquitecturas serverless, Sentry resulta especialmente muy útil. Este tipo de aplicaciones suelen ser altamente distribuidas, lo que complica el seguimiento de errores. Imagina una petición que pasa por API Gateway, luego por AWS Lambda, guarda información en DynamoDB y finalmente publica un mensaje en AWS SNS. Si algo falla en ese flujo, el rastreo manual del error puede volverse complejo y lento.

Con Sentry, este proceso se simplifica notablemente, ya que nos permite:

• Recibir notificaciones en tiempo real: enterarnos de los errores antes de que los usuarios los reporten.

• Tener el contexto necesario: acceder a stack traces y a los datos del evento que disparó la Lambda.

• Detectar cuellos de botella: identificar funciones que tardan demasiado en ejecutarse o que presentan un cold start elevado.

Ahora que sabemos un poco más sobre esta increíble plataforma, pasemos a la parte interesante: cómo integrarla con AWS Lambda.

Prerrequisitos

Antes de empezar, asegúrate de tener:

1. Una cuenta y un proyecto en Sentry.io

2. AWS CLI configurado en tu computador

3. Node.js y AWS CDK instalados

Paso 1: Configuración del Proyecto CDK

Primero, iniciaremos un nuevo proyecto en AWS CDK con TypeScript

mkdir sentry-with-aws-lambda
cd sentry-with-aws-lambda
cdk init app --language typescript .

A continuación, necesitamos instalar las dependencias necesarias. Usaremos el paquete oficial de Sentry para AWS Lambda.

npm install @sentry/aws-serverless
# Si usas yarn
yarn add @sentry/aws-serverless
# O si usas pnpm
pnpm add @sentry/aws-serverless

Paso 2: Crear el Handler de la Lambda

Vamos a crear una función sencilla que simule un error para ver como llega el error a Sentry. Crea un archivo en src/lambdas/handler.ts.

Lo importante aquí es “envolver” tu handler con Sentry. Esto asegura que cualquier excepción no capturada sea interceptada y enviada a Sentry antes de que el proceso de la Lambda termine.

// src/lambdas/handler.ts
import * as Sentry from "@sentry/aws-serverless";
import { APIGatewayProxyEventV2, APIGatewayProxyResultV2 } from "aws-lambda";

// 1. Inicializa Sentry fuera del handler
Sentry.init({
  dsn: process.env.SENTRY_DSN,
  tracesSampleRate: 1.0, // Ajusta esto en producción (ej. 0.1 para 10%)
});

// 2. Definimos el codigo de nuestro handler
export const main = async (
  event: APIGatewayProxyEventV2
): Promise<APIGatewayProxyResultV2> => {
  console.log("Procesando evento:", event.requestContext.requestId);

  // Simulamos un error aleatorio para probar
  if (event.queryStringParameters?.error === "true") {
    throw new Error("Oops, something went wrong in the lambda!");
  }

  return {
    statusCode: 200,
    body: JSON.stringify({
      message: "Hola Mundo!",
      eventId: event.requestContext.requestId,
    }),
  };
};

// 3. Envuelve el handler con Sentry
export const handler = Sentry.wrapHandler(main);

Paso 3: Definir la Infraestructura con CDK

Ahora vamos a definir la infraestructura en nuestro stack de CDK. Usaremos el construct NodejsFunction, ideal para Lambdas con TypeScript, ya que usa esbuild para transpilar y empaquetar el código automáticamente.

Edita el archivo en lib/sentry-with-aws-lambda-stack.ts:

import { Stack, StackProps } from "aws-cdk-lib";
import { Runtime } from "aws-cdk-lib/aws-lambda";
import { NodejsFunction } from "aws-cdk-lib/aws-lambda-nodejs";
import { Construct } from "constructs";
import path = require("node:path");

export class SentryWithAwsLambdaStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    // Definimos la Lambda
    const mySentryLambda = new NodejsFunction(this, 'SentryExampleFunction', {
      functionName: "sentry-example-lambda",
      runtime: lambda.Runtime.NODEJS_20_X, // Usa siempre versiones LTS recientes
      entry: path.join(__dirname, '../src/lambdas/handler.ts'),
      handler: 'handler',
      environment: {
        // Pasamos el DSN como variable de entorno
        // RECOMENDACIÓN: En producción, usa AWS Secrets Manager o SSM Parameter Store
        SENTRY_DSN: 'TU_SENTRY_DSN_AQUI'
      },
    });
  }
}

Paso 4: Despliegue y Prueba

Despliega tu stack en AWS con el siguiente comando:

cdk deploy

Una vez desplegado, ve a la consola de AWS Lambda y prueba la función con un evento de prueba. Alternativamente, si conectaste un API Gateway, puedes invocar la URL.

Para probar el error, asegúrate de enviar el parámetro que programamos: ?error=true.

1. Invoca la función para generar el error.

2. Ve a tu dashboard de Sentry.

3. Verás la excepción reportada junto con el stack trace y el contexto del evento.

Integrar Sentry en AWS Lambda cambia por completo la forma en que te enfrentas a los errores en arquitecturas serverless. En lugar de reaccionar cuando un usuario reporta un problema, pasas a tener visibilidad inmediata, contexto claro y un contexto completo de lo que ocurrió en producción.

Lo valioso no es solo saber que algo falló, sino entender por qué falló y en qué condiciones, sin tener que reconstruir el problema a partir de logs dispersos. Esa diferencia es la que realmente reduce el estrés y el tiempo invertido en depurar.

Con pocos pasos y usando AWS CDK + TypeScript, puedes integrar Sentry de forma limpia, mantenible y alineada con un flujo moderno de desarrollo serverless.

El repositorio completo del ejemplo está disponible aquí: https://github.com/ashelenlanube/sentry-with-aws-lambda

Si ya usas Lambda en producción, te recomiendo probar Sentry aunque sea en una función pequeña. Ver un error con contexto real por primera vez suele ser suficiente para no querer volver atrás.

Si este artículo te resultó útil, compártelo o deja un comentario con tus dudas o experiencias. 🚀