Startserver.mjs

import fs from "fs";
import fetch from "node-fetch";
import cron from "node-cron";
import nodemailer from "nodemailer";
import { WebClient } from "@slack/web-api";
import Database from "better-sqlite3";
import moment from "moment";
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";

const SMTP_HOST = "Pass your SMTP host here...";
const SMTP_PORT = "Pass your SMTP port here...";
const SMTP_USER = "Pass your SMTP user here...";
const SMTP_PASS = "Pass your SMTP password here...";
const db = new Database("apiHealth.db");

const storeInDB = (data) => {
  db.exec("CREATE TABLE IF NOT EXISTS objects (data TEXT)");
  const serializedData = JSON.stringify(data);
  const insert = db.prepare("INSERT INTO objects (data) VALUES (?)");
  insert.run(serializedData);
  console.log("Data stored in database successfully...");

  const rows = db.prepare("SELECT * FROM objects").all();
  const deserializedData = rows.map((row) => JSON.parse(row.data));
  // console.log("Data read from database:", deserializedData);
};

const readAPIsFromJSON = () => {
  try {
    const data = fs.readFileSync(new URL("./apis.json", import.meta.url));
    return JSON.parse(data);
  } catch (error) {
    console.error("Error reading APIs from JSON:", error);
    throw error;
  }
};

const sendEmail = async (unhealthyAPI) => {
  try {
    let transporter = nodemailer.createTransport({
      host: SMTP_HOST,
      port: SMTP_PORT,
      auth: {
        user: SMTP_USER,
        pass: SMTP_PASS,
      },
      secure: false,
      tls: {
        ciphers: "SSLv3",
      },
    });

    for (const api of unhealthyAPI) {
      if (api.value && !api.value.healthy) {
        for (const ownerEmail of api.owners) {
          let mailOptions = {
            from: SMTP_USER,
            to: ownerEmail,
            subject: `Unhealthy API Alert:  ${api.name} ⚠️`,
            text: `
                        ⚠️ Unhealthy API Alert for ${api.name} ⚠️
                        
                        Owner Email: ${
                          ownerEmail ? ownerEmail : "Not Available"
                        }
                        
                        --------------------
                        • API Name: ${api.name ? api.name : "Not Available"}
                        • API Health: ${
                          api.value.healthy ? "Healthy" : "Unhealthy 🚫"
                        }
                        • Error: ${
                          api.value.error ? api.value.error : "Not Available"
                        }
                        • API EndPoint: ${
                          api.endpoint ? api.endpoint : "Not Available"
                        }
                        • API Method: ${
                          api.method ? api.method : "Not Available"
                        }
                        • API Headers: ${
                          api.headers
                            ? JSON.stringify(api.headers)
                            : "Not Available"
                        }
                        • API Body: ${api.body ? api.body : "Not Available"}
                        • API Query Params: ${
                          api.queryParams
                            ? JSON.stringify(api.queryParams)
                            : "Not Available"
                        }
                        • Status: ${
                          api.value.status ? api.value.status : 500 + "❌"
                        }
                        • Message: ${
                          api.value.message
                            ? api.value.message
                            : api.value.error
                            ? api.value.error
                            : "Not Available"
                        }
                        • Time: ${
                          api.value.time ? api.value.time : moment().format()
                        }
                        --------------------

                        "This email has been automatically generated by the API Health Monitoring System. Please refrain from replying to this email."
                        `,
          };
          await transporter.sendMail(mailOptions);
          console.log("Email sent successfully...");
          break;
        }
      }
    }
  } catch (error) {
    console.error(`Error sending email for unhealthy APIs:`, error);
  }
};

const sendSlackMessage = async (unhealthyAPI) => {
  try {
    // Create a new instance of the WebClient class with the WebClient token passed in the constructor to authenticate with Slack API using the WebClient.
    const slackClient = new WebClient("<pass slack WebClient Token >");

    for (const api of unhealthyAPI) {
      if (api.value && !api.value.healthy) {
        const messageBlock = {
          blocks: [
            {
              type: "section",
              text: {
                type: "mrkdwn",
                text: `:warning: *Unhealthy API Alert for ${api.name}*`,
              },
            },
            {
              type: "divider",
            },
            {
              type: "section",
              fields: [
                {
                  type: "mrkdwn",
                  text: `*API Name:*\n${api.name} 📡`,
                },
                {
                  type: "mrkdwn",
                  text: `*Owner Email:*\n${
                    api.owners == ""
                      ? "Not Available  ⚠️"
                      : api.owners
                      ? api.owners + "   👨‍💻"
                      : "Not Available  ⚠️"
                  }`,
                },
              ],
            },
            {
              type: "divider",
            },
            {
              type: "section",
              fields: [
                {
                  type: "mrkdwn",
                  text: `*API Health:*\n${
                    api.value.healthy ? "Healthy  ✅" : "Unhealthy  ❌"
                  }`,
                },
                {
                  type: "mrkdwn",
                  text: `*Error:*\n${
                    api.value.error ? api.value.error : "Not Available  ✔️"
                  }`,
                },
              ],
            },
            {
              type: "divider",
            },
            {
              type: "section",
              fields: [
                {
                  type: "mrkdwn",
                  text: `*API EndPoint:*\n${
                    api.endpoint
                      ? "```" + api.endpoint + "  🔗" + "```"
                      : "```" + "Not Available  ⚠️" + "```"
                  }`,
                },
                {
                  type: "mrkdwn",
                  text: `*API Method:*\n${
                    api.method
                      ? "```" + api.method + "```"
                      : "```" + "Not Available  ⚠️" + "```"
                  }`,
                },
              ],
            },
            {
              type: "divider",
            },
            {
              type: "section",
              fields: [
                {
                  type: "mrkdwn",
                  text: `*API Headers:*\n${
                    api.headers
                      ? "```" + JSON.stringify(api.headers) + "```"
                      : "Not Available  ⚠️"
                  }`,
                },
                {
                  type: "mrkdwn",
                  text: `*API Body:*\n${
                    api.body == undefined
                      ? "```" + "Not Available" + "```"
                      : api.body
                      ? "```" + api.body + "```"
                      : "```" + JSON.stringify(api.json) + "```"
                      ? "```" + JSON.stringify(api.json) + "```"
                      : "Not Available"
                  }`,
                },
              ],
            },
            {
              type: "divider",
            },
            {
              type: "section",
              fields: [
                {
                  type: "mrkdwn",
                  text: `*API Query Params:*\n${
                    api.queryParams
                      ? "```" + JSON.stringify(api.queryParams) + "```" + ""
                      : "Not Available"
                  }`,
                },
              ],
            },
            {
              type: "divider",
            },
            {
              type: "section",
              fields: [
                {
                  type: "mrkdwn",
                  text: `*Status:*\n${
                    api.value.status
                      ? api.value.status == "200"
                        ? "200   ✅"
                        : api.value.status == "404"
                        ? "```" + "404  ⌛" + "```"
                        : "```" + api.value.status + "   ❌" + "```"
                      : "```" + "500  ❌" + "```"
                  }`,
                },
                {
                  type: "mrkdwn",
                  text: `*Message:*\n${
                    api.value.message
                      ? "```" + api.value.message + "  📌" + "```"
                      : "```" + api.value.error + "  📌" + "```"
                  }`,
                },
              ],
            },
            {
              type: "divider",
            },
            {
              type: "section",
              fields: [
                {
                  type: "mrkdwn",
                  text: `*Time:*\n${
                    api.value.time
                      ? api.value.time + "   ⏰"
                      : moment().format() + "   ⏰"
                  }`,
                },
              ],
            },
          ],
        };

        const result = await slackClient.chat.postMessage({
          channel: api.slack,
          blocks: messageBlock.blocks,
        });

        console.log("Slack message sent successfully...");
      }
    }
  } catch (error) {
    console.error(`Error sending Slack message for unhealthy APIs:`, error);
  }
};

const checkHealth = async (api) => {
  try {
    let url = api.endpoint;
    if (api.queryParams) {
      const queryParams = new URLSearchParams(api.queryParams);
      url += `?${queryParams.toString()}`;
    }

    const response = await fetch(url, {
      method: api.method,
      headers: api.headers,
      body: api.json ? JSON.stringify(api.json) : api.body,
    });

    if (response.ok) {
      return {
        ...response,
        healthy: true,
        name: api.name,
        url: response.url,
        status: response.status,
        message: response.statusText,
        time: moment().format(),
      };
    } else {
      return {
        ...response,
        healthy: false,
        name: api.name,
        url: response.url,
        status: response.status,
        message: response.statusText,
        time: moment().format(),
      };
    }
  } catch (error) {
    return {
      error: error.message,
      healthy: false,
      name: api.name,
      time: moment().format(),
    };
  }
};

const checkAPIsStatuspage = async (mergedResults) => {
  const apiKey = "4bdaa902fdbe47b9b52ea01f92ea2ed0";

  async function patchComponentStatus(
    componentId,
    healthy,
    error,
    name,
    headers,
    method,
    urlAPI,
    status,
    message
  ) {
    //<key> is the page key of the statuspage.io replace it with your page key or leave it as it is if you want any dashboard to be updated.

    const url = `https://api.statuspage.io/v1/pages/<key>/components/${componentId}?api_key=${apiKey}`;
    const data = {
      component: {
        status: healthy ? "operational" : "major_outage",
        description: `API ${name}\n URL: ${urlAPI}\n Status: ${status}\n Message: ${message} \n Method: ${method}\n`,
      },
    };

    try {
      const response = await fetch(url, {
        method: "PATCH",
        body: JSON.stringify(data),
        headers: {
          "Content-Type": "application/json",
        },
      });
      const result = await response.json();
      console.log(
        "PATCH request succeeded for all APIs on statuspage.io if you pass the correct componentId..."
      );
    } catch (error) {
      console.error("Error making PATCH request:", error);
    }
  }

  async function patchComponents() {
    for (const component of mergedResults) {
      await patchComponentStatus(
        component.componentId,
        component.value.healthy,
        component.value.error,
        component.value.name,
        component.headers,
        component.method,
        component.value.url ? component.value.url : component.endpoint,
        component.value.status ? component.value.status : 500,
        component.value.message
          ? component.value.message
          : component.value.error
      );
    }
  }

  patchComponents();
};

const checkAPIsHealth = async (apis) => {
  try {
    console.log("Checking APIs health...");
    let results = await Promise.allSettled(apis.map((api) => checkHealth(api)));
    let mergedResults = apis.map((api, i) => ({
      ...api,
      value: results[i].status === "fulfilled" ? results[i].value : null,
    }));
    console.log("APIs health checked successfully...");

    const unhealthyAPIs = mergedResults.filter(
      (api) => !api.value || !api.value.healthy
    );
    if (unhealthyAPIs.length > 0) {
      console.log(unhealthyAPIs.length, "Unhealthy APIs found");
      console.log("Sending email and slack message for unhealthy APIs...");
      await sendEmail(unhealthyAPIs);
      await sendSlackMessage(unhealthyAPIs);
    } else {
      console.log("All APIs are healthy...");
    }
    checkAPIsStatuspage(mergedResults);
    console.log("Storing results in database...");
    storeInDB(mergedResults);
    return mergedResults;
  } catch (error) {
    console.error("Error occurred while checking APIs health:", error);
    throw error;
  }
};

cron.schedule("*/1 * * * *", async () => {
  console.log("Running a task every minute...");
  try {
    const apis = readAPIsFromJSON();
    console.log("APIs read from JSON successfully", apis);
    await checkAPIsHealth(apis.apis);
  } catch (error) {
    console.error("An error occurred during task execution:", error);
  }
});