PM2

https://pm2.keymetrics.io/docs
Admin
PM2 is a production process manager for Node.js applications that enables easy deployment,...
Tokens:90,526
Snippets:918
Trust Score:7.5
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### PM2 API Quickstart: Install and Manage Processes Programmatically

Source: https://pm2.keymetrics.io/docs/usage/pm2-api

Install PM2 as a dependency and then create a script that connects to PM2, starts an app named 'api', lists all managed applications, restarts the app, and disconnects. The example uses the pm2 module's connect, start, list, restart, and disconnect methods. Note that you must call pm2.disconnect() to release the connection and allow the application to exit.

```bash
npm install pm2 --save

```

```javascript
const pm2 = require('pm2')

pm2.connect(function(err) {
  if (err) {
    console.error(err)
    process.exit(2)
  }

  pm2.start({
    script    : 'api.js',
    name      : 'api'
  }, function(err, apps) {
    if (err) {
      console.error(err)
      return pm2.disconnect()
    }

    pm2.list((err, list) => {
      console.log(err, list)

      pm2.restart('api', (err, proc) => {
        // Disconnects from PM2
        pm2.disconnect()
      })
    })
  })
})

```

--------------------------------

### Configuration file ecosystem.config.js and start command

Source: https://pm2.keymetrics.io/docs/usage/process-management

Configuration file example for managing multiple applications, and the command to start both apps.

```javascript
module.exports = {
  apps : [{
    name   : "limit worker",
    script : "./worker.js",
    args   : "limit"
  },{
    name   : "rotate worker",
    script : "./worker.js",
    args   : "rotate"
  }]
}

```

```bash
$ pm2 start ecosystem.config.js

```

--------------------------------

### Install and start a generated module

Source: https://pm2.keymetrics.io/docs/plus/guide/modules

Install and start the generated module. If you edit the source, PM2 automatically restarts the module (watch option is activated).

```bash
cd <your-module-name>
pm2 install .

```

--------------------------------

### Quick Start: Install tx2 and expose a meter metric with PM2

Source: https://pm2.keymetrics.io/docs/usage/process-metrics

Install the tx2 module, create a monit.js app that exposes a meter metric, start it with PM2, and view the metrics using pm2 show or the terminal-based pm2 monit interface. Metrics appear in the 'Code metrics value' section.

```bash
$ npm install tx2

```

```javascript
const tx2 = require('tx2')
const http = require('http')

let meter = tx2.meter({
  name      : 'req/sec',
  samples   : 1,
  timeframe : 60
})

http.createServer((req, res) => {
  meter.mark()
  res.writeHead(200, {'Content-Type': 'text/plain'})
  res.write('Hello World!')
  res.end()
}).listen(6001)

```

```bash
$ pm2 start monit.js

```

```bash
$ pm2 show [app]
# pm2 show monit

```

```bash
$ pm2 monit

```

--------------------------------

### Start process file

Source: https://pm2.keymetrics.io/docs/usage/cluster-mode

Start the application using the process file configuration.

```bash
pm2 start processes.json

```

--------------------------------

### Run CoffeeScript v2 app

Source: https://pm2.keymetrics.io/docs/usage/specifics

Install and start a CoffeeScript v2 app.

```bash
pm2 install coffeescript
pm2 start app.coffee

```

--------------------------------

### Open the setup wizard

Source: https://pm2.keymetrics.io/docs/enterprise/on-premise/baremetal

Open the setup wizard in a browser to set your License Key and configuration.

```bash
$ google-chrome http://server-ip/wizard

```

--------------------------------

### Run CoffeeScript v1 app

Source: https://pm2.keymetrics.io/docs/usage/specifics

Install and start a CoffeeScript v1 app.

```bash
pm2 install coffee-script 
pm2 start app.coffee

```

--------------------------------

### Start ecosystem file with pm2 start ecosystem.config.js

Source: https://pm2.keymetrics.io/docs/usage/quick-start

Starts the applications defined in the ecosystem.config.js file.

```bash
$ pm2 start ecosystem.config.js

```

--------------------------------

### Start an app with pm2 start

Source: https://pm2.keymetrics.io/docs/usage/quick-start

Start, daemonize, and monitor a Node.js application with PM2.

```bash
$ pm2 start app.js

```

--------------------------------

### Start any kind of application with pm2 start

Source: https://pm2.keymetrics.io/docs/usage/process-management

Starts any kind of application, including bash commands, scripts, and binaries.

```bash
$ pm2 start "npm run start"
$ pm2 start "ls -la"
$ pm2 start app.py

```

--------------------------------

### Install Docker and Docker Compose

Source: https://pm2.keymetrics.io/docs/enterprise/on-premise/baremetal

Install Docker and Docker Compose (minimum version 1.19.0) on the host machine. The commands download and install Docker, then download Docker Compose and make it executable.

```bash
$ sudo wget -qO- https://get.docker.com/ | sh
$ sudo curl -L https://github.com/docker/compose/releases/download/1.19.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
$ sudo chmod +x /usr/local/bin/docker-compose

```

--------------------------------

### Start an application with pm2 start

Source: https://pm2.keymetrics.io/docs/usage/process-management

Starts the application api.js in the background.

```bash
$ pm2 start api.js

```

--------------------------------

### Install the keymetrics-aio Helm chart

Source: https://pm2.keymetrics.io/docs/enterprise/helm

Installs the PM2 Plus chart with required settings. The installation also includes Redis, ElasticSearch, and MongoDB. After installation, follow the NOTES to set DNS and connect to the web interface.

```bash
helm install keymetrics-aio --set km_license=<YOUR_LICENSE> \
                            --set km_public_dns=<YOUR_SUBDOMAIN> \
                            --set km_smtp_host=<SMTP_ADDRESS> \
                            --set km_smtp_user=<SMTP_USERNAME> \
                            --set km_smtp_pass=<SMTP_PASSWORD> \
                            --set km_smtp_sender=<SMTP_SENDER_ADDRESS>
```

--------------------------------

### Run CoffeeScript with PM2 --interpreter

Source: https://pm2.keymetrics.io/docs/tutorials/using-transpilers-with-pm2

Installs CoffeeScript globally and starts index.coffee with PM2 using the coffee interpreter. Add --watch to restart on file changes. Only works in fork_mode.

```bash
#- npm install -g coffee-script
#- pm2 start --interpreter coffee index.coffee
```

--------------------------------

### Start Bun applications with PM2

Source: https://pm2.keymetrics.io/docs/usage/bun-deno

PM2 native support for Bun. Use `pm2 start app.ts` to run TypeScript files with Bun automatically when installedva3; set the interpreter explicitly with `pm2 start index.js --interpreter bun`; or declare the interpreter in a configuration file. The config example passes flags to the Bun binary via `node_args`.

```bash
# .ts and .tsx files default to the bun interpreter
pm2 start app.ts

```

```bash
pm2 start index.js --interpreter bun

```

```javascript
module.exports = {
  apps: [{
    name: "api",
    script: "./app.ts",
    interpreter: "bun",
    node_args: "--smol"   // flags passed to the bun binary
  }]
}

```

--------------------------------

### Start and display log stream with --attach

Source: https://pm2.keymetrics.io/docs/usage/process-management

Starts the app and displays the log stream. When quitting via Ctrl-C, the app will still run in background.

```bash
$ pm2 start api.js --attach

```

--------------------------------

### Set listen timeout via process file

Source: https://pm2.keymetrics.io/docs/usage/signals-clean-restart

In an ecosystem file, use wait_ready and listen_timeout attributes to configure graceful start. This example sets wait_ready to true and listen_timeout to 10000ms.

```javascript
module.exports = {
  apps : [{
    name: 'app',
    script: './app.js',
    wait_ready: true,
    listen_timeout: 10000
  }]
}

```

--------------------------------

### Example ecosystem.config.js for PM2

Source: https://pm2.keymetrics.io/docs/usage/use-pm2-with-cloud-providers

Example ecosystem.config.js file. Modify it to match your application's name, script path, and environment variables. The env_production block is used when starting with --env production.

```javascript
module.exports = {
  apps : [{
    name: "app",
    script: "./app.js",
    env: {
      NODE_ENV: "development",
    },
    env_production: {
      NODE_ENV: "production",
    }
  }]
}

```

--------------------------------

### Start the stack with docker-compose up

Source: https://pm2.keymetrics.io/docs/enterprise/on-premise/baremetal

Start the on-premise stack in detached mode after configuring the docker-compose.yml file.

```bash
$ docker-compose up -d

```

--------------------------------

### PM2 ecosystem file with env_production

Source: https://pm2.keymetrics.io/docs/usage/application-declaration

Example of a PM2 ecosystem file with multiple apps and environment-specific variables. Use `pm2 start ecosystem.json --env production` to use the `env_production` block.

```json
{
  "apps" : [{
    "name"        : "worker-app",
    "script"      : "./worker.js",
    "watch"       : true,
    "env": {
      "NODE_ENV": "development"
    },
    "env_production" : {
       "NODE_ENV": "production"
    }
  },{
    "name"       : "api-app",
    "script"     : "./api.js",
    "instances"  : 4,
    "exec_mode"  : "cluster"
  }]
}

```

--------------------------------

### Run Babel with PM2 --interpreter

Source: https://pm2.keymetrics.io/docs/tutorials/using-transpilers-with-pm2

Installs Babel CLI globally and starts index.es6 with PM2 using babel-node as the interpreter. Only works in fork_mode; use the require hook alternative for cluster mode.

```bash
#- npm install -g babel-cli
#- pm2 start --interpreter babel-node index.es6
```

--------------------------------

### Install @pm2/io with yarn

Source: https://pm2.keymetrics.io/docs/plus/guide/configuration

Install the @pm2/io module using yarn. This is an alternative to npm installation.

```bash
yarn add @pm2/io

```

--------------------------------

### Start app in cluster mode with pm2 start -i max

Source: https://pm2.keymetrics.io/docs/faq

Starts the application in cluster mode, spawning one instance per CPU core. Only works for Node.js applications; other languages run in fork mode.

```bash
pm2 start app.js -i max

```

--------------------------------

### Start PM2 Plus with pm2 plus

Source: https://pm2.keymetrics.io/docs/plus/overview

Use the pm2 CLI (version above 3.2.7) to start PM2 Plus. This command initiates the PM2 Plus service.

```bash
pm2 plus

```

--------------------------------

### Start rpc.js with PM2

Source: https://pm2.keymetrics.io/docs/usage/process-actions

Starts the rpc.js application with PM2 so its RPC methods become available.

```bash
$ pm2 start rpc.js

```

--------------------------------

### Install a PM2 module

Source: https://pm2.keymetrics.io/docs/plus/guide/modules

Install a PM2 module by name, from a GitHub repository, or from a local folder in dev mode.

```bash
pm2 install <module-name>

# Install a module from GitHub (username/repository)
pm2 install pm2-hive/pm2-docker

# Install a module in dev mode from local folder
pm2 install .

```

--------------------------------

### Install tx2 module

Source: https://pm2.keymetrics.io/docs/usage/process-actions

Installs the tx2 module, which is required to expose RPC methods from your application.

```bash
$ npm install tx2

```

--------------------------------

### Start processes with a namespace

Source: https://pm2.keymetrics.io/docs/faq

Start processes with a namespace from the CLI. The namespace attribute can also be used in the configuration file.

```bash
pm2 start api.js    --namespace backend
pm2 start worker.js --namespace backend

```

--------------------------------

### Winston Logger Setup

Source: https://pm2.keymetrics.io/docs/plus/guide/custom-actions

Initializes a Winston logger with the log level set to 'info' and logs a debug message. This is the baseline setup before adding custom actions.

```javascript
const { createLogger, format, transports } = require('winston')

const logger = createLogger({
  level: 'info',
  format: format.simple(),
  transports: [new transports.Console()]
})

logger.info('Hello world')
logger.debug('Debugging info')

```

--------------------------------

### Install @pm2/io with npm

Source: https://pm2.keymetrics.io/docs/plus/guide/configuration

Install the @pm2/io module using npm. This is required to refine configuration, add custom metrics, or add custom actions.

```bash
npm install @pm2/io --save

```

--------------------------------

### Metric example with id

Source: https://pm2.keymetrics.io/docs/plus/guide/custom-metrics

In active mode, save the return of the metric method to get an object with set(). This example includes an id for the metric.

```javascript
const realtimeUsers = io.metric({
  name: 'Realtime Users'
  id: 'app/realtime/users',
})

realtimeUsers.set(23)

```

--------------------------------

### Generate a sample configuration file with pm2 init simple

Source: https://pm2.keymetrics.io/docs/usage/application-declaration

Run this command to generate a sample ecosystem.config.js file. The generated file is shown in the next snippet.

```bash
$ pm2 init simple

```

--------------------------------

### Specify the init system with pm2 startup

Source: https://pm2.keymetrics.io/docs/usage/startup

Specify the platform yourself by using one of the listed init systems, e.g., `ubuntu`, `centos`, `systemd`, etc.

```bash
pm2 startup [ubuntu | ubuntu14 | ubuntu12 | centos | centos6 | arch | oracle | amazon | macos | darwin | freebsd | systemd | systemv | upstart | launchd | rcd | rcd-openbsd | openrc | smf | sunos | solaris]

```

--------------------------------

### Start PM2 from project_root using ecosystem.json

Source: https://pm2.keymetrics.io/docs/tutorials/capistrano-like-deployments

Shows the deployment command that starts or restarts PM2 using the ecosystem.json located in the current release. Run this from the project_root directory so that relative paths in the ecosystem file resolve correctly.

```bash
# somewhere in your deployment script
cd /home/www/project_root
pm2 startOrRestart current/ecosystem.json

```

--------------------------------

### Pass arguments to app with pm2 start --

Source: https://pm2.keymetrics.io/docs/usage/process-management

Passes arguments after -- to the app.

```bash
$ pm2 start api.js -- arg1 arg2

```

--------------------------------

### Install PM2 with npm

Source: https://pm2.keymetrics.io/docs/integrations/heroku

Adds PM2 as a dependency to your project using npm. This is required before setting the start script.

```bash
npm install pm2

```

--------------------------------

### Send ready signal for graceful start

Source: https://pm2.keymetrics.io/docs/usage/signals-clean-restart

When using --wait-ready, your application must send process.send('ready') to let PM2 know it is ready. This example shows an HTTP server that sends the ready signal after it starts listening.

```javascript
var http = require('http')

var app = http.createServer(function(req, res) {
  res.writeHead(200)
  res.end('hey')
})

var listener = app.listen(0, function() {
  console.log('Listening on port ' + listener.address().port)
  // Here we send the ready signal to PM2
  process.send('ready')
})

```

--------------------------------

### Get the Tracer singleton

Source: https://pm2.keymetrics.io/docs/enterprise/guides/distributed-tracing

Retrieves the global singleton Tracer instance from the PM2/io agent. This is the first step to start a trace.

```javascript
const tracer = io.getTracer()

```

--------------------------------

### Counter example with inc() and dec()

Source: https://pm2.keymetrics.io/docs/plus/guide/custom-metrics

Use io.counter() to create a discrete counter that starts at 0. Increment with inc() and decrement with dec().

```javascript
const io = require('@pm2/io');

const currentReqs = io.counter({
  name: 'Realtime request count',
  id: 'app/realtime/requests'
});

http.createServer((req, res) => {
  // Increment the counter, counter will eq 1
  currentReqs.inc();
  req.on('end', () => {
    // Decrement the counter, counter will eq 0
    currentReqs.dec();
  });
});

```

--------------------------------

### List RPC methods with pm2 show

Source: https://pm2.keymetrics.io/docs/usage/process-actions

Lists all available RPC methods for a PM2 application. The commented example shows the 'rpc' application.

```bash
pm2 show <application-name>
# pm2 show rpc

```

--------------------------------

### PM2 start with quoted node-args

Source: https://pm2.keymetrics.io/docs/usage/application-declaration

Example of using quotes to pass an ESC (escaped) argument to PM2. The node-args value is parsed as a single argument with spaces preserved.

```bash
$pm2 start test.js --node-args "port=3001 sitename='first pm2 app'"

```

--------------------------------

### pm2.start(process, fn)

Source: https://pm2.keymetrics.io/docs/usage/pm2-api

Starts a new process with the given script path or an options object. The options object allows detailed configuration of the process behavior.

```APIDOC
## pm2.start(process, fn)

### Description
Start a process with the given script path or options object.

### Method
start

### Parameters
- **process** (string/object) - Required - Script path (relative) or an options object.
- **fn** (function) - Required - Callback function.

### Options (when process is an object)
- **name** (string) - Optional - An arbitrary name to interact with the process later. Defaults to the script name without extension.
- **script** (string) - Required - The path of the script to run.
- **args** (string/array) - Optional - Arguments to pass to the script.
- **interpreterArgs** (string/array) - Optional - Arguments to call the interpreter process with.
- **cwd** (string) - Optional - Working directory to start the process with.
- **output** (string) - Optional - Path to file for stdout output. Default: `~/.pm2/logs/app_name-out.log`.
- **error** (string) - Optional - Path to file for stderr output. Default: `~/.pm2/logs/app_name-error.err`.
- **logDateFormat** (string) - Optional - Display format for log timestamps.
- **pid** (string) - Optional - Path to file to write the pid. Default: `~/.pm2/pids/app_name-id.pid`.
- **minUptime** (number) - Optional - Minimum uptime before considered successfully started.
- **maxRestarts** (number) - Optional - Maximum number of consecutive restarts if exits in less than minUptime.
- **maxMemoryRestart** (string) - Optional - Restart if memory usage exceeds this value (e.g., "150M").
- **killTimeout** (number) - Optional - Milliseconds to wait before SIGKILL after SIGINT. Default: 1600.
- **restartDelay** (number) - Optional - Milliseconds to wait before restarting. Default: 0.
- **interpreter** (string) - Optional - Interpreter for the script. Default: 'node'.
- **execMode** (string) - Optional - 'fork' or 'cluster'. Default: 'fork'.
- **instances** (number) - Optional - Number of instances in cluster mode. Default: 1.
- **mergeLogs** (boolean) - Optional - Merge log files in cluster mode. Default: false.
- **watch** (boolean) - Optional - Restart on file change. Default: false.
- **force** (boolean) - Optional - Start a new instance even if script is already running. Default: false.
- **autorestart** (boolean) - Optional - Restart on exit. Default: true.
- **cron** - Optional - Cron schedule.
- **executeCommand** - Optional - Execute command.
- **write** - Optional - Write option.
- **sourceMapSupport** - Optional - Enable source map support.
- **disableSourceMapSupport** - Optional - Disable source map support.

### Callback
- **err** (Error) - Error object if start failed.
- **proc** (pm2 process object) - The pm2 process object.

### Example
```javascript
const pm2 = require('pm2');
pm2.start({
  script: 'app.js',
  name: 'my-app',
  instances: 2,
  exec_mode: 'cluster'
}, (err, proc) => {
  if (err) {
    console.error(err);
  }
});
```
```

--------------------------------

### Provision remote server with pm2 deploy setup

Source: https://pm2.keymetrics.io/docs/usage/deployment

Provisions remote servers for deployment. Requires that remote servers have PM2 installed and have granted permissions to GIT clone the target repository.

```bash
$ pm2 deploy production setup

```

--------------------------------

### Initialize a PM2 module with @pm2/io

Source: https://pm2.keymetrics.io/docs/plus/guide/modules

Main module entry point that calls `io.initModule()` to initialize the module. The callback receives the configuration and can start the business logic.

```javascript
const io = require('@pm2/io')

const conf = io.initModule({
  // Override PID to be monitored
  pid: io.resolvePidPaths(['/var/run/redis.pid']),
}, (err, conf) => {
  // Now the module is initialized
  require('./business_logic.js')(conf)
})

```

--------------------------------

### Switch environments with --env option

Source: https://pm2.keymetrics.io/docs/usage/application-declaration

Use the --env option to switch between environment variable sets defined in the configuration file. The example shows starting with production and restarting with development.

```bash
pm2 start ecosystem.config.js --env production
pm2 restart ecosystem.config.js --env development

```

--------------------------------

### Copy/paste the displayed command to set up startup script

Source: https://pm2.keymetrics.io/docs/usage/startup

Copy and paste the command displayed by `pm2 startup` to configure the startup script. This command uses sudo and sets the PATH and home directory.

```bash
sudo su -c "env PATH=$PATH:/home/unitech/.nvm/versions/node/v14.3/bin pm2 startup <distribution> -u <user> --hp <home-path>

```

--------------------------------

### Embed PM2 agent in Golang application

Source: https://pm2.keymetrics.io/docs/enterprise/collector/go

Import the pm2-io-apm-go library, create a PM2 connector with your public and private keys and an application name, then start the connection to PM2 Enterprise. This is the minimal setup to monitor a Golang application.

```go
package main

import (
  "github.com/keymetrics/pm2-io-apm-go/services"
  "github.com/keymetrics/pm2-io-apm-go/structures"
)

func main() {
  // Create PM2 connector
  pm2 := pm2io.Pm2Io{
    Config: &structures.Config{
      PublicKey: "myPublic",    // define the public key given in the dashboard
      PrivateKey: "myPrivate",  // define the private key given in the dashboard
      Name: "Golang app",       // define an application name
    },
  }

  // Start the connection to PM2 Enterprise backend
  pm2.Start()
}

```

--------------------------------

### Generate a startup script with pm2 startup

Source: https://pm2.keymetrics.io/docs/usage/startup

Run `pm2 startup` without sudo to detect the init system and display a command to copy/paste for setting up the startup script.

```bash
$ pm2 startup
[PM2] Init System found: systemd
[PM2] To setup the Startup Script, copy/paste the following command:
sudo env PATH=$PATH:/home/unitech/.nvm/versions/node/v22.0.0/bin pm2 startup systemd -u <user> --hp <home-path>

```

--------------------------------

### Configure Keymetrics module variables

Source: https://pm2.keymetrics.io/docs/enterprise/gcp

Example module definition with all required variables set. The variables control the infrastructure setup and external services. Required variables include keymetrics_key, environment, smtp_username, smtp_password, smtp_host, smtp_sender, and network_name.

```hcl
module "example_keymetrics_setup" {
  source  = "keymetrics_aio_gcp"

  keymetrics_key = "..."

  environment = "example"

  smtp_host = "smtp.mailgun.org"
  smtp_username = "postmaster@example.com"
  smtp_password = "XXX"
  smtp_sender = "keymetrics@example.com"
  
  public_host_address = "our-keymetrics-public-subdomain.example.com"
  
  network_name = "default"
}

```

--------------------------------

### Run PM2 tests

Source: https://pm2.keymetrics.io/docs/usage/contributing

Clone the PM2 repository, install dependencies, and run the test suite. If some packages are missing, use NODE_ENV=development npm install. Report any failing tests as issues.

```bash
git clone https://github.com/Unitech/pm2.git
cd pm2
npm install  # Or do NODE_ENV=development npm install if some packages are missing
npm test

```

--------------------------------

### Sample ecosystem.config.js generated by pm2 init simple

Source: https://pm2.keymetrics.io/docs/usage/application-declaration

This is the sample configuration file generated by the pm2 init simple command. It defines a single app named app1 that runs ./app.js.

```javascript
module.exports = {
  apps : [{
    name   : "app1",
    script : "./app.js"
  }]
}

```

--------------------------------

### Procfile to start app with npm start

Source: https://pm2.keymetrics.io/docs/tutorials/use-pm2-with-aws-elastic-beanstalk

Create a Procfile at the root of your source bundle to specify the command that starts your application. This ensures Beanstalk launches your app using npm start.

```plaintext
web: npm start

```

--------------------------------

### Check systemd installation and logs

Source: https://pm2.keymetrics.io/docs/usage/startup

Commands to check if the pm2-<USER> service has been added, check logs, cat the systemd configuration file, and analyze startup.

```bash
# Check if pm2-<USER> service has been added
$ systemctl list-units
# Check logs
$ journalctl -u pm2-<USER>
# Cat systemd configuration file
$ systemctl cat pm2-<USER>
# Analyze startup
$ systemd-analyze plot > output.svg

```

--------------------------------

### Start, stop, restart, reload, and delete all apps in a configuration file

Source: https://pm2.keymetrics.io/docs/usage/application-declaration

These commands act on all applications defined in ecosystem.config.js. Use them to manage the entire set of apps at once.

```bash
# Start all applications
pm2 start ecosystem.config.js

# Stop all
pm2 stop ecosystem.config.js

# Restart all
pm2 restart ecosystem.config.js

# Reload all
pm2 reload ecosystem.config.js

# Delete all
pm2 delete ecosystem.config.js

```

--------------------------------

### PM2 CLI options for pm2 start

Source: https://pm2.keymetrics.io/docs/usage/quick-start

CLI options for pm2 start, including app name, watch mode, memory threshold, log file, extra arguments, restart delay, time prefix, no-autorestart, cron pattern, attach, and no-daemon.

```bash
# Specify an app name
--name <app_name>

# Watch and Restart app when files change
--watch

# Set memory threshold for app reload
--max-memory-restart <200MB>

# Specify log file
--log <log_path>

# Pass extra arguments to the script
-- arg1 arg2 arg3

# Delay between automatic restarts
--restart-delay <delay in ms>

# Prefix logs with time
--time

# Do not auto restart app
--no-autorestart

# Specify cron for forced restart
--cron <cron_pattern>

# Attach to application log after start
--attach

# Run the PM2 daemon in the foreground
--no-daemon

```

--------------------------------

### Install PM2 with NPM or Yarn

Source: https://pm2.keymetrics.io/docs/usage/quick-start

Install the latest PM2 version globally using NPM or Yarn. Requires Node.js and NPM, which can be installed via NVM.

```bash
$ npm install pm2@latest -g
# or
$ yarn global add pm2

```

--------------------------------

### Install profiler addon for older Node versions

Source: https://pm2.keymetrics.io/docs/enterprise/guides/profiling

Install the profiler addon using pm2 install profiler for Node.js 4, 6, and 7. This is required because the profilers are not native in these versions.

```bash
pm2 install profiler

```

--------------------------------

### Install PM2 test dependencies on Ubuntu

Source: https://pm2.keymetrics.io/docs/usage/contributing

Install required dependencies for running PM2 tests on Ubuntu. Installs build-essential, sets up nvm (Node.js version manager), and installs/uses Node.js version 4.

```bash
sudo apt-get install build-essential
# nvm is a Node.js version manager - https://github.com/creationix/nvm
wget -qO- https://raw.github.com/creationix/nvm/master/install.sh | sh
nvm install 4
nvm use 4

```

--------------------------------

### Set up PM2 to restart apps on reboot with pm2 startup and pm2 save

Source: https://pm2.keymetrics.io/docs/faq

Generates an init script for the platform, then freezes the process list so PM2 and apps are resurrected at boot. Run the command printed by pm2 startup before pm2 save.

```bash
pm2 startup
# run the command printed by pm2
pm2 save

```
Tokens:
Raw