LISTEN notifications stop after a while

I’m using LISTEN to be notified of changes. It used to work perfectly when I was listening to a DB on localhost. However, now that I’ve moved the DB over to another VM, I’m encountering some problems where my client loses “sync” with the DB and stops receiving notifications after some time (in order of minutes/hours).

I’m not using the connection pool, here’s how I connect and listen to updates:

var client = new pg.Client(pgConString);
client.connect(function(err, client) {
    if(err) {
      throw err;
    }
    client.on('notification', function(msg) {
        console.log(msg.payload);
    });
    client.on('error', function(error) {
      console.error('This never even runs:', error);
    });
    var query = client.query("LISTEN watchers");
});

Is it possible keep this listener working indefinitely? Am I doing something silly? What is supposed to happen after a momentary network failure? Do I have to resign to polling the DB and diffing changes?

[pankleks]

I found problem with my case - in fact stupid mistake. Connection used for notification was taken from pool, when I created dedication connection with new Client(...) is looks good.

Here is piece of TS code that could be reused - hope it helps. In case connection is lost, it will try to reconnect immediately, if this fails, it will try again after some time.

    listen(fn: (message: { channel: string, payload: string }, client: Pg.Client) => void, ...channels: string[]) {
        let
            client = new Pg.Client(this._config);

        client.connect((err) => {
            if (err) {
                console.error(`Can't connect listener.`);

                setTimeout(() => {
                    this.listen(fn, ...channels);
                }, 1000 * LISTEN_RECONNECT_S);

                return;
            }

            client.on("notification", (message) => {
                fn(message, client);
            });

            client.on("error", (err) => {
                console.error(`Lost connection for listener.`);
                this.listen(fn, ...channels);
            });

            for (let e of channels)
                client.query(`LISTEN ${e}`);
        });
    }

[vitaly-t]

One of the main reasons why this library moved mostly into the use of the connection pool is because it is very awkward dealing with dropped connections, while the pool can maintain connections automatically.

But with the event listening it is impossible to use the pool, because each connection in the pool has an expiration on it.

If you cannot detect a dropped connection through the client interface, you can try and detect it otherwise, and once detected, re-establish the watcher.

If you suspect a networking failure, you can listen for that, somehow.

Like I said, static connections are awkward. And listeners are used by very few people, so there is no standard solution to this, it seems. I would suggest to inquire about this on Stack Overflow.