Log_service/app/utils/runtimeCheckLogs.ts

import fs from "fs";
import chokidar from "chokidar";
import moment from "moment";
import LogDetectFile from "App/Models/LogDetectFile";
import LogReport from "App/Models/LogReport";
import KeyValue from "App/Models/KeyValue";
import Database from "@ioc:Adonis/Lucid/Database";
import { sendMessToZulip } from "./sendMessToZulip";
import { getListLineByItem } from "./getListLineByItem";
import { screenShot } from "./screenShot";
import { uploadFileToZulip } from "./uploadFileZulip";

// export default class loggerAPI {
export async function runtimeCheckLogs(folderPath) {
  try {
    let fileList = Array();
    let fileList_old = Array();

    // console.log(listKeyValues.map(obj=>obj.$original.value))
    // Function to update the list of files
    async function updateFileList() {
      //get date now
      let dateNow = moment(Date.now()).format("YYYY/MM/DD");
      //Get list file in folder
      fileList = fs.readdirSync(folderPath);
      //Get date modified
      fileList.map((file) => {
        const filePath = `${folderPath}/${file}`;
        if (file?.split(".")[filePath.split(".").length - 1] === "log") {
          const stats = fs.statSync(filePath);

          //scan file today
          if (dateNow !== moment(stats.mtime).format("YYYY/MM/DD")) {
            fileList = fileList.filter((i) => i !== file);
          }
        }
      });
    }

    // Watch the folder for new files
    const folderWatcher = chokidar.watch(folderPath);
    // folderWatcher.setMaxListeners(20);

    folderWatcher.on("add", async (filePath) => {
      //import log new file
      // console.log(filePath)
      if (
        //Sua \\ --> /
        filePath?.split(".")[filePath.split(".").length - 1] === "log" &&
        filePath.split("/")[filePath.split("/").length - 1]?.split("-")[0] ===
          moment(Date.now()).format("YYYYMMDD").toString()
      ) {
        console.log("New file added: ", filePath);
        await LogDetectFile.firstOrCreate(
          { file_name: filePath.split("/")[filePath.split("/").length - 1] },
          { file_name: filePath.split("/")[filePath.split("/").length - 1] }
        );
        // await LogDetectFile.firstOrCreate(
        //   { file_name: filePath.split("\\")[filePath.split("\\").length - 1] },
        //   { file_name: filePath.split("\\")[filePath.split("\\").length - 1] }
        // );

        fileList_old = fileList;
        updateFileList();
        watchFilesInList();
      }
      // updateFile;
    });

    // Watch for changes in the files listed
    async function watchFilesInList() {
      // console.log("--------->", fileList);
      //get date now
      //check new file
      await fileList
        ?.filter((i) => fileList_old.includes(i) === false)
        ?.forEach((fileName) => {
          //path file
          const filePath = `${folderPath}/${fileName}`;
          const scan = fs.watchFile(
            filePath,
            { interval: 300000 },
            async (eventType) => {
              //check special item, extra RAM, error in log
              let lines = [];
              let fileDetect = await LogDetectFile.findBy(
                "file_name",
                fileName
              );

              let logsDetect = await Database.rawQuery(
                "select * from log_reports where id_file = " +
                  fileDetect?.id_ldf
              );

              let lastLine = Math.max(...logsDetect[0].map((obj) => obj.line));
              let content = await fs
                .readFileSync(filePath)
                .toString()
                ?.split("\n")
                .slice();

              let allValue = await KeyValue.all();
              let listKeyValues = allValue.filter(
                (i) =>
                  i.$original.key === "MODEL_SPECIAL" ||
                  i.$original.key === "CATCH_FAULTY"
              );

              let listExcludeErr = allValue
                .filter((i) => i.$original.key === "EXCLUDE_ERR")
                .map((obj) => obj.$original.value);

              let listExtraItem = allValue
                .filter((i) => i.$original.key === "MODEL_SPECIAL")
                .map((obj) => obj.$original.value);

              content.map((line, index) => {
                listKeyValues
                  .map((obj) => obj.$original.value)
                  .map(async (value) => {
                    if (
                      line.search(value) !== -1 &&
                      listExcludeErr.filter((err) => line.includes(err))
                        .length === 0
                    ) {
                      // let keyWord = "";
                      // line.split(" ").map((word) => {
                      //   if (word.toLocaleLowerCase().includes(value)) {
                      //     keyWord = keyWord + word;
                      //   }
                      // });
                      // if (value.length === keyWord.length) {
                      const log = await LogDetectFile.findBy(
                        "file_name",
                        fileName
                      );

                      let checkLog = await Database.rawQuery(
                        "select * from log_reports where id_file = " +
                          log?.id_ldf +
                          " and line = " +
                          (index + 1) +
                          " and detected_content='" +
                          value +
                          "'"
                      );

                      if (checkLog[0].length === 0) {
                        await LogReport.create({
                          detected_content: value,
                          line: index + 1,
                          id_file: log?.id_ldf,
                        });
                        lines.push(index + 1);
                      }
                    }
                  });
              });
              // }, 5000);
              //true: import log to log_report table, send report to Zulip
              setTimeout(async () => {
                if (lines.length === 0) {
                  console.log(`${fileName} has changed (${eventType})---Good`);
                } else {
                  console.log(
                    `${fileName} has changed (${eventType})---SOS---${lines.length}`
                  );

                  let fileDetect = await LogDetectFile.findBy(
                    "file_name",
                    fileName
                  );

                  let logsDetect = await Database.rawQuery(
                    "select * from log_reports where id_file = " +
                      fileDetect?.id_ldf
                  );

                  await screenShot(fileName);
                  const uriImage = await uploadFileToZulip();
                  let listReport = await getListLineByItem(
                    logsDetect[0].filter((l) => l.line > lastLine)
                  );
                  let content =
                    "|  |Last updated at | Item/error | Line | Report \n|---|:---:|:---|:---|:-----------:\n";
                  let spoiler = "";
                  listReport.map((log, index) => {
                    let item = listExtraItem.includes(log.detected_content)
                      ? ":medal: **" + log.detected_content + "**"
                      : ":small_orange_diamond: " + log.detected_content;
                    content =
                      content +
                      "|" +
                      (index + 1) +
                      "|**" +
                      moment(log.created_at).format("HH:mm - DD/MM") +
                      "**|" +
                      item +
                      "|" +
                      log.line +
                      "|[View](https://logs.danielvu.com/logs/" +
                      fileName +
                      "#" +
                      log.line +
                      ")\n";
                  });
                  // }
                  // setTimeout(() => {
                  sendMessToZulip(
                    "stream",
                    "Result test - auto.nswteam.net",
                    "Log Alert",
                    "------------\n\n:warning: :warning: **" +
                      fileName +
                      "**\n\n" +
                      content +
                      "\n\n" +
                      spoiler 
                      +
                      "\n\n[image](" +
                      uriImage +
                      ")\n"
                  );

                  sendMessToZulip(
                    "stream",
                    "AUS_VN_Test",
                    "Test Log Alerts",
                    "------------\n\n:warning: :warning: **" +
                      fileName +
                      "**\n\n" +
                      content +
                      "\n\n" +
                      spoiler 
                      +
                      "\n\n[image](" +
                      uriImage +
                      ")\n"
                  );
                  // }, 3000);
                }
              }, 3000);
              //false: next
            }
          );
          //setMaxListeners
          scan.setMaxListeners(0);
          // }
        });
    }
  } catch (error) {
    console.log(error);
  }
}