mirror of
https://github.com/outline/outline.git
synced 2026-11-20 21:23:06 +03:00
130 lines
4.4 KiB
TypeScript
130 lines
4.4 KiB
TypeScript
import { fork } from "node:child_process";
|
|
import cluster from "node:cluster";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { styleText } from "node:util";
|
|
import env from "@server/env";
|
|
import Logger from "@server/logging/Logger";
|
|
|
|
/**
|
|
* Applies a default V8 heap limit to forked service processes when the process
|
|
* is running under a memory constraint (e.g. a container limit) and no limit
|
|
* was configured explicitly. Without this, V8 sizes its heap from the host's
|
|
* total memory, so several forked processes can together commit far more
|
|
* memory than the container allows and are eventually OOM-killed.
|
|
*
|
|
* The limit can be overridden by setting `--max-old-space-size` in
|
|
* `NODE_OPTIONS` or on the command line.
|
|
*
|
|
* @param processCount the number of service processes that will be forked.
|
|
*/
|
|
export function configureChildHeapLimit(processCount: number) {
|
|
if (cluster.isWorker) {
|
|
return;
|
|
}
|
|
|
|
const nodeOptions = process.env.NODE_OPTIONS ?? "";
|
|
const isConfigured =
|
|
nodeOptions.includes("--max-old-space-size") ||
|
|
process.execArgv.some((arg) => arg.startsWith("--max-old-space-size"));
|
|
if (isConfigured) {
|
|
return;
|
|
}
|
|
|
|
// constrainedMemory() reports 0/undefined when unknown, and an effectively
|
|
// unlimited sentinel (2^64) when no cgroup limit is set — only apply a
|
|
// default when a real constraint below the host's total memory exists.
|
|
const constrainedMemory = process.constrainedMemory();
|
|
if (!constrainedMemory || constrainedMemory >= os.totalmem()) {
|
|
return;
|
|
}
|
|
|
|
// Budget ~80% of the constraint for V8 heaps across all forked processes,
|
|
// leaving headroom for the master process and non-heap memory such as
|
|
// compiled code, buffers, and native allocations.
|
|
const totalMB = constrainedMemory / 1024 / 1024;
|
|
const budgetMB = Math.floor((totalMB * 0.8) / Math.max(1, processCount));
|
|
|
|
// Below 256MB per process the server cannot operate reliably, so the floor
|
|
// is applied even though the combined heaps may then exceed the budget.
|
|
const heapMB = Math.max(256, budgetMB);
|
|
if (heapMB > budgetMB) {
|
|
Logger.warn(
|
|
`The available memory of ${Math.round(totalMB)}MB is low for ${processCount} service process(es); reduce process count or increase available memory`
|
|
);
|
|
}
|
|
|
|
// Forked processes parse NODE_OPTIONS on startup, so this applies to every
|
|
// service process without affecting the already-running master.
|
|
process.env.NODE_OPTIONS =
|
|
`${nodeOptions} --max-old-space-size=${heapMB}`.trim();
|
|
|
|
Logger.info(
|
|
"lifecycle",
|
|
`Memory constraint of ${Math.round(totalMB)}MB detected, defaulting each service process to a ${heapMB}MB heap limit`
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Runs the database connection and pending migration checks in a short-lived
|
|
* child process, resolving once it exits successfully. Running these checks out
|
|
* of process keeps the long-lived master free of the Sequelize models graph.
|
|
*
|
|
* @returns a promise that resolves when the checks have completed successfully.
|
|
*/
|
|
export function checkPendingMigrations(): Promise<void> {
|
|
// Migrations are run as a separate release step in the hosted service.
|
|
if (env.isCloudHosted) {
|
|
return Promise.resolve();
|
|
}
|
|
|
|
return new Promise((resolve) => {
|
|
const child = fork(
|
|
path.join(__dirname, "..", "scripts", "checkMigrations.js"),
|
|
process.argv.slice(2),
|
|
// Run without the parent's CLI flags so an inherited --inspect port does
|
|
// not clash; the heap limit is inherited via NODE_OPTIONS in the env.
|
|
{ execArgv: [], stdio: ["inherit", "inherit", "inherit", "ipc"] }
|
|
);
|
|
|
|
child.once("error", (err) => {
|
|
Logger.fatal("Failed to run database migration checks", err);
|
|
});
|
|
|
|
child.once("exit", (code) => {
|
|
if (code === 0) {
|
|
resolve();
|
|
return;
|
|
}
|
|
process.exit(code ?? 1);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Prints information about the current environment to the log on startup.
|
|
*/
|
|
export async function printEnv() {
|
|
if (env.isProduction) {
|
|
Logger.info(
|
|
"lifecycle",
|
|
styleText(
|
|
"green",
|
|
`
|
|
Is your team enjoying Outline? Consider supporting future development by sponsoring the project:\n\nhttps://github.com/sponsors/outline
|
|
`
|
|
)
|
|
);
|
|
} else if (env.isDevelopment) {
|
|
Logger.warn(
|
|
`Running Outline in ${styleText(
|
|
"bold",
|
|
"development mode"
|
|
)}. To run Outline in production mode set the ${styleText(
|
|
"bold",
|
|
"NODE_ENV"
|
|
)} env variable to "production"`
|
|
);
|
|
}
|
|
}
|