influx4mqtt 0.0.1 → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Sebastian Raff <hobbyquaker@gmail.com> (https://hobbyquaker.github.io)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,17 +1,117 @@
 # influx4mqtt
 
-Insert incoming MQTT values into InfluxDB.
+[![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)
+[![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]
 
-see [https://github.com/mqtt-smarthome/mqtt-smarthome](https://github.com/mqtt-smarthome/mqtt-smarthome)
+Record MQTT values in InfluxDB — the history behind a Grafana dashboard.
 
-## Install & Usage
+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.
+
+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
+
+```
+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`.
+
+### Docker
+
+Multi-arch image (amd64, arm64, armv7):
 
 ```
-sudo npm install -g influx4mqtt
-influx4mqtt --help
+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
 ```
 
+## 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
+
+```
+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
 
-MIT
+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

@@ -0,0 +1,108 @@
+/**
+ * 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.
+ */
+
+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,131 +1,87 @@
 #!/usr/bin/env node
-var pkg =   require('./package.json');
-var config = require('yargs')
-    .usage(pkg.name + ' ' + pkg.version + '\n' + pkg.description + '\n\nUsage: $0 [options]')
-    .describe('v', 'possible values: "error", "warn", "info", "debug"')
-    .describe('n', 'instance name. used as mqtt client id and as prefix for connection-state topic')
-    .describe('u', 'mqtt broker url. See https://github.com/mqttjs/MQTT.js#connect-using-a-url')
-    .describe('h', 'show help')
-    .alias({
-        'c': 'config',
-        'h': 'help',
-        'n': 'name',
-        'u': 'url',
-        'v': 'verbosity',
-        'i': 'influx-host',
-        'p': 'influx-port',
-        'd': 'influx-db'
 
-    })
-    .default({
-        'u': 'mqtt://127.0.0.1',
-        'n': 'influx',
-        'v': 'info',
-        'influx': false,
-        'influx-host': '127.0.0.1',
-        'influx-port': 8086,
-        'influx-db': 'mqtt'
-    })
-    .config('config')
-    .version(pkg.name + ' ' + pkg.version + '\n', 'version')
-    .help('help')
-    .argv;
-
-console.log('mqtt connecting', config.url);
-var mqtt = require('mqtt').connect(config.url, {will: {topic: config.name + '/connected', payload: '0'}});
-mqtt.publish(config.name + '/connected', '2');
-
-var subscriptions = [ // Todo command line param
-    '+/status/#',
-    '+/connected'
-];
-
-console.log('connecting InfluxDB', config['influx-host']);
-var influx = require('influx')({
-    host: config['influx-host'] || '127.0.0.1',
-    port: config['influx-port'] || 8086, // optional, default 8086
-    protocol: 'http', // optional, default 'http' // todo command line param
-    //username: 'dbuser', // todo command line param
-    //password: 'f4ncyp4ass', // todo command line param
-    database: config['influx-db'] || 'mqtt'
-});
-
-var buffer = {};
-var bufferCount = 0;
-
-var connected;
-mqtt.on('connect', function () {
-    connected = true;
-    console.log('mqtt connected ' + config.url);
-
-    subscriptions.forEach(function (subs) {
-        console.log('mqtt subscribe ' + subs);
-        mqtt.subscribe(subs);
-    });
-});
-
-
-mqtt.on('close', function () {
-    if (connected) {
-        connected = false;
-        console.log('mqtt closed ' + config.url);
+/**
+ * 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;
     }
-});
-
-mqtt.on('error', function () {
-    console.error('mqtt error ' + config.url);
-});
-
-
-mqtt.on('message', function (topic, payload, msg) {
-
-    if (msg.retain) return;
-
-    var timestamp = (new Date()).getTime();
-
-    payload = payload.toString();
-
-    var seriesName = topic.replace(/^([^\/]+)\/status\/(.+)/, '$1//$2');
-
-    var value;
-
-    try {
-        var tmp = JSON.parse(payload);
-        value = tmp.val;
-        timestamp = tmp.ts || timestamp;
-    } catch (e) {
-        value = payload;
+    // {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 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
+        }
     }
-    var valueFloat = parseFloat(value);
-
-    if (value === true || value === 'true') {
-        value = '1.0';
-    } else if (value === false || value === 'false') {
-        value = '0.0';
-    } else if (isNaN(valueFloat)) {
-        return; // FIXME do we need strings? Creating a field as string leads to errors when trying to write float on it. Can we expect topics to be of the same type always?
-        value = '"' + value + '"';
-    } else {
-        value = '' + valueFloat;
-        if (!value.match(/\./)) value = value + '.0';
+    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;
     }
+    recorded++;
+    writer.add(line);
+}
 
-    //console.log(seriesName, value, timestamp, tmp.ts);
-    if (!buffer[seriesName]) buffer[seriesName] = [];
-    buffer[seriesName].push([{value: value, time: timestamp}]);
-    bufferCount += 1;
-    if (bufferCount > 1000) write(); // todo command line param
-
+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 (!bufferCount) return;
-    //console.log('write', bufferCount);
-    influx.writeSeries(buffer, {}, function (err, res) {
-        if (err) console.error('error', err);
-    });
-    buffer = {};
-    bufferCount = 0;
-}
+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, 30000); // todo command line param
+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,34 +1,64 @@
 {
   "name": "influx4mqtt",
-  "version": "0.0.1",
-  "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": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "Sebastian 'hobbyquaker' Raff <hq@ccu.io>",
-  "license": "MIT",
-  "dependencies": {
-    "influx": "git://github.com/hobbyquaker/node-influx",
-    "mqtt": "^1.3.3",
-    "yargs": "^3.14.0"
-  },
   "bin": {
-    "influx4mqtt": "./index.js"
+    "influx4mqtt": "index.js"
   },
   "preferGlobal": true,
+  "files": [
+    "index.js",
+    "config.js",
+    "lib/"
+  ],
+  "engines": {
+    "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"
+  ],
+  "mqttInterfaces": {
+    "spec": "2.0",
+    "envPrefix": "INFLUX4MQTT",
+    "needs": [
+      "network"
+    ],
+    "serviceExtra": []
+  },
+  "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