Node.js 应用程序在生产中启动永无止境的流程

Question

I am hosting a node.js application on cPanel. It is nothing but simple RESTful web APIs using express which include CRUD. The issue that I am facing is that the number of processes are getting increased by time, means some of the previous processes are never ending and application keeps on adding until the point where my server reaches resource limit and all the applications stop working.

cPanel actually doesn't have a way to console.log() any errors which I am writing the code to do from inside my application. All I can see is the main domain from where the processes are stemming.

I tried to write my own log file for that but that didn't help too

I am writing this in my terminal to check processes ps -ef | grep node ps -ef | grep node (because I know all the processes are only node.js processes). I noticed that the number of processes I can see in this command are different (way less) than that I can see in side my cPanel dashboard!

UPDATE:

For an example, this is one of the APIs which is creating issue:

My app.js (entry point) :

require("dotenv").config();
const fs = require("fs");
const path = require("path");
const express = require("express");
const bodyParser = require("body-parser");
const morgan = require("morgan");
const cors = require("cors");

const mongoose = require("mongoose");

// Initialize the app
const app = express();

// Enable CORS
app.use(cors({ origin: true }));
 
// create a write stream (in append mode)
var accessLogStream = fs.createWriteStream(path.join(__dirname, 'access.log'), { flags: 'a' })
 
// setup the logger
app.use(morgan('combined', { stream: accessLogStream }))

// Parse the body to JSON
app.use(bodyParser.json());

// Serving static files
app.use("/images", express.static("images"));

// Routes middlewares go here!
app.use("/api/categories", require("./routes/category-routes"));
app.use("/api/users", require("./routes/user-routes"));
app.use("/api/sellers", require("./routes/seller-routes"));
app.use("/api/services", require("./routes/service-routes"));
app.use("/api/resellers", require("./routes/reseller-routes"));
app.use("/api/support", require("./routes/support-routes"));
app.use("/api/trackings", require("./routes/tracking-routes"));

app.use((err, req, res, next) => {
  console.log(err);
  res
    .status(500)
    .send({ success: false, error: err, errors: ["Something went wrong"] });
});

// Start listening finally
const port = process.env.PORT || 5000;

mongoose
  .connect(process.env.MONGO_URI, {
    // .connect(process.env.MONGO_URI_NAI_NAI_NAI, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
    useFindAndModify: false,
  })
  .then(() => {
    app.listen(() => {
      console.log(`Server started on port ${port}`);
    });
  })
  .catch((err) => {
    try {
      fs.appendFileSync("my-own-log-file.txt", `\n\n${err}`);
    } catch (err) {
      console.log(err);
    }
    process.exit(1)
    console.log(err);
  });

Here I am registring the route:

// @route   POST /api/services/filtered-by-state
// @desc    To fetch all services filtered by state
// @access  public

router.post(
  "/filtered-by-state/",
  body("state")
    .trim()
    .not()
    .isEmpty()
    .withMessage("Please enter choose a state"),
  checkValidity,
  serviceControllers.getServicesFilteredByState
);

This is the controller:

exports.getServicesFilteredByState = (req, res) => {
  let page = req.query.page || 1;
  const { state, sellerId } = req.body;
  let options = {};

  if (page) {
    page = parseInt(page);
  }

  if (state === "Australia Wide") {
    options = { state }; // Look for only documents where state is 'Australia wide'
  } else {
    // Look for documents where state is 'Australia wide' or ```state``` itself
    options = { state: { $in: ["Australia Wide", state] } };
  }

  if (!sellerId) {
    options.isHidden = false;
  }

  let totalItems = 0;

  Service.find(options)
    .countDocuments()
    .then((numServices) => {
      totalItems = numServices;
      return Service.find(options)
        .sort("sortingOrder")
        .populate("sellerId")
        .populate("categoryId");
      // .skip((page - 1) * ITEMS_PER_PAGE)
      // .limit(ITEMS_PER_PAGE);
    })
    .then((foundServices) => {
      res.status(200).json({
        success: true,
        totalItems,
        services: foundServices,
      });
    })
    .catch((err) => {
      console.log(err);
      res.status(500).status("Something went wrong");
    });
};

This is simple CRUD!

Answer 1

A Node.js application runs on single thread and the event loop also runs on the same thread. So we can say that Node.js is single-threaded but the catch is that there are some libraries in Node.js that are not single-threaded.

Node.js internally uses the libuv library which is responsible for handling operating system related tasks, like asynchronous I/O based operation systems, networking, concurrency, etc. Libuv sets up a thread pool of x threads to perform OS-related operations by utilizing the power of all the CPU cores. For example, if you have a computer with 4 CPU cores, Libuv will create a thread pool of 4 threads, each thread from the pool is assigned to every core. This results in one thread per core.

However, you can change this value by changing the UV_THREADPOOL_SIZE environment variable:

process.env.UV_THREADPOOL_SIZE = numOfThreads;

In case you are not doing anything wierd with your code, this is totally normal for Node.js and will use as many CPU cores as available to perform better.

I have found a really interesting article that explains everything in detail: Is Node.js Really Single-Threaded?