🚀 Monitor Track Apprecio

monitor-track-apprecio es una librería que proporciona middleware para monitoreo y tracking en aplicaciones Node.js. Actualmente soporta Sentry para observabilidad.

📦 Instalación

Para instalar la librería, usa el siguiente comando:

npm install monitor-track-apprecio

🚀 Uso en un Proyecto Express.js

La libreria se debe ubicar debajo de express.json para que pueda tomar el body del request y antes que cualquier middlaware para que intercepte todas las peticiones http

"use strict";

const express = require("express");
const path = require("path");
const logger = require("morgan");
const { observabilityMiddleware, setObservabilityProvider,observabilityErrorMiddleware } = require("monitor-track-apprecio");

const app = express();

app.set("views", path.join(__dirname, "views"));
app.set("view engine", "pug");

app.use(logger("dev"));
app.use(express.json({ limit: "1gb", extended: true }));
app.use(express.urlencoded({ limit: "1gb", extended: false }));

// 🔹 Configurar el proveedor de observabilidad
setObservabilityProvider({ name: "sentry", dns: process.env.SENTRY_DSN }, process.env.APP_ENV);
// 🔹 Usar el middleware de observabilidad
app.use(observabilityMiddleware);

// punto final para lanzar un error controlado;
app.get("/debug-sentry", function mainHandler(req, res) {
  throw new Error("My first Sentry error!");
});



app.use("/", require("./routes/index"));
app.use("/graphql", require("./routes/graphqlRoutes"));

require("./routes/graphql").applyMiddleware({ app, path: "/graphql" });

// 🔹 Agregar el manejador de errores de Sentry antes de cualquier otro middleware de error
app.use(observabilityErrorMiddleware);

// error handler
app.use(function (err, req, res, next) {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get("env") === "development" ? err : {};
  sendError(err)
  // render the error page
  res.status(err.status || 500);
  res.render("error");
});

app.listen(3000, () => {
  console.log("🚀 Servidor corriendo en http://localhost:3000");
});

⚙️ Configuración de Variables de Entorno

APP_ENV=dev
SENTRY_DSN=https://your-sentry-dsn

🚀 Uso en un ApolloServer

"use strict";
const { ApolloServer } = require('apollo-server-express');
const constraintDirective = require('graphql-constraint-directive');
const { getObservabilityApolloPlugin} = require("monitor-track-apprecio");
var schemas = require('../graphql/schemas/graph');

var resolvers = require('../graphql/resolvers/graph');

const sentryConfig = getObservabilityApolloPlugin();

const server = new ApolloServer({
	typeDefs: schemas,
	resolvers: resolvers,
	introspection: ((process.env.graphQlInstrospection && process.env.graphQlInstrospection === 'true') ? true : false),
	playground: ((process.env.graphQlPlayGround && process.env.graphQlPlayGround === 'true') ? true : false),
	schemaDirectives: { constraint: constraintDirective },
	plugins: [sentryConfig],
	context: ({ req, res }) => (
		require('../graphql/graphModels')(req, res)
	)
});

module.exports = server;

🚀 Uso en moongose connection

"use strict";

const mongoose = require("mongoose");
mongoose.Promise = global.Promise;
mongoose.set('useCreateIndex', true);
const { 
	captureErrorMiddleware
  } = require("monitor-track-apprecio");

const mongooseCon = new function () {
	let mongoCon = {};
	this.conexion = function (_stringCon) {
		console.log('conexion controller');
		mongoCon.con = mongoose.createConnection(_stringCon,
			{
				useNewUrlParser: true
				//,reconnectTries: Number.MAX_VALUE // Never stop trying to reconnect
				//,reconnectInterval: 1000 // Reconnect every 1000ms
				//,poolSize: 100 // Maintain up to 10 socket connections
				//,bufferMaxEntries: 0 // If not connected, return errors immediately rather than waiting for reconnect
				,connectTimeoutMS: 3000000 // Give up initial connection after 10 seconds
				,socketTimeoutMS: 3000000 // Close sockets after 15 seconds of inactivity
				,useUnifiedTopology: true
				,keepAlive: true
			}, function (error) {
				if (error) {
					console.log(error);
					captureErrorMiddleware(error);
				} else {
					console.log('Conectado exitosamente');
				}
			});
		mongoCon.mongo = mongoose;
		return mongoCon;
	}
};

module.exports = mongooseCon;