Implementando Sentry para el manejo de log de errores

Clase 23 de 43 • Curso de Express.js 2018

Contenido del curso

Bienvenida e introducción

Template Engines y archivos estáticos

Creando un API Restful

Conectando Express.js con servicios externos

Middlewares: En el medio del request

Autenticación en Express.js

Testing

Deployment

Tomar examen

Para empezar a usar Sentry lo primero que debemos hacer es crear una cuenta usando el link https://sentry.io/signup/. Para agilizar este paso recomiendo que usen su cuenta de GitHub como método de inscripción y sigan los pasos.

Al ingresar al dashboard de Sentry lo que podemos hacer es ir directamente onboarding haciendo click en la alerta amarilla que aparece en la parte superior o mediante el link https://sentry.io/onboarding/<organización>/.

Allí nos pedirá que seleccionemos un lenguage y un team, para el lenguaje seleccionaremos Server > Node.js le daremos un nombre al proyecto dejaremos el team que tiene por defecto y a continuación haremos click en Create Project.

Después de ello nos entregara unas instrucciones para configurar Sentry. Lo que haremos es instalar la dependencia de Sentry e inicializar su configuración en el archivo /utils/middlewares/errorsHandlers.js.

Recordemos que no debemos dejar ninguna key, secret o identificador quemado en nuestro código por lo que la recomendación es moverlo a variables de entorno y configuración usando el archivo .env.

// .env.example y .env

SENTRY_DNS=
SENTRY_ID=

// config/index.js

require("dotenv").config();

const config = {
  sentryDns: process.env.SENTRY_DNS,
  sentryId: process.env.SENTRY_ID
};

module.exports = { config: config };

// utils/middlewares/errorsHandlers.js

const Sentry = require("@sentry/node");
const { config } = require("../../config");

Sentry.init({ dsn: `https://${config.sentryDns}@sentry.io/${config.sentryId}` });

Y dentro de nuestro middleware logErrors agregamos el capturador de errores de Sentry:

// utils/middlewares/errorsHandlers.js

function logErrors(err, req, res, next) {
  Sentry.captureException(err);
  console.error(err.stack);
  next(err);
}

Le damos click en All done! y nos reenviara al dashboard dónde podremos monitorear los errores que ocurren en nuestra aplicación.

De esta manera cualquier error que ocurra en nuestra aplicación desplegada en producción estará registrado en Sentry y podremos revisarlos y corregirlos proactivamente.

Si quieres obtener más información sobre cómo capturar eventos y mensajes manualmente puedes consultarlo aquí https://docs.sentry.io/error-reporting/capturing/?platform=node

Comentarios

HUGO ANDRES DIAZ BERNAL

student•

Despues de 1 hora ![](

Roberto Zapata

student•

Las imágenes de referencia de Sentry no aparecen por un error 404.

Mariandrea Cruz

student•

corregido, gracias!

Pedro Alberto Barrios Molina

student•

Les dejo mi configuración de Sentry para los que están teniendo problemas, espero sea de ayuda

Suponiendo un url dado de esta manera:

Sentry.init({
    dsn: "https://1d45ce2daead40f286eb14b354c86538@o552521.ingest.sentry.io/5699401",
  
    // Set tracesSampleRate to 1.0 to capture 100%
    // of transactions for performance monitoring.
    // We recommend adjusting this value in production
    tracesSampleRate: 1.0,
  }); */

en .env tendremos lo siguiente

// CONFIG

PORT = 8000;
CORS:*

// MONGO
DB_USER=xxxxxxxxxx
DB_PASSWORD=xxxxxxxxxx
DB_HOST=xxxxxxxxxxxxxx
DB_NAME=xxxxxxxxxxxxxxxx
SENTRY_DNS=1d45ce2daead40f286eb14b354c86538@o552521
SENTRY_ID=5699401

En errorsHandlers.js tendremos lo siguiente

const { config } =  require('../../config');
const Sentry = require("@sentry/node");

 Sentry.init({
    dsn: `https://${config.sentryDns}.ingest.sentry.io/${config.sentryId}`,

    // Set tracesSampleRate to 1.0 to capture 100%
    // of transactions for performance monitoring.
    // We recommend adjusting this value in production

    tracesSampleRate: 1.0,   
})

//Imporante aquí para capturar el error
function logErrors(err, req, res, next){
    Sentry.captureException(err);
    console.log(err.stack);
    next(err);
}

Y ya nada más para simular un error en routes/views/products.js agregamos un throw new error.

router.get('/', async function(req, res, next){
    const { tags } =  req.query
    try {
        throw new Error ('this is a error')
        const products = await productService.getProducts({ tags });
        res.render("products", { products });
        
    } catch (error) {
        next(error)
    }
});

Espero les sea de utilidad.

Luis Lira

student•

Actualmente con Sentry lo que tienen que hacer es mandar un error de prueba para que los deje continuar, puede hacer toda la instalación y poner un throw new Error() en la parte de la ruta de las vistas para que se envíe y terminen la instalación.

Héctor Martínez Reséndiz

student•

Muchas gracias, no sabia que hacer!

Genessis Jimenez

student•

Sentry también tiene la opción de proyectos Express… Porque no usar ese en lugar de Node?

Alejandro Valenzuela

student•

Genial, no conocía estas tipos de herramientas para el monitoreo de app en producción..!

pd: dejo un articulo sobre Sentry.. Sentry

David Alejandro Mosquera Moreno

student•

Hecho! .

. No olvidar incluir la el error de prueba

router.get('/', async (req, res, next) => {
  const { tags } = req.query;

  try {
    myUndefinedFunction();
    const products = await productService.getProducts({ tags });

    res.status(200).json({
      data: products,
      message: 'Products listed'
    })
  } catch (error) {
    next(error)
  }
})```

Eden Gomez Gress

student•

Disculpa comppanero como conseguiste que en la pare izquierda del cuadro de dialogo de Node.js cambiara su status a "Event was receive"

David Alejandro Mosquera Moreno

student•

Hola @EdenGg . Lo que hice fue seguir los pasos que me daba la página de Sentry. Configuré esto en el archivo errorsHandlers.js

const Sentry = require("@sentry/node");

Sentry.init({ dsn: `https://${config.sentryDns}@sentry.io/${config.sentryId}` });

Y dentro de logErrors( ) esto:

// utils/middlewares/errorsHandlers.js

function logErrors(err, req, res, next) {
  Sentry.captureException(err);
  console.error(err.stack);
  next(err);
}

Y pues de ahí puse esta función myUndefinedFunction(); que no estaba declarada, dentro del try catch de getProducts para que me arrojara el error y Sentry lo detectara.

Gloriq Lopez

student•

Hice de esta manera el path de Sentry una url de ejemplo de sentry "https://4def5517db8e345fb21ff938355b749763@e490773.ingest.sentry.io/554829890 En el archivo punto .env colocaremos: SENTRY_DNS= 4def5517db8e345fb21ff938355b749763@e490773 SENTRY_ID= 554829890 y después en archivo errorsHandlers: Sentry.init({dsn: https://${config.sentryDns}.ingest.sentry.io/${config.sentryId}})

Carlos Enrique Ramírez Flores

student•

listo! Aquí mi código!

const Sentry = require(&quot;@sentry/node&quot;);
const { config } = require('../../config');

Sentry.init({ dsn: `${config.sentryDns}/${config.sentryId}` });

function logErrors(err, req, res, next){
    Sentry.captureException(err);
    console.error(err.stack);
    next(err);
}

function clientErrorHandler(err, req, res, next) {
    //catch errors for ajax request
    if(req.xhr)
        res.status(500).json({ err: err.message});
    else
        next(err);
}

function errorHandler(err, req, res, next) {
    if(res.headersSent)
        next(err)
    
    if(!config.dev)
        delete err.stack;

    res.status(err.status || 500);
    res.render(&quot;error&quot;, {error: err});
}

module.exports = {
    logErrors,
    clientErrorHandler,
    errorHandler
}

Francisco Javier Suarez Verdugo

student•

Listo, Sentry configurado.

Daniel Salazar Munoz

student•

Ese pequeño momento de felicidad cuando vez que ya te dice la página: hemos recibido el evento, puedes continuar.

Naldo Duran

student•

✌

Maided Guadalupe Hernández Ponce

student•

Si les sale la siguiente leyenda en Sentry: TypeError poll(../../sentry/scripts/views.js) error Object [object Object] has no method 'updateFrom' Es un ejemplo de error, en mi caso lo borré. Para ver si funciona, pueden colocar un throw error en la ruta: routes/views/products.js justo así:

router.get('/', async function (req, res, next) {
  const { tags } = req.query
  try {
   throw new Error('This is an error')

O si no, Sentry te da el siguiente código con un error y que lo puedes colocar en errorHandlers.js:

const transaction = Sentry.startTransaction({
  op: 'test',
  name: 'My First Test Transaction'
})

setTimeout(() => {
  try {
    foo()
  } catch (e) {
    Sentry.captureException(e)
  } finally {
    transaction.finish()
  }
}, 99)

Emmanuel Rodríguez

student•

Mi configuración para Sentry:

// dependencies error handler
import * as Sentry from '@sentry/node';

// other dependencies
import config from '../config/envServer';

// handler sentry configuration
const { mode, sentryDns } = config;

Sentry.init({
    dsn: sentryDns,
    environment: mode,
    tracesSampleRate: 1.0
});

const logErrors = (err, req, res, next) => {
    Sentry.captureException(err);
    res.status(500).json(err);
};

export default logErrors;

jorge llanque

student•

Tuve problemas con invalid dsn, pero colocando toda la ruta en el archivo lo solucioné

Carlyle Komalram

student•

Realmente util, muchas gracias por el aporte.

Michael Camelo

student•

Excelente, no conocía esta herramienta

Rodrigo Hernández

student•

Si eres nuevo y estas teniendo problemas con un error de Sentry de 'invalid dsn', prueba a colocar todo el path en el archivo de errorHandlers.js, sin utilizar el archivo .env, lo que me sucedio fue que estaba colocando en el SENTRY_DSN del archivo .evn tanto el DSN como el SENTRY_ID de junto.

Sentry.init({
    dsn: "https://1d45ce2daead40f286eb14b354c86538@o552521.ingest.sentry.io/5699401",
  
    // Set tracesSampleRate to 1.0 to capture 100%
    // of transactions for performance monitoring.
    // We recommend adjusting this value in production
    tracesSampleRate: 1.0,
  }); */

// CONFIG

PORT = 8000;
CORS:*

// MONGO
DB_USER=xxxxxxxxxx
DB_PASSWORD=xxxxxxxxxx
DB_HOST=xxxxxxxxxxxxxx
DB_NAME=xxxxxxxxxxxxxxxx
SENTRY_DNS=1d45ce2daead40f286eb14b354c86538@o552521
SENTRY_ID=5699401

const { config } =  require('../../config');
const Sentry = require("@sentry/node");

 Sentry.init({
    dsn: `https://${config.sentryDns}.ingest.sentry.io/${config.sentryId}`,

    // Set tracesSampleRate to 1.0 to capture 100%
    // of transactions for performance monitoring.
    // We recommend adjusting this value in production

    tracesSampleRate: 1.0,   
})

//Imporante aquí para capturar el error
function logErrors(err, req, res, next){
    Sentry.captureException(err);
    console.log(err.stack);
    next(err);
}

router.get('/', async function(req, res, next){
    const { tags } =  req.query
    try {
        throw new Error ('this is a error')
        const products = await productService.getProducts({ tags });
        res.render("products", { products });
        
    } catch (error) {
        next(error)
    }
});

router.get('/', async (req, res, next) => {
  const { tags } = req.query;

  try {
    myUndefinedFunction();
    const products = await productService.getProducts({ tags });

    res.status(200).json({
      data: products,
      message: 'Products listed'
    })
  } catch (error) {
    next(error)
  }
})```

const Sentry = require(&quot;@sentry/node&quot;);
const { config } = require('../../config');

Sentry.init({ dsn: `${config.sentryDns}/${config.sentryId}` });

function logErrors(err, req, res, next){
    Sentry.captureException(err);
    console.error(err.stack);
    next(err);
}

function clientErrorHandler(err, req, res, next) {
    //catch errors for ajax request
    if(req.xhr)
        res.status(500).json({ err: err.message});
    else
        next(err);
}

function errorHandler(err, req, res, next) {
    if(res.headersSent)
        next(err)
    
    if(!config.dev)
        delete err.stack;

    res.status(err.status || 500);
    res.render(&quot;error&quot;, {error: err});
}

module.exports = {
    logErrors,
    clientErrorHandler,
    errorHandler
}

const transaction = Sentry.startTransaction({
  op: 'test',
  name: 'My First Test Transaction'
})

setTimeout(() => {
  try {
    foo()
  } catch (e) {
    Sentry.captureException(e)
  } finally {
    transaction.finish()
  }
}, 99)

// dependencies error handler
import * as Sentry from '@sentry/node';

// other dependencies
import config from '../config/envServer';

// handler sentry configuration
const { mode, sentryDns } = config;

Sentry.init({
    dsn: sentryDns,
    environment: mode,
    tracesSampleRate: 1.0
});

const logErrors = (err, req, res, next) => {
    Sentry.captureException(err);
    res.status(500).json(err);
};

export default logErrors;

Implementando Sentry para el manejo de log de errores

Bienvenida e introducción

¿Dónde aprender Express.js actualizado?

Lo que aprenderás sobre Express.js

¿Qué es express y para qué sirve?

Creando tu primer servidor

Express application generator

Template Engines y archivos estáticos

Qué es template engine y cómo crearlo

Implementando un template engine

Usando Pug como template engine

Usando Handlebars como template engine

Creando nuestro layout de productos usando Pug

Manejo de archivos estáticos

Creando un API Restful

Anatomía de una API RESTful e implementación CRUD

Implementando nuestra capa de Servicios

Recapitulando el proyecto

Request object

Conectando Express.js con servicios externos

Conexión a Mongodb en Express.js

Conectando nuestros servicios con mongo DB

Implementando acciones CRUD en MongoDB

Configurar una cuenta en Amazon AWS

Middlewares: En el medio del request

Qué es un middleware y qué tipos existen

Manejo de errores usando un middleware

Validación de datos usando un middleware