influx4mqtt 1.0.0 → 2.0.0

package/README.md

@@ -2,51 +2,112 @@
 
 [![mqtt-smarthome](https://img.shields.io/badge/mqtt-smarthome-blue.svg)](https://github.com/mqtt-smarthome/mqtt-smarthome)
 [![NPM version](https://badge.fury.io/js/influx4mqtt.svg)](http://badge.fury.io/js/influx4mqtt)
-[![Dependency Status](https://img.shields.io/gemnasium/hobbyquaker/influx4mqtt.svg?maxAge=2592000)](https://gemnasium.com/github.com/hobbyquaker/influx4mqtt)
-[![Build Status](https://travis-ci.org/hobbyquaker/influx4mqtt.svg?branch=master)](https://travis-ci.org/hobbyquaker/influx4mqtt)
-[![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/sindresorhus/xo)
+[![CI](https://github.com/hobbyquaker/influx4mqtt/actions/workflows/ci.yml/badge.svg)](https://github.com/hobbyquaker/influx4mqtt/actions/workflows/ci.yml)
 [![License][mit-badge]][mit-url]
 
-Insert incoming MQTT values into InfluxDB.
+Record MQTT values in InfluxDB — the history behind a Grafana dashboard.
 
-see [https://github.com/mqtt-smarthome/mqtt-smarthome](https://github.com/mqtt-smarthome/mqtt-smarthome)
+Subscribes to the topics you name, turns each message into one InfluxDB point and writes them in
+batches. Numeric values only: booleans and `ON`/`OFF` become `1`/`0`, text is ignored, because a
+time series with a string in it is a series InfluxDB will not let you graph.
 
-Removes the mqtt-smarthome `status` from the topic (e.g. `hm/status/lamp` gets replaced by `hm//lamp`). Inserts numeric
-value only to InfluxDB, booleans are converted to `0.0` respectively `1.0`. Strings are ignored.
+Built on [mqtt-interfaces-core](https://github.com/hobbyquaker/mqtt-interfaces-core), so it has the
+same options, `--install`, `<name>/info` and maintenance topics as the rest of the `xyz2mqtt` fleet.
+Works with **InfluxDB 1 and 2**.
 
+## Install
 
-## Install & Usage
+```
+npm install -g influx4mqtt
+influx4mqtt --mqtt-url mqtt://broker                 # foreground
+sudo influx4mqtt --install -n influx -u mqtt://broker   # systemd service influx4mqtt@influx
+```
+
+`--install` writes the options to `/etc/influx4mqtt/<name>.env` and enables
+`influx4mqtt@<name>.service`. Broker settings shared with the other adapters on the host live in
+`/etc/mqtt-interfaces/broker.env`.
 
-`$ sudo npm install -g influx4mqtt`
+### Docker
 
-I suggest to use [pm2](http://pm2.keymetrics.io/) to manage the influx4mqtt process (start on system boot, manage log 
-files, ...)
+Multi-arch image (amd64, arm64, armv7):
 
+```
+docker run -d --name influx4mqtt --restart unless-stopped \
+  -e INFLUX4MQTT_MQTT_URL=mqtt://broker \
+  -e INFLUX4MQTT_INFLUX_URL=http://influxdb:8086 \
+  -e INFLUX4MQTT_SUBSCRIBE='+/status/#,$SYS/#' \
+  ghcr.io/hobbyquaker/influx4mqtt
+```
 
-## Command Line Parameters
+## What gets recorded
+
+Every message on a subscribed topic becomes one point:
+
+| topic                      | payload               | series                     | value                       |
+| -------------------------- | --------------------- | -------------------------- | --------------------------- |
+| `hm/status/Licht/STATE`    | `21.5`                | `hm//Licht/STATE`          | `21.5`                      |
+| `hm/status/Licht/STATE`    | `{"val":21.5,"ts":…}` | `hm//Licht/STATE`          | `21.5` at the device's `ts` |
+| `zigbee2mqtt/sensor/state` | `ON`                  | `zigbee2mqtt/sensor/state` | `1`                         |
+| `hm/status/mode`           | `auto`                | —                          | not recorded                |
+
+- **The `status` level is collapsed**: `hm/status/lamp` is recorded as `hm//lamp`, the
+  mqtt-smarthome convention. `--no-shorten-status` records the full topic instead — but only do
+  that on a fresh database, since it renames every series you already have.
+- **`{val, ts, lc}` payloads** are recorded at the device's own timestamp, not at arrival time.
+- **Retained messages are ignored.** On every reconnect the broker replays the retained value of
+  every matching topic; recording those would pile duplicates at the reconnect time rather than
+  when the value was measured.
+- **`$SYS/` is rewritten** to `$SYS/<hostname>/` by default, because `$SYS` topics are identical on
+  every broker and two of them in one database would interleave into nonsense. `--replace-sys`
+  chooses the prefix.
+
+## Options
+
+| Option              | Default                 | Meaning                                                 |
+| ------------------- | ----------------------- | ------------------------------------------------------- |
+| `-s, --subscribe`   | `+/status/#`            | topic to record, `+`/`#` wildcards; repeat for more     |
+| `-u, --mqtt-url`    | `mqtt://localhost`      | broker url                                              |
+| `-n, --name`        | `influx`                | instance name = topic prefix of its own topics          |
+| `--influx-url`      | `http://127.0.0.1:8086` | InfluxDB base url                                       |
+| `--influx-version`  | `1`                     | `1` (`/write?db=`) or `2` (`/api/v2/write`, token auth) |
+| `-d, --influx-db`   | `mqtt`                  | database (api 1) or bucket (api 2)                      |
+| `--influx-org`      |                         | organisation (api 2)                                    |
+| `--influx-token`    |                         | api token (api 2; InfluxDB 1.8+ accepts it too)         |
+| `--influx-username` |                         | http basic auth (api 1)                                 |
+| `--influx-password` |                         | http basic auth (api 1)                                 |
+| `--shorten-status`  | `true`                  | record `hm/status/lamp` as `hm//lamp`                   |
+| `--replace-sys`     | `$SYS/<hostname>/`      | rewrite the `$SYS/` prefix                              |
+| `--buf-length`      | `1000`                  | write once this many points are buffered                |
+| `--buf-interval`    | `30`                    | seconds between writes, however few points are buffered |
+| `-v, --verbosity`   | `info`                  | `error`, `warn`, `info`, `debug`                        |
+
+Every option is also an environment variable (`INFLUX4MQTT_SUBSCRIBE`, `INFLUX4MQTT_INFLUX_URL`, …);
+several subscriptions are comma separated there. `--help` lists the shared options too, and
+`--config-schema` prints the JSON Schema a management UI reads.
+
+### InfluxDB 2
 
 ```
-Usage: influx4mqtt [options]
-   
-Options:
-  -n, --name         instance name. used as prefix for connection-state topic
-                                                             [default: "influx"]
-  -v, --verbosity    possible values: "error", "warn", "info", "debug"
-                                                               [default: "info"]
-  -u, --url          mqtt broker url. May contain user/password
-                                                   [default: "mqtt://127.0.0.1"]
-  -k, --insecure     allow ssl connections with invalid certs          [boolean]
-  --buf-length       maximum number of buffered messages         [default: 1000]
-  --buf-interval     maximum age of buffered messages in seconds   [default: 30]
-  --replace-sys      replace $SYS/ by           [default: "$SYS/BastisMacBook/"]
-  -h, --help         Show help                                         [boolean]
-  --version          Show version number                               [boolean]
-  -s, --subscribe    topics to subscribe to (may be repeated)         [required]
-  -i, --influx-host                                       [default: "127.0.0.1"]
-  -p, --influx-port                                              [default: 8086]
-  -d, --influx-db                                              [default: "mqtt"]
+influx4mqtt -u mqtt://broker \
+  --influx-version 2 --influx-url http://influxdb:8086 \
+  --influx-org home --influx-db mqtt --influx-token <token>
 ```
 
+`--influx-db` is the bucket. Put the token in the instance's env file rather than on the command
+line, where a process list would show it — `--install` does that for you.
+
+## Topics of its own
+
+| Topic                             | Meaning                                                          |
+| --------------------------------- | ---------------------------------------------------------------- |
+| `<name>/connected`                | `2` InfluxDB is accepting writes · `1` broker only · `0` stopped |
+| `<name>/info`                     | endpoint, subscriptions, points recorded and skipped             |
+| `<name>/maintenance/set/loglevel` | `error` \| `warn` \| `info` \| `debug` at runtime                |
+| `<name>/maintenance/set/restart`  | graceful restart                                                 |
+| `<name>/maintenance/stats`        | memory, cpu, event loop lag, uptime                              |
+
+A database that is unreachable shows up as `<name>/connected 1`, so a broken recorder is visible
+without reading logs.
 
 ## License
 
@@ -54,4 +115,3 @@ MIT © [Sebastian Raff](https://github.com/hobbyquaker)
 
 [mit-badge]: https://img.shields.io/badge/License-MIT-blue.svg?style=flat
 [mit-url]: LICENSE
-

package/config.js

@@ -1,40 +1,108 @@
-const os = require('os');
-module.exports = require('yargs')
-    .usage('Usage: $0 [options]')
-    .describe('subscribe', 'topics to subscribe to (may be repeated)')
-    .describe('n', 'instance name. used as prefix for connection-state topic')
-    .describe('v', 'possible values: "error", "warn", "info", "debug"')
-    .describe('u', 'mqtt broker url. May contain user/password')
-    .describe('k', 'allow ssl connections with invalid certs')
-    .describe('buf-length', 'maximum number of buffered messages')
-    .describe('buf-interval', 'maximum age of buffered messages in seconds')
-    .describe('replace-sys', 'replace $SYS/ by')
-    .describe('h', 'show help')
-    .alias({
-        s: 'subscribe',
-        h: 'help',
-        n: 'name',
-        u: 'url',
-        i: 'influx-host',
-        p: 'influx-port',
-        d: 'influx-db',
-        k: 'insecure',
-        v: 'verbosity'
+/**
+ * Adapter options on top of the core's parseConfig(): the shared MQTT / name / maintenance
+ * options, INFLUX4MQTT_* environment variables and --config-schema come from
+ * mqtt-interfaces-core; only what is specific to recording into InfluxDB is defined here.
+ */
 
-    })
-    .demand('subscribe')
-    .boolean('insecure')
-    .default({
-        u: 'mqtt://127.0.0.1',
-        n: 'influx',
-        v: 'info',
-        influxHost: '127.0.0.1',
-        influxPort: 8086,
-        influxDb: 'mqtt',
-        bufLength: 1000,
-        bufInterval: 30,
-        replaceSys: '$SYS/' + os.hostname() + '/'
-    })
-    .version()
-    .help('help')
-    .argv;
+import os from 'node:os';
+import {parseConfig} from 'mqtt-interfaces-core';
+import pkg from './package.json' with {type: 'json'};
+
+export const OPTIONS = {
+    subscribe: {
+        alias: 's',
+        type: 'array',
+        describe: 'mqtt topic to record, with + and # wildcards (repeatable)',
+        default: ['+/status/#'],
+    },
+    'influx-url': {
+        type: 'string',
+        describe: 'influxdb base url',
+        default: 'http://127.0.0.1:8086',
+    },
+    'influx-version': {
+        type: 'number',
+        describe: 'influxdb api: 1 (/write?db=) or 2 (/api/v2/write, token auth)',
+        choices: [1, 2],
+        default: 1,
+    },
+    'influx-db': {
+        alias: 'd',
+        type: 'string',
+        describe: 'database (api 1) or bucket (api 2)',
+        default: 'mqtt',
+    },
+    'influx-org': {
+        type: 'string',
+        describe: 'influxdb organisation (api 2)',
+    },
+    'influx-token': {
+        type: 'string',
+        describe: 'influxdb api token (api 2; also accepted by influxdb 1.8+)',
+        secret: true,
+    },
+    'influx-username': {
+        type: 'string',
+        describe: 'influxdb username (api 1, http basic auth)',
+    },
+    'influx-password': {
+        type: 'string',
+        describe: 'influxdb password (api 1)',
+        secret: true,
+    },
+    'shorten-status': {
+        type: 'boolean',
+        describe: 'record hm/status/lamp as hm//lamp — the mqtt-smarthome convention',
+        default: true,
+    },
+    'replace-sys': {
+        type: 'string',
+        describe: '$SYS/ topics are the same on every broker: rewrite the prefix to tell them apart',
+        default: `$SYS/${os.hostname()}/`,
+    },
+    'buf-length': {
+        type: 'number',
+        describe: 'write to influxdb once this many points are buffered',
+        default: 1000,
+    },
+    'buf-interval': {
+        type: 'number',
+        describe: 'seconds between writes, however few points are buffered',
+        default: 30,
+    },
+};
+
+/** yargs .check(): value ranges the option types cannot express. */
+export function check(argv) {
+    if (!(argv.bufLength >= 1)) {
+        throw new Error('--buf-length must be >= 1');
+    }
+    if (!(argv.bufInterval >= 1)) {
+        throw new Error('--buf-interval must be >= 1 second');
+    }
+    if (Number(argv.influxVersion) === 2 && !argv.influxToken) {
+        throw new Error('--influx-version 2 needs --influx-token');
+    }
+    if (!/^https?:\/\//.test(String(argv.influxUrl))) {
+        throw new Error('--influx-url must start with http:// or https://');
+    }
+    for (const topic of argv.subscribe || []) {
+        if (!topic || /#.+/.test(topic)) {
+            throw new Error(`--subscribe ${topic}: # is only allowed as the last level`);
+        }
+    }
+    return true;
+}
+
+export default parseConfig({
+    pkg,
+    options: OPTIONS,
+    defaults: {name: 'influx'},
+    check,
+    examples: [
+        ['$0 -u mqtt://broker', 'record every mqtt-smarthome status topic'],
+        ['$0 -u mqtt://broker -s "+/status/#" -s "zigbee2mqtt/+/+"', 'record two topic patterns'],
+        ['$0 --influx-version 2 --influx-org home --influx-db mqtt --influx-token …', 'influxdb 2'],
+        ['sudo $0 --install -n influx -u mqtt://broker', 'install as service influx4mqtt@influx'],
+    ],
+});

package/index.js

@@ -1,122 +1,87 @@
 #!/usr/bin/env node
 
-const Mqtt = require('mqtt');
-const request = require('request');
-const log = require('yalm');
-const pkg = require('./package.json');
-const config = require('./config.js');
-
-process.title = pkg.name;
-
-log.setLevel(config.verbosity);
-
-log.info(pkg.name + ' ' + pkg.version + ' starting');
-
-log.info('mqtt connecting', config.url);
-const mqtt = Mqtt.connect(config.url, {
-    will: {topic: config.name + '/connected', payload: '0', retain: true},
-    rejectUnauthorized: !config.insecure
-});
-
-if (typeof config.subscribe === 'string') {
-    config.subscribe = [config.subscribe];
-}
-
-let buffer = [];
-
-let connected;
-mqtt.on('connect', () => {
-    mqtt.publish(config.name + '/connected', '2', {retain: true});
-    connected = true;
-    log.info('mqtt connected ' + config.url);
-
-    config.subscribe.forEach(topic => {
-        log.info('mqtt subscribe ' + topic);
-        mqtt.subscribe(topic);
-    });
-});
-
-mqtt.on('close', () => {
-    if (connected) {
-        connected = false;
-        log.info('mqtt closed ' + config.url);
-    }
-});
-
-mqtt.on('error', err => {
-    log.error('mqtt', err.message);
-});
-
-mqtt.on('message', (topic, payload, msg) => {
-    if (msg.retain) {
+/**
+ * influx4mqtt — record MQTT values in InfluxDB, on mqtt-interfaces-core.
+ *
+ * A *sink*: unlike a device adapter it has no device of its own, its subject is what every other
+ * adapter publishes. The core's `listen` gives it the subscriptions (absolute topics, not under
+ * `<name>/`); lib/line.js turns a message into a point and lib/influx.js writes them in batches.
+ *
+ * `<name>/connected` reports 2 while InfluxDB is accepting writes and 1 while it is not, so a
+ * database that is down is visible on the broker rather than only in the log.
+ */
+
+import {createAdapter} from 'mqtt-interfaces-core';
+import config from './config.js';
+import pkg from './package.json' with {type: 'json'};
+import {handle as handleInstall} from './lib/install.js';
+import {seriesName, point} from './lib/line.js';
+import {createWriter} from './lib/influx.js';
+
+handleInstall(config); // --install / --uninstall never reach the rest
+
+let writer;
+let recorded = 0;
+let skipped = 0;
+
+/**
+ * One message -> at most one point.
+ *
+ * Retained messages are ignored: on every (re)connect the broker replays the retained value of
+ * every matching topic, and recording those would put a burst of duplicates at the reconnect time
+ * rather than at the time the value was actually measured.
+ */
+function record(topic, value, raw, packet) {
+    if (packet.retain) {
         return;
     }
-
-    let timestamp = (new Date()).getTime();
-
-    payload = payload.toString();
-
-    const seriesName = topic.replace(/^([^/]+)\/status\/(.+)/, '$1//$2').replace(/^\$SYS\//, config.replaceSys);
-
-    let value;
-
-    if (payload.indexOf('{') === -1) {
-        value = payload;
-    } else {
+    // {val, ts, lc} payloads carry the device's own time; parsePayload gave us the value, the
+    // timestamp has to come out of the raw payload
+    let timestamp = Date.now();
+    if (raw.includes('{')) {
         try {
-            const tmp = JSON.parse(payload);
-            value = tmp.val;
-            timestamp = tmp.ts || timestamp;
-        } catch (err) {
-            value = payload;
+            const json = JSON.parse(raw);
+            if (json && typeof json === 'object' && Number(json.ts) > 0) {
+                timestamp = Number(json.ts);
+            }
+        } catch {
+            // not JSON after all; our clock it is
         }
     }
-
-    log.debug('<', topic, typeof value, value, payload);
-
-    const valueFloat = parseFloat(value);
-
-    if (value === true || value === 'true') {
-        value = '1.0';
-    } else if (value === false || value === 'false') {
-        value = '0.0';
-    } else if (isNaN(valueFloat)) {
+    const series = seriesName(topic, {shortenStatus: config.shortenStatus, replaceSys: config.replaceSys});
+    const line = point(series, value, timestamp);
+    if (!line) {
+        skipped++; // text, or a payload that is not a number - not a time series
         return;
-    } else {
-        value = String(valueFloat);
-        if (!value.match(/\./)) {
-            value += '.0';
-        }
     }
+    recorded++;
+    writer.add(line);
+}
 
-    log.debug('>', seriesName, value, timestamp);
-    buffer.push(seriesName.replace(/ /g, '\\ ').replace(/,/g, '\\,') + ' value=' + value + ' ' + (timestamp * 1000000));
-    if (buffer.length > config.bufLength) {
-        write();
-    }
+const adapter = createAdapter({
+    pkg,
+    config,
+    deviceLabel: 'influx',
+    info: () => ({
+        influx: writer ? writer.url : undefined,
+        api: config.influxVersion,
+        db: config.influxDb,
+        subscribe: config.subscribe,
+        buffered: writer ? writer.size : 0,
+        recorded,
+        skipped,
+    }),
+    // a sink: the topics are the user's, anywhere on the broker, not under <name>/
+    listen: Object.fromEntries(config.subscribe.map((topic) => [topic, record])),
+    onShutdown: () => writer.stop(),
 });
 
-function write() {
-    if (buffer.length === 0) {
-        return;
-    }
-
-    const body = buffer.join('\n');
-    buffer = [];
-
-    request.post({
-        url: 'http://' + config.influxHost + ':' + config.influxPort + '/write',
-        qs: {db: config.influxDb},
-        body
-    }, (err, res, resBody) => {
-        if (err) {
-            log.error(err.message);
-        } else if (res.statusCode === 204) {
-            log.debug('wrote ' + body.length + ' points');
-        } else {
-            log.error(res.statusCode, resBody);
-        }
-    });
-}
+writer = createWriter(config, {
+    log: adapter.log,
+    // <name>/connected 2 while influx accepts writes, 1 while it does not
+    onState: (up) => adapter.setDeviceConnected(up),
+});
 
-setInterval(write, config.bufInterval * 1000);
+adapter.log.info(`influxdb api ${config.influxVersion} at ${writer.url}`);
+writer.start();
+adapter.start();

package/lib/influx.js

@@ -0,0 +1,145 @@
+/**
+ * The InfluxDB write client: where the points go and how the request is authenticated.
+ *
+ * InfluxDB 1 and 2 speak the same line protocol — only the endpoint and the auth differ, which is
+ * why one adapter can serve both and `--influx-version` is all it takes:
+ *
+ *   v1   POST <url>/write?db=<db>&precision=ns            optional HTTP basic auth
+ *   v2   POST <url>/api/v2/write?org=<org>&bucket=<db>&precision=ns   Authorization: Token <token>
+ *
+ * InfluxDB 2 also serves the v1 endpoint for compatibility, so `--influx-version 1` against a v2
+ * server works if a v1 mapping was set up there; `2` is the native path and the one to prefer.
+ *
+ * Points are buffered because one HTTP request per MQTT message would be absurd at the rate a
+ * smart home publishes. The buffer is flushed when it is full, on a timer, and on shutdown — the
+ * last one is why this takes the adapter's lifecycle rather than a bare `setInterval`.
+ */
+
+/** The URL a write goes to, query string included. */
+export function writeUrl({influxUrl, influxVersion = 1, influxDb, influxOrg}) {
+    const base = String(influxUrl).replace(/\/+$/, '');
+    const q = new URLSearchParams({precision: 'ns'});
+    if (Number(influxVersion) === 2) {
+        q.set('bucket', influxDb);
+        if (influxOrg) {
+            q.set('org', influxOrg);
+        }
+        return `${base}/api/v2/write?${q}`;
+    }
+    q.set('db', influxDb);
+    return `${base}/write?${q}`;
+}
+
+/** Auth and content headers for a write. The api version does not matter here — a token is
+ * accepted by both, so only which credential was given decides the scheme. */
+export function writeHeaders({influxToken, influxUsername, influxPassword}) {
+    const headers = {'content-type': 'text/plain; charset=utf-8'};
+    if (influxToken) {
+        // v2's scheme, and accepted by v1.8+ as well
+        headers.authorization = `Token ${influxToken}`;
+    } else if (influxUsername) {
+        const basic = Buffer.from(`${influxUsername}:${influxPassword || ''}`).toString('base64');
+        headers.authorization = `Basic ${basic}`;
+    }
+    return headers;
+}
+
+/**
+ * A buffer of line-protocol points that writes itself out.
+ *
+ * @param {object} config parsed config (influxUrl, influxVersion, influxDb, influxOrg, credentials,
+ *        bufLength, bufInterval)
+ * @param {{log?: object, fetchImpl?: Function, onState?: (up: boolean) => void}} [deps]
+ *        `onState` reports reachability, so the adapter can put it in <name>/connected
+ */
+export function createWriter(config, {log = console, fetchImpl = globalThis.fetch, onState} = {}) {
+    const url = writeUrl(config);
+    const headers = writeHeaders(config);
+    const max = Number(config.bufLength) > 0 ? Number(config.bufLength) : 1000;
+    let buffer = [];
+    let timer = null;
+    let up = null;
+    let inFlight = null;
+
+    function state(next) {
+        if (next !== up) {
+            up = next;
+            if (onState) {
+                onState(next);
+            }
+        }
+    }
+
+    async function send(lines) {
+        const body = lines.join('\n');
+        let response;
+        try {
+            response = await fetchImpl(url, {method: 'POST', headers, body});
+        } catch (error) {
+            // unreachable: the points are gone. Keeping them would grow without bound while a
+            // database is down for a day, and a gap is the honest outcome for a time series.
+            log.warn('influx unreachable —', error.message, `(${lines.length} points dropped)`);
+            state(false);
+            return false;
+        }
+        if (response.status === 204 || response.status === 200) {
+            log.debug('influx wrote', lines.length, 'points');
+            state(true);
+            return true;
+        }
+        let detail = '';
+        try {
+            detail = (await response.text()).slice(0, 300);
+        } catch {
+            // a body we cannot read changes nothing about the status
+        }
+        // 4xx is our own line protocol being wrong: the same points would fail again, so they go
+        log.error('influx write failed', response.status, detail);
+        state(response.status < 500);
+        return false;
+    }
+
+    /** Write everything buffered. Serialised: two overlapping writes could reorder points. */
+    function flush() {
+        if (buffer.length === 0) {
+            return inFlight || Promise.resolve(true);
+        }
+        const lines = buffer;
+        buffer = [];
+        inFlight = Promise.resolve(inFlight)
+            .catch(() => {})
+            .then(() => send(lines));
+        return inFlight;
+    }
+
+    return {
+        /** Buffer one point; writes early when the buffer is full. */
+        add(line) {
+            buffer.push(line);
+            if (buffer.length >= max) {
+                flush();
+            }
+        },
+        flush,
+        get size() {
+            return buffer.length;
+        },
+        get url() {
+            return url;
+        },
+        start() {
+            const seconds = Number(config.bufInterval) > 0 ? Number(config.bufInterval) : 30;
+            timer = setInterval(flush, seconds * 1000);
+            if (timer.unref) {
+                timer.unref(); // the mqtt connection keeps the process alive, not this
+            }
+        },
+        async stop() {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            await flush(); // whatever is buffered on SIGTERM would otherwise be lost
+        },
+    };
+}

package/lib/install.js

@@ -0,0 +1,18 @@
+/**
+ * --install / --uninstall: systemd template service influx4mqtt@<name> (mqtt-interfaces-core
+ * installer). Nothing privileged — it talks to two network services and keeps no state.
+ */
+
+import {createInstaller} from 'mqtt-interfaces-core';
+
+export const SERVICE = 'influx4mqtt';
+export const ENV_PREFIX = 'INFLUX4MQTT';
+
+const installer = createInstaller({
+    service: SERVICE,
+    envPrefix: ENV_PREFIX,
+    description: `${SERVICE} %i - MQTT to InfluxDB recorder`,
+    documentation: 'https://github.com/hobbyquaker/influx4mqtt',
+});
+
+export const {unitFile, envFile, installService, uninstallService, handle} = installer;

package/lib/line.js

@@ -0,0 +1,107 @@
+/**
+ * Topic and payload → one InfluxDB line-protocol point. Pure: no sockets, no config object, so
+ * every rule below is testable on its own.
+ *
+ * The measurement is the topic, lightly rewritten (see `seriesName`); the only field is `value`,
+ * always a float, because a series whose type changes is a series Influx will refuse to write.
+ */
+
+/** Line protocol escapes in a measurement name: spaces and commas separate tokens. */
+export function escapeMeasurement(name) {
+    return name.replace(/,/g, '\\,').replace(/ /g, '\\ ');
+}
+
+/**
+ * The series a topic is recorded under.
+ *
+ * `shortenStatus` collapses the mqtt-smarthome `status` level — `hm/status/lamp` becomes
+ * `hm//lamp`. It has been the behaviour since 1.0 and stays the default: turning it off renames
+ * every existing series and splits the history in Grafana. New setups may prefer the full topic.
+ *
+ * `replaceSys` rewrites the leading `$SYS/`, whose topics are otherwise identical on every broker
+ * — recording two of them into one database would interleave them into nonsense.
+ *
+ * @param {string} topic
+ * @param {{shortenStatus?: boolean, replaceSys?: string}} [options]
+ */
+export function seriesName(topic, {shortenStatus = true, replaceSys} = {}) {
+    let name = topic;
+    if (shortenStatus) {
+        name = name.replace(/^([^/]+)\/status\/(.+)$/, '$1//$2');
+    }
+    if (replaceSys) {
+        name = name.replace(/^\$SYS\//, replaceSys);
+    }
+    return name;
+}
+
+/** Payloads that mean true / false rather than a number. Case-insensitive since 2.0. */
+const TRUE = new Set(['true', 'on', 'yes']);
+const FALSE = new Set(['false', 'off', 'no']);
+
+/**
+ * A value → the float Influx stores, as a string, or `null` for anything that is not a number.
+ *
+ * Booleans and the strings devices use for them become `1`/`0`; everything else has to parse as a
+ * number. Text is dropped rather than stored — this is a numeric time series, and a string field
+ * would fix the series' type to string forever.
+ *
+ * The trailing `.0` is deliberate: without it Influx infers an integer field, and a series that
+ * starts out integer rejects the first float that arrives.
+ *
+ * @returns {string|null}
+ */
+export function toFloat(value) {
+    if (value === true) {
+        return '1.0';
+    }
+    if (value === false) {
+        return '0.0';
+    }
+    let number;
+    if (typeof value === 'number') {
+        number = value;
+    } else if (typeof value === 'string') {
+        const trimmed = value.trim();
+        const lower = trimmed.toLowerCase();
+        if (TRUE.has(lower)) {
+            return '1.0';
+        }
+        if (FALSE.has(lower)) {
+            return '0.0';
+        }
+        if (trimmed === '') {
+            return null;
+        }
+        /*
+         * Number(), not parseFloat(): parseFloat('21 °C') is 21, and recording that as a
+         * temperature is worse than recording nothing — it looks like a real measurement. The
+         * empty string is handled above because Number('') is 0, not NaN.
+         */
+        number = Number(trimmed);
+    } else {
+        // objects, null, undefined: Number(null) is 0 and Number([5]) is 5, so never fall through
+        return null;
+    }
+    if (!Number.isFinite(number)) {
+        return null;
+    }
+    const text = String(number);
+    return /[.e]/i.test(text) ? text : text + '.0';
+}
+
+/**
+ * One line-protocol point, or `null` when the value is not numeric.
+ *
+ * @param {string} series measurement name (already rewritten by `seriesName`)
+ * @param {*} value
+ * @param {number} timestampMs
+ */
+export function point(series, value, timestampMs) {
+    const float = toFloat(value);
+    if (float === null || !series) {
+        return null;
+    }
+    // influx takes nanoseconds; the timestamp is milliseconds, from the payload or our clock
+    return `${escapeMeasurement(series)} value=${float} ${Math.round(timestampMs) * 1000000}`;
+}

package/package.json

@@ -1,45 +1,64 @@
 {
   "name": "influx4mqtt",
-  "version": "1.0.0",
-  "description": "Insert incoming MQTT values into InfluxDB. Follows mqtt-smarthome architecture.",
+  "version": "2.0.0",
+  "description": "Record MQTT values in InfluxDB. Follows the mqtt-smarthome architecture.",
+  "type": "module",
   "main": "index.js",
-  "scripts": {
-    "test": "camo-purge ; xo"
-  },
-  "author": "Sebastian 'hobbyquaker' Raff <hobbyquaker@gmail.com>",
-  "license": "MIT",
-  "dependencies": {
-    "mqtt": "^2.15.1",
-    "request": "^2.83.0",
-    "yalm": "^4.1.0",
-    "yargs": "^11.0.0"
-  },
   "bin": {
-    "influx4mqtt": "./index.js"
+    "influx4mqtt": "index.js"
   },
   "preferGlobal": true,
+  "files": [
+    "index.js",
+    "config.js",
+    "lib/"
+  ],
   "engines": {
-    "node": ">=6.0.0"
+    "node": "^20.19 || ^22.12 || >=24"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "lint": "eslint . && prettier --check .",
+    "format": "prettier --write . && eslint --fix .",
+    "test": "node --test",
+    "deploy": "bash deploy.sh"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/hobbyquaker/influx4mqtt"
+    "url": "git+https://github.com/hobbyquaker/influx4mqtt.git"
+  },
+  "homepage": "https://github.com/hobbyquaker/influx4mqtt",
+  "bugs": {
+    "url": "https://github.com/hobbyquaker/influx4mqtt/issues"
   },
+  "author": "Sebastian Raff <hobbyquaker@gmail.com> (https://github.com/hobbyquaker)",
+  "license": "MIT",
   "keywords": [
     "mqtt",
-    "smarthome",
-    "history",
+    "mqtt-smarthome",
+    "home-automation",
     "influxdb",
-    "charts",
+    "influx",
     "grafana",
-    "time",
-    "series"
+    "time series",
+    "history"
   ],
-  "devDependencies": {
-    "camo-purge": "latest",
-    "xo": "latest"
+  "mqttInterfaces": {
+    "spec": "2.0",
+    "envPrefix": "INFLUX4MQTT",
+    "needs": [
+      "network"
+    ],
+    "serviceExtra": []
   },
-  "xo": {
-    "space": 4
+  "dependencies": {
+    "mqtt-interfaces-core": "^0.13.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9",
+    "eslint": "^9",
+    "eslint-config-prettier": "^10",
+    "globals": "^16",
+    "prettier": "^3"
   }
 }

package/.npmignore

@@ -1,3 +0,0 @@
-.idea
-node_modules
-.DS_Store

package/.travis.yml

@@ -1,3 +0,0 @@
-language: node_js
-node_js:
-  - '6'