@vladonv/pm2-postgres 0.1.1

package/README.md

@@ -0,0 +1,55 @@
+# pm2-postgres
+PostgreSQL module for Keymetrics
+
+![pm2-postgres screenshot](https://raw.githubusercontent.com/pm2-hive/pm2-postgres/master/pm2-postgres.jpg)
+
+## Description
+
+PM2 module to monitor key PostgreSQL server metrics:
+
+* Tables / Indexes Count
+* Backends Active / Idle
+* Exclusive / Access Share Locks
+* Total Tables Size
+* Transactions Committed / Rollback
+* Tuples Fetched / Updated / Inserted / Deleted
+
+## Requirements
+
+This module requires a PostgreSQL install (v9.3+, including SCRAM-SHA-256 auth on PostgreSQL 10-17).
+
+## Install
+
+```bash
+$ npm install pm2 -g
+
+$ pm2 install pm2-postgres
+```
+
+## Config
+
+The default connection details are :    
+"hostname": "localhost"  
+"port": 5432  
+"username": "guest"  
+"password": "guest"  
+"database": "postgres"  
+
+To modify the config values you can use the commands:
+```bash
+$ pm2 set pm2-postgres:hostname localhost
+$ pm2 set pm2-postgres:port 5432
+$ pm2 set pm2-postgres:username guest
+$ pm2 set pm2-postgres:password guest
+$ pm2 set pm2-postgres:database postgres
+```
+
+## Uninstall
+
+```bash
+$ pm2 uninstall pm2-postgres
+```
+
+# License
+
+MIT

package/app.js

@@ -0,0 +1,67 @@
+var fs = require('fs');
+var path = require('path');
+var pmx = require('pmx');
+var pgClientFactory = require('./lib/clientFactory.js');
+var pgStats = require('./lib/stats.js');
+var pgActions = require('./lib/actions.js');
+
+// Debian/Ubuntu's postgresql-common names pidfiles "<version>-main.pid"
+// (e.g. "17-main.pid", "9.6-main.pid"). Scanning the directory instead of
+// hardcoding a version list keeps this working for future major versions.
+function detectPostgresPidPaths() {
+  var pgRunDir = '/var/run/postgresql';
+
+  try {
+    return fs.readdirSync(pgRunDir)
+      .filter(function (name) { return /^\d+(\.\d+)?-main\.pid$/.test(name); })
+      .sort(function (a, b) { return parseFloat(b) - parseFloat(a); })
+      .map(function (name) { return path.join(pgRunDir, name); });
+  } catch (e) {
+    return [];
+  }
+}
+
+pmx.initModule({
+
+  pid: pmx.resolvePidPaths(detectPostgresPidPaths()),
+
+  // Options related to the display style on Keymetrics
+  widget: {
+
+    // Logo displayed
+    logo: 'http://www.inquidia.com/sites/default/files/postgresql_logo%5B1%5D.png',
+
+    // Module colors
+    // 0 = main element
+    // 1 = secondary
+    // 2 = main border
+    // 3 = secondary border
+    theme: ['#60798c', '#326892', '#ffffff', '#807C7C'],
+
+    // Section to show / hide
+    el: {
+      probes: true,
+      actions: true
+    },
+
+    // Main block to show / hide
+    block: {
+      actions: true,
+      issues: true,
+      meta: true,
+
+      // Custom metrics to put in BIG
+      main_probes: ['Tables', 'Indexes','Total Tables Size','Backends Active','Exclusive Locks']
+    }
+
+  }
+
+}, function (err, conf) {
+  var pgClient = pgClientFactory.build(conf);
+
+  // Init metrics refresh loop
+  pgStats.init(pgClient);
+
+  // Init actions
+  pgActions.init(pgClient);
+});

package/lib/actions.js

@@ -0,0 +1,36 @@
+var pmx = require('pmx');
+
+function initActions(pgClient) {
+
+  // List DBs
+  pmx.action('List DBs', function (reply) {
+    var queryString = "SELECT datname FROM pg_database WHERE datistemplate = false;"
+    pgClient.query(queryString, function (err, results) {
+      if (err) {
+        return reply(err);
+      }
+
+      reply(results.rows.map(function (row) { return row.datname; }));
+    })
+  });
+
+  // Show Settings
+  pmx.action('Show Settings', function (reply) {
+    var queryString = "SHOW ALL;";
+    pgClient.query(queryString, function (err, results) {
+      if (err) {
+        return reply(err);
+      }
+
+      reply(results.rows);
+    })
+  });
+
+
+}
+
+function init(pgClient) {
+  initActions(pgClient);
+}
+
+module.exports.init = init;

package/lib/clientFactory.js

@@ -0,0 +1,30 @@
+var pg = require('pg');
+var pmx = require('pmx');
+
+function build(conf) {
+  var pgClient = {};
+
+  var connectionString = "postgres://" + conf.username + ":" + conf.password + "@" + conf.hostname + ":" + conf.port + "/" + conf.database;
+
+  var pool = new pg.Pool({ connectionString: connectionString });
+
+  pool.on('error', function (err) {
+    // Errors on idle clients (e.g. connection dropped) must not crash the process.
+    pmx.notify("Postgres pool error: " + err);
+  });
+
+  pgClient.query = function (queryString, cb) {
+    pool.query(queryString, function (err, result) {
+      if (err) {
+        pmx.notify("Couldn't query postgres: " + err);
+        return cb(err);
+      }
+
+      return cb(null, result);
+    });
+  };
+
+  return pgClient;
+}
+
+module.exports.build = build;

package/lib/stats/refreshBackendMetrics.js

@@ -0,0 +1,19 @@
+var pmx = require('pmx');
+
+module.exports = function refreshBackendMetrics(metrics, pgClient) {
+  var queryString = "SELECT count(*) - ( SELECT count(*) FROM pg_stat_activity WHERE"
+    + " state = 'idle' ) AS backends_active, ( SELECT count(*) FROM"
+    + " pg_stat_activity WHERE state = 'idle' ) AS backends_idle"
+    + " FROM pg_stat_activity;";
+  pgClient.query(queryString, function (err, results) {
+    if (err) {
+      return pmx.notify("Backend Query Error: " + err);
+    }
+
+    // Backends Active
+    metrics.backendsActive.set(results.rows[0].backends_active);
+
+    // Backends Idle
+    metrics.backendsIdle.set(results.rows[0].backends_idle);
+  });
+};

package/lib/stats/refreshIndexCount.js

@@ -0,0 +1,13 @@
+var pmx = require('pmx');
+
+module.exports = function refreshIndexCount(metrics, pgClient) {
+  var queryString = "SELECT count(1) as indexes FROM pg_class WHERE relkind = 'i';";
+  pgClient.query(queryString, function (err, results) {
+    if (err) {
+      return pmx.notify("Index Query Error: " + err);
+    }
+
+    // # of Indexes
+    metrics.indexCount.set(results.rows[0].indexes);
+  });
+};

package/lib/stats/refreshLockCount.js

@@ -0,0 +1,21 @@
+var pmx = require('pmx');
+
+function findLockCount(rows, mode) {
+  var row = rows.find(function (row) { return row.mode === mode; });
+  return row ? row.count : 'N/A';
+}
+
+module.exports = function refreshLockCount(metrics, pgClient) {
+  var queryString = "SELECT mode, count(mode) AS count FROM pg_locks GROUP BY mode ORDER BY mode;";
+  pgClient.query(queryString, function (err, results) {
+    if (err) {
+      return pmx.notify("Lock Query Error: " + err);
+    }
+
+    // # of Access Share Locks
+    metrics.accessShareLockCount.set(findLockCount(results.rows, 'AccessShareLock'));
+
+    // # of Exclusive Locks
+    metrics.exclusiveLockCount.set(findLockCount(results.rows, 'ExclusiveLock'));
+  });
+};

package/lib/stats/refreshTableCount.js

@@ -0,0 +1,13 @@
+var pmx = require('pmx');
+
+module.exports = function refreshTableCount(metrics, pgClient) {
+  var queryString = "SELECT count(1) as relations FROM pg_class WHERE relkind IN ('r', 't');";
+  pgClient.query(queryString, function (err, results) {
+    if (err) {
+      return pmx.notify("Table Query Error: " + err);
+    }
+
+    // # of Tables
+    metrics.tableCount.set(results.rows[0].relations);
+  });
+};

package/lib/stats/refreshTablesSize.js

@@ -0,0 +1,14 @@
+var pmx = require('pmx');
+var humanize = require('humanize');
+
+module.exports = function refreshTablesSize(metrics, pgClient) {
+  var queryString = "SELECT ((sum(relpages)* 8) * 1024) AS size_relations FROM pg_class WHERE relkind IN ('r', 't');";
+  pgClient.query(queryString, function (err, results) {
+    if (err) {
+      return pmx.notify("Table Size Query Error: " + err);
+    }
+
+    // Total Tables Size
+    metrics.tablesSize.set(humanize.filesize(results.rows[0].size_relations));
+  });
+};

package/lib/stats/refreshTransactionMetrics.js

@@ -0,0 +1,33 @@
+var pmx = require('pmx');
+
+module.exports = function refreshTransactionMetrics(metrics, pgClient) {
+  var queryString = "SELECT sum(xact_commit) AS transactions_committed,"
+    + " sum(xact_rollback) AS transactions_rollback, sum(blks_read) AS blocks_read,"
+    + " sum(blks_hit) AS blocks_hit, sum(tup_returned) AS tuples_returned,"
+    + " sum(tup_fetched) AS tuples_fetched, sum(tup_inserted) AS tuples_inserted,"
+    + " sum(tup_updated) AS tuples_updated, sum(tup_deleted) AS tuples_deleted"
+    + " FROM pg_stat_database;";
+  pgClient.query(queryString, function (err, results) {
+    if (err) {
+      return pmx.notify("Transaction Query Error: " + err);
+    }
+
+    // Transactions Committed
+    metrics.transactionsCommitted.set(results.rows[0].transactions_committed);
+
+    // Transactions Rollback
+    metrics.transactionsRollback.set(results.rows[0].transactions_rollback);
+
+    // Tuples Fetched
+    metrics.tuplesFetched.set(results.rows[0].tuples_fetched);
+
+    // Tuples Inserted
+    metrics.tuplesInserted.set(results.rows[0].tuples_inserted);
+
+    // Tuples Updated
+    metrics.tuplesUpdated.set(results.rows[0].tuples_updated);
+
+    // Tuples Deleted
+    metrics.tuplesDeleted.set(results.rows[0].tuples_deleted);
+  });
+};

package/lib/stats/refreshVersion.js

@@ -0,0 +1,17 @@
+var pmx = require('pmx');
+
+module.exports = function refreshVersion(metrics, pgClient) {
+  var queryString = "SELECT version();";
+  pgClient.query(queryString, function (err, results) {
+    if (err) {
+      return pmx.notify("Version Query Error: " + err);
+    }
+
+    // # of Indexes
+    var fullVersion = results.rows[0].version;
+    var match = fullVersion.match(/^PostgreSQL (\d+(?:\.\d+)*)/);
+    if (match) {
+      metrics.version.set(match[1]);
+    }
+  });
+};

package/lib/stats.js

@@ -0,0 +1,103 @@
+var pmx = require('pmx');
+
+var refreshTableCount = require('./stats/refreshTableCount');
+var refreshIndexCount = require('./stats/refreshIndexCount');
+var refreshTransactionMetrics = require('./stats/refreshTransactionMetrics');
+var refreshTablesSize = require('./stats/refreshTablesSize');
+var refreshBackendMetrics = require('./stats/refreshBackendMetrics');
+var refreshLockCount = require('./stats/refreshLockCount');
+var refreshVersion = require('./stats/refreshVersion');
+
+var metrics = {};
+var REFRESH_RATE = 10000; // ms
+var probe = pmx.probe();
+
+// Init metrics with default values
+function initMetrics() {
+  metrics.version = probe.metric({
+    name: 'PostgreSQL Version',
+    value: 'N/A'
+  });
+  metrics.tableCount = probe.metric({
+    name: 'Tables',
+    value: 'N/A'
+  });
+  metrics.indexCount = probe.metric({
+    name: 'Indexes',
+    value: 'N/A'
+  });
+  metrics.transactionsCommitted = probe.metric({
+    name: 'Transactions Committed',
+    value: 'N/A'
+  });
+  metrics.transactionsRollback = probe.metric({
+    name: 'Transactions Rollback',
+    value: 'N/A'
+  });
+  metrics.tuplesFetched = probe.metric({
+    name: 'Tuples Fetched',
+    value: 'N/A'
+  });
+  metrics.tuplesInserted = probe.metric({
+    name: 'Tuples Inserted',
+    value: 'N/A'
+  });
+  metrics.tuplesUpdated = probe.metric({
+    name: 'Tuples Updated',
+    value: 'N/A'
+  });
+  metrics.tuplesDeleted = probe.metric({
+    name: 'Tuples Deleted',
+    value: 'N/A'
+  });
+  metrics.tablesSize = probe.metric({
+    name: 'Total Tables Size',
+    value: 'N/A'
+  });
+  metrics.backendsActive = probe.metric({
+    name: 'Backends Active',
+    value: 'N/A'
+  });
+  metrics.backendsIdle = probe.metric({
+    name: 'Backends Idle',
+    value: 'N/A',
+    alert: {
+      mode: 'threshold-avg',
+      value: 8,
+      msg: 'Too many Idle Backends',
+      cmp: ">"
+    }
+  });
+  metrics.accessShareLockCount = probe.metric({
+    name: 'Access Share Locks',
+    value: 'N/A'
+  });
+  metrics.exclusiveLockCount = probe.metric({
+    name: 'Exclusive Locks',
+    value: 'N/A',
+    alert: {
+      mode: 'threshold-avg',
+      value: 500,
+      msg: 'Too many Exclusive Locks',
+      cmp: ">"
+    }
+  });
+}
+
+// Refresh metrics
+function refreshMetrics(pgClient) {
+  refreshTableCount(metrics, pgClient);
+  refreshIndexCount(metrics, pgClient);
+  refreshTransactionMetrics(metrics, pgClient);
+  refreshTablesSize(metrics, pgClient);
+  refreshBackendMetrics(metrics, pgClient);
+  refreshLockCount(metrics, pgClient);
+}
+
+function init(pgClient) {
+  initMetrics();
+  setInterval(refreshMetrics.bind(this, pgClient), REFRESH_RATE);
+  refreshVersion(metrics,pgClient);
+}
+
+module.exports.init = init;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@vladonv/pm2-postgres",
+  "version": "0.1.1",
+  "description": "PM2 PostgreSQL Module (fork of pm2-hive/pm2-postgres, updated for PostgreSQL 10-18 / SCRAM auth support)",
+  "main": "app.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "humanize": "0.0.9",
+    "pg": "^8.23.0",
+    "pmx": ">=0.5.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vladonv/pm2-postgres.git"
+  },
+  "config": {
+    "hostname": "localhost",
+    "port": 5432,
+    "username": "guest",
+    "password": "guest",
+    "database": "postgres"
+  },
+  "apps": [
+    {
+      "merge_logs": true,
+      "max_memory_restart": "200M",
+      "script": "app.js"
+    }
+  ],
+  "author": "Keymetrics Inc. (original), vladonv (fork maintainer)",
+  "license": "MIT",
+  "devDependencies": {}
+}