git clone https://github.com/DesmondSanctity/twilio-log-alert.git 

npm install 

PORT=5000 DB_NAME=XXXXX DB_USERNAME=XXXXX DB_PASSWORD=XXXXX DB_HOST=XXXXX JWT_SECRET=XXXXX JWT_EXPIRES_IN=XXXXX TWILIO_AUTH_TOKEN=XXXXX TWILIO_ACCOUNT_SID=XXXXX REDIS_URL=XXXXX 

DB_NAME=alertdb DB_USERNAME=root DB_PASSWORD= DB_HOST=localhost 

node -e "console.log(require('crypto').randomBytes(32).toString('hex'))" 

npm install winston winston-daily-rotate-file twilio 

// Define sensitive keys you want to remove from logs export const SensitiveKeys = { UserId: "userId", Password: "password", //this is how the value is stored in the config, service or database. NewPassword: "newPassword", OldPassword: "oldPassword", RepeatPassword: "repeatPassword", PhoneNumber: "phoneNumber", Token: "token", Authorization: "authorization", }; 

export const SuccessMessages = { CreateSuccess: "Resource created successfully", GetSuccess: "Resource retrieved successfully", UpdateSuccess: "Resource updated successfully", DeleteSuccess: "Resource deleted successfully", GenericSuccess: "Operation completed successfully", UserRemoveSuccess: "User removed!", ProductRemoveSuccess: "Product removed!", }; export const HTTPHeaders = { ResponseTime: "x-response-time", ForwardedFor: "x-forwarded-for", }; export const HTTPMethods = { HEAD: "HEAD", GET: "GET", POST: "POST", PATCH: "PATCH", PUT: "PUT", DELETE: "DELETE", }; 

import { SensitiveKeys } from "./sensitiveKeys.js"; const sensitiveKeysList = Object.values(SensitiveKeys) export const redactLogData = (data) => { if (typeof data === 'object' && data !== null) { if (Array.isArray(data)) { return data.map(item => redactLogData(item)); } const redactedData = {}; for (const key in data) { if (sensitiveKeysList.includes(key)) { redactedData[key] = '******'; // replace sensitive data with * } else { // Recursively redact sensitive keys within nested objects redactedData[key] = redactLogData(data[key]); } } return redactedData; } else { return data; } }; 

export const LogIndentation = { None: 0, SM: 2, // Small MD: 4, // Medium LG: 6, // Large XL: 8, // XLarge XXL: 10, XXXL: 12, }; 

import twilio from "twilio"; import { accountSid, authToken } from "../../config/index.js"; // Initialize Twilio client with your credentials const twilioClient = new twilio(accountSid, authToken); // A formatted message to send to the user const formatErrorAlert = async ({ errorDescription, affectedEndpoint, startTime, duration, details, alertType, method, }) => { return ` *${alertType == "Critical" ? `⛔ Alert Type ` : `🚫 Alert Type: `}${alertType}*\n ⚠️ Error Description: ${errorDescription}\n 🌐 Affected Endpoint: ${affectedEndpoint}\n 🔗 HTTP Method: ${method}\n 🕒 Start Time: ${startTime}\n ⌛ Duration: ${duration}\n 📝 Details: ${JSON.stringify(details)}\n `; }; export const sendWhatsAppAlert = async (messageParams) => { const message = await formatErrorAlert(messageParams); try { await twilioClient.messages.create({ body: `New Incident Alert:\n ${message}`, from: "whatsapp:<your Twilio WhatsApp number>", to: "whatsapp:<your own number>", }); console.log(`WhatsApp Alert sent successfully.`); } catch (error) { console.error(`WhatsApp Alert error: ${error.message}`); } }; 

import { randomBytes } from "crypto"; import winston from "winston"; import { LogIndentation } from "../utils/log/indentation.js"; import DailyRotateFile from "winston-daily-rotate-file"; const { combine, timestamp, json, printf } = winston.format; const timestampFormat = "MMM-DD-YYYY HH:mm:ss"; const appVersion = process.env.npm_package_version; const generateLogId = () => randomBytes(16).toString("hex"); export const httpLogger = winston.createLogger({ format: combine( timestamp({ format: timestampFormat }), json(), printf(({ timestamp, level, message, ...data }) => { const response = { level, logId: generateLogId(), timestamp, appInfo: { appVersion, environment: process.env.NODE_ENV, proccessId: process.pid, }, message, data, }; // indenting logs for better readbility return JSON.stringify(response, null, LogIndentation.MD); }) ), transports: [ // log to console new winston.transports.Console({ // if set to true, logs will not appear silent: process.env.NODE_ENV === "test_env", // true/false }), // log to file, but rotate daily new DailyRotateFile({ // each file name includes current date filename: "logs/rotating-logs-%DATE%.log", datePattern: "MMMM-DD-YYYY", zippedArchive: false, // zip logs true/false maxSize: "20m", // rotate if file size exceeds 20 MB maxFiles: "14d", // max files }), ], }); 

import { sendWhatsAppAlert } from "../alert/alertFunctions.js"; import { HTTPHeaders } from "../constants/constants.js"; import { redactLogData } from "./redactedData.js"; const formatHTTPLoggerResponse = (req, res, responseBody, requestStartTime) => { let requestDuration = ""; let startTime = ""; const formattedBody = JSON.parse(responseBody); const textBody = { request: { host: req.headers.host, url: req.url, body: (req.body && redactLogData(req.body)) || {}, params: req?.params, query: req?.query, clientIp: req?.headers[HTTPHeaders.ForwardedFor] ?? req?.socket.remoteAddress, }, response: { statusCode: res.statusCode, requestDuration, body: redactLogData(formattedBody), }, } if (requestStartTime) { const endTime = Date.now() - requestStartTime; requestDuration = `${endTime / 1000}s`; // ms to seconds // Create a Date object from the timestamp const date = new Date(requestStartTime); // Format the date into a human-readable string startTime = date.toLocaleString(); } // message param for twilio alert const messageParams = { errorDescription: formattedBody?.message, affectedEndpoint: req.baseUrl, startTime: startTime, duration: requestDuration, details: redactLogData(textBody), alertType: res.statusCode >= 500 ? "Critical" : "Error", method: req.method, }; if (res.statusCode >= 400) { sendWhatsAppAlert(messageParams); } return { request: { headers: (req.headers && redactLogData(req.headers)) || {}, host: req.headers.host, baseUrl: req.baseUrl, url: req.url, method: req.method, body: (req.body && redactLogData(req.body)) || {}, params: req?.params, query: req?.query, clientIp: req?.headers[HTTPHeaders.ForwardedFor] ?? req?.socket.remoteAddress, }, response: { headers: res.getHeaders(), statusCode: res.statusCode, requestDuration, body: redactLogData(formattedBody), }, }; }; export default formatHTTPLoggerResponse; 

import formatHTTPLoggerResponse from "./formatLog.js"; import { HTTPMethods, SuccessMessages } from "../constants/constants.js"; import { httpLogger } from "../../middlewares/logger.js"; export const responseInterceptor = (req, res, next) => { // used to calculate time between request and the response const requestStartTime = Date.now(); // Save the original response method const originalSend = res.send; let responseSent = false; // Override the response method res.send = function (body) { if (!responseSent) { if (res.statusCode < 400) { httpLogger.info( getResponseMessage(req.method), formatHTTPLoggerResponse(req, res, body, requestStartTime) ); } else { httpLogger.error( body.message, formatHTTPLoggerResponse(req, res, body, requestStartTime) ); } responseSent = true; } // Call the original response method return originalSend.call(this, body); }; // Continue processing the request next(); }; function getResponseMessage(responseMethod) { switch (responseMethod) { case HTTPMethods.POST: return SuccessMessages.CreateSuccess; case HTTPMethods.GET: return SuccessMessages.GetSuccess; case HTTPMethods.PUT || HTTPMethods.PATCH: return SuccessMessages.UpdateSuccess; case HTTPMethods.DELETE: return SuccessMessages.DeleteSuccess; default: return SuccessMessages.GenericSuccess; } } 

import express from "express"; import cors from "cors"; import redis from "redis"; import bodyParser from "body-parser"; import { port, redisURL } from "./src/config/index.js"; import { AppError } from "./src/utils/responseHandler.js"; import { responseInterceptor } from "./src/utils/log/interceptor.js"; import swaggerDocs from "./swagger.js"; import "./src/models/index.js"; import userRouter from "./src/routes/users.js"; import authRouter from "./src/routes/auth.js"; const app = express(); app.use(cors()); app.use(express.json()); app.disable("x-powered-by"); // less hackers know about our stack app.use(bodyParser.urlencoded({ extended: false })); // Your middleware function to handle errors const errorHandler = (err, req, res, next) => { if (res.headersSent) { return next(err); } if (err instanceof AppError) { // If it's a CustomError, respond with the custom status code and message return res .status(err.statusCode) .json({ status: err.status, error: err.message, code: err.statusCode }); } else { // If it's an unknown error, respond with a 500 status code and a generic error message return res .status(500) .json({ status: "critical", error: "Internal Server Error.", code: 500 }); } }; // Applying the error handling middleware app.use(errorHandler); // create a client connection export const client = redis.createClient({ url: redisURL, }); // on the connection client.on("connect", () => console.log("Connected to Redis")); client.connect(); // Run the swagger docs before log interception swaggerDocs(app, port); // Place an interceptor above all routes that you want to `intercept` app.use(responseInterceptor); /** HTTP GET Request */ app.get("/", (req, res) => { res.status(201).json("Home GET Request"); }); app.use("/api/v1/user", userRouter); app.use("/api/v1/auth", authRouter); app.listen(port, () => { console.log(` ########################################### Server is currently running at port ${port} ###########################################`); }); 

ngrok http 5000