pg-monitor

Events monitor for pg-promise.

• About
• Installing
• Testing
• Usage
• API
  • attach
  • isAttached
  • detach
  • connect
  • disconnect
  • query
  • task
  • transact
  • error
  • detailed
  • setTheme
  • log
• Themes
• Useful Tips

About

This library takes the flexible event system provided by pg-promise and outputs it on screen, with full details available, and in the most informative way.

Its purpose is to give you the full picture of how the database is used in your application, providing full details with the context, such as tasks and transactions in which queries are executed.

In addition, it simplifies events logging for your application.

Installing

$ npm install pg-monitor

The library has no direct dependency on pg-promise.

Testing

• Clone the repository (or download, if you prefer):

$ git clone https://github.com/vitaly-t/pg-monitor

• Install the library's DEV dependencies:

$ npm install

• To run all tests:

$ npm test

• To run all tests with coverage:

$ npm run coverage

Usage

1const monitor = require('pg-monitor');
2
3const initOptions = {
4    // pg-promise initialization options;
5};
6
7const pgp = require('pg-promise')(initOptions);
8
9// attach to all pg-promise events of the initOptions object:
10monitor.attach(initOptions);
11
12// Example of attaching to just events 'query' and 'error':
13// monitor.attach(initOptions, ['query', 'error']); 

Method attach is to provide the quickest way to start using the library, by attaching to a set of events automatically.

If, however, you want to have full control over event handling, you can use the manual event forwarding.

Example of forwarding events query and error manually:

1const initOptions = {
2    query(e) {
3        /* do some of your own processing, if needed */
4
5        monitor.query(e); // monitor the event;
6    },
7    error(err, e) {
8        /* do some of your own processing, if needed */
9        
10        monitor.error(err, e); // monitor the event;
11    }
12};

See the API below for all the methods and options that you have.

Below is a safe forwarding implemented in TypeScript, for events connect, disconnect and query. It works the same for all other events.

1import * as monitor from 'pg-monitor';
2
3function forward(event: monitor.LogEvent, args: IArguments) {
4    // safe event forwarding into pg-monitor:
5    (monitor as any)[event].apply(monitor, [...args]);
6} 
7
8const options: IInitOptions = {
9    connect() {
10        forward('connect', arguments);
11    },
12    disconnect() {
13        forward('disconnect', arguments);
14    },
15    query() {
16        forward('query', arguments);
17    }
18};

API

attach(options, [events], [override])

Alternative Syntax: attach({options, events, override});

Adds event handlers to object initOptions that's used during pg-promise initialization:

1monitor.attach(initOptions); // mutates the options object to attach to all events

A repeated call (without calling detach first) will throw Repeated attachments not supported, must call detach first.

[events]

Optional array of event names to which to attach. Passing null/undefined will attach to all known events.

Example of attaching to just events query and error:

1monitor.attach(initOptions, ['query', 'error']);

Query-related events supported by pg-promise: connect, disconnect, query, task, transact and error.

See also: Initialization Options.

[override]

By default, the method uses derivation logic - it will call the previously configured event handler, if you have one, and only then will it call the internal implementation.

If, however, you want to override your own handlers, pass override = true.

Example of overriding all known event handlers:

1monitor.attach({options: initOptions, override: true});

isAttached()

Verifies if the monitor is currently attached, and returns a boolean.

detach()

Detaches from all the events to which attached after the last successful call to attach.

Calling it while not attached will throw Event monitor not attached.

connect({client, dc, useCount}, [detailed])

Monitors and reports event connect.

client

Client object passed to the event.

dc

Database Context.

useCount

Number of times the connection has been used.

[detailed]

Optional. When set, it reports such connection details as user@database.

When not set, it defaults to the value of monitor.detailed.

disconnect({client, dc}, [detailed])

Monitors and reports event disconnect.

client

Client object passed to the event.

dc

Database Context.

[detailed]

Optional. When set, it reports such connection details as user@database.

When not set, it defaults to the value of monitor.detailed.

query(e, [detailed])

Monitors and reports event query.

e

Event context object.

[detailed]

Optional. When set, it reports details of the task/transaction context in which the query is executing.

When not set, it defaults to the value of monitor.detailed.

task(e)

Monitors and reports event task.

e

Event context object.

transact(e)

Monitors and reports event transact.

e

Event context object.

error(err, e, [detailed])

Monitors and reports event error.

err

Error message passed to the event.

e

Event context object.

[detailed]

Optional. When set, it reports details of the task/transaction context in which the error occurred.

When not set, it defaults to the value of monitor.detailed.

detailed

This boolean property provides the default for every method that accepts optional parameter detailed.

By default, it is set to be true. Setting this parameter to false will automatically switch off all details in events that support optional details, unless they have their own parameter detailed passed in as true, which then overrides this global one.

Use method setDetailed to change the value.

setTheme(t)

Activates either a predefined or a custom color theme.

t

Either a predefined theme name or a custom theme object.

For details, see Color Themes.

log

This event is to let your application provide your own log for everything that appears on the screen.

1monitor.setLog((msg, info) => {
2    // save the screen message into your own log;
3});

The notification occurs for every single line of text that appears on the screen, so you can maintain a log file with exactly the same content.

msg

New message line, exactly as shown on the screen, with color attributes removed.

info

Object with additional information about the event:

• time - Date object that was used for the screen, or null when it is an extra line with the event's context details;
• colorText - color-coded message text, without time in front;
• text - message text without the time in front (color attributes removed);
• event - name of the event being logged.
• ctx - Optional, task/transaction context when available.

If your intent is only to log events, while suppressing any screen output, you can do so on per-event basis, as shown below:

1info.display = false; // suppress screen output for the event;

Themes

The library provides a flexible theme support to choose any color palette that you like, with a few of them predefined for your convenience.

For details, see Color Themes.

Useful Tips

If your application uses more than one task or transaction, it is a good idea to tag them, so they provide informative context for every query event that's being logged, i.e. so you can easily see in which task/transaction context queries are executed.

Tagging a task or transaction with pg-promise is very easy, by taking this code:

1db.task(t => {
2    // task queries; 
3});
4db.tx(t => {
5    // transaction queries; 
6});

and replacing it with this one:

1db.task(tag, t => {
2    // task queries; 
3});
4db.tx(tag, t => {
5    // transaction queries; 
6});

where tag is any object or value. In most cases you would want tag to be just a string that represents the task/transaction name, like this:

1db.task('MyTask', t => {
2    // task queries; 
3});
4db.tx('MyTransaction', t => {
5    // transaction queries; 
6});

The tag can be anything, including your custom object, so you can use it for your own reference when handling events. And if you want to use it as your own object, while also allowing this library to log the task/transaction pseudo-name/alias, then have your object implement method toString() that returns the tag name.