@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/influxdb/influxdb.js

@@ -0,0 +1,1487 @@
+module.exports = function (RED) {
+
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+
+    const http = require("http");
+
+    const https = require("https");
+
+    const { URL } = require("url");
+    const DEFAULT_MAX_QUEUE_SIZE = 50000;
+    const DEFAULT_BATCH_SIZE = 500;
+    const DEFAULT_FLUSH_INTERVAL_MS = 1000;
+    const DEFAULT_REQUEST_TIMEOUT_MS = 10000;
+    const DEFAULT_RETRY_BASE_MS = 1000;
+    const DEFAULT_RETRY_MAX_MS = 30000;
+    const DEFAULT_MIN_WRITE_INTERVAL_MS = 1000;
+    const DEFAULT_HEARTBEAT_MS = 60000;
+    const DEFAULT_ERROR_LOG_MAX_REPEATS = 10;
+    const DEFAULT_ERROR_LOG_WINDOW_MS = 60000;
+    const DEFAULT_ERROR_LOG_MUTE_MS = 300000;
+    const VALID_PRECISIONS = {
+        ns: 1,
+        us: 1000,
+        ms: 1000000,
+        s: 1000000000
+    };
+
+
+    function cleanString(value) {
+
+        return String(value || "").trim();
+
+    }
+
+
+    function positiveNumber(value, fallback) {
+
+        const n = Number(value);
+
+        return Number.isFinite(n) && n > 0 ? n : fallback;
+
+    }
+
+
+    function positiveInteger(value, fallback) {
+
+        const n = Math.round(Number(value));
+
+        return Number.isFinite(n) && n > 0 ? n : fallback;
+
+    }
+
+
+    function positiveIntegerWithLegacyDefault(value, fallback, legacyValues) {
+
+        const n = positiveInteger(value, fallback);
+        const legacy = Array.isArray(legacyValues) ? legacyValues : [];
+
+        return legacy.indexOf(n) !== -1 ? fallback : n;
+
+    }
+
+
+    function normalizePrecision(value) {
+
+        const precision = cleanString(value || "ns");
+
+        return VALID_PRECISIONS[precision] ? precision : "ns";
+
+    }
+
+
+    function nonNegativeInteger(value, fallback) {
+
+        const n = Math.round(Number(value));
+
+        return Number.isFinite(n) && n >= 0 ? n : fallback;
+
+    }
+
+
+    function normalizeDropPolicy(value) {
+
+        const policy = cleanString(value || "drop_oldest");
+
+        return policy === "drop_newest" ? "drop_newest" : "drop_oldest";
+
+    }
+
+
+    function parseTags(value) {
+
+        const text = cleanString(value);
+
+        const tags = {};
+
+
+        if (!text) {
+
+            return tags;
+
+        }
+
+
+        if (text.charAt(0) === "{") {
+
+            try {
+
+                const parsed = JSON.parse(text);
+
+                if (isPlainObject(parsed)) {
+
+                    Object.keys(parsed).forEach(function (key) {
+
+                        const tagKey = cleanString(key);
+
+                        const tagValue = cleanString(parsed[key]);
+
+                        if (tagKey && tagValue) {
+
+                            tags[tagKey] = tagValue;
+
+                        }
+
+                    });
+
+                    return tags;
+
+                }
+
+            } catch (err) {
+
+                return tags;
+
+            }
+
+        }
+
+
+        text.split(",").forEach(function (part) {
+
+            const index = part.indexOf("=");
+
+            if (index <= 0) {
+
+                return;
+
+            }
+
+
+            const key = cleanString(part.slice(0, index));
+
+            const tagValue = cleanString(part.slice(index + 1));
+
+            if (key && tagValue) {
+
+                tags[key] = tagValue;
+
+            }
+
+        });
+
+
+        return tags;
+
+    }
+
+
+    function isPlainObject(value) {
+
+        return value !== null && typeof value === "object" && !Array.isArray(value);
+
+    }
+
+
+    function sanitizeKey(value) {
+
+        return cleanString(value)
+
+            .replace(/\s+/g, "_")
+
+            .replace(/[^A-Za-z0-9_.-]/g, "_");
+
+    }
+
+
+    function escapeMeasurement(value) {
+
+        return cleanString(value).replace(/\\/g, "\\\\").replace(/ /g, "\\ ").replace(/,/g, "\\,");
+
+    }
+
+
+    function escapeTag(value) {
+
+        return cleanString(value)
+
+            .replace(/\\/g, "\\\\")
+
+            .replace(/ /g, "\\ ")
+
+            .replace(/,/g, "\\,")
+
+            .replace(/=/g, "\\=");
+
+    }
+
+
+    function escapeFieldKey(value) {
+
+        return cleanString(value).replace(/\\/g, "\\\\").replace(/ /g, "\\ ").replace(/,/g, "\\,").replace(/=/g, "\\=");
+
+    }
+
+
+    function escapeStringField(value) {
+
+        return String(value).replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+
+    }
+
+
+    function fieldValueToLineProtocol(value) {
+
+        if (typeof value === "number" && Number.isFinite(value)) {
+
+            return String(value);
+
+        }
+
+
+        if (typeof value === "string" && value.trim() !== "") {
+
+            const parsed = Number(value);
+
+            if (Number.isFinite(parsed)) {
+
+                return String(parsed);
+
+            }
+
+            return "";
+
+        }
+
+
+        return "";
+
+    }
+
+
+    function timestampToNs(value) {
+
+        if (value === undefined || value === null || value === "") {
+
+            return "";
+
+        }
+
+
+        if (value instanceof Date) {
+
+            const ms = value.getTime();
+
+            return Number.isFinite(ms) ? String(ms * 1000000) : "";
+
+        }
+
+
+        if (typeof value === "number" && Number.isFinite(value)) {
+
+            if (value > 1000000000000000000) {
+
+                return String(Math.round(value));
+
+            }
+
+            if (value > 1000000000000000) {
+
+                return String(Math.round(value * 1000));
+
+            }
+
+            if (value > 1000000000000) {
+
+                return String(Math.round(value * 1000000));
+
+            }
+
+            return String(Math.round(value * 1000000000));
+
+        }
+
+
+        const parsed = Date.parse(String(value));
+
+        return Number.isFinite(parsed) ? String(parsed * 1000000) : "";
+
+    }
+
+
+    function timestampToPrecision(value, precision) {
+
+        const ns = Number(timestampToNs(value));
+
+        if (!Number.isFinite(ns)) {
+
+            return "";
+
+        }
+
+        const factor = VALID_PRECISIONS[normalizePrecision(precision)] || 1;
+
+        return String(Math.round(ns / factor));
+
+    }
+
+
+    function flattenNumericFields(source, prefix, target) {
+
+        Object.keys(source || {}).forEach(function (key) {
+
+            const value = source[key];
+
+            const nextKey = prefix ? prefix + "_" + sanitizeKey(key) : sanitizeKey(key);
+
+            if (!nextKey) {
+
+                return;
+
+            }
+
+
+            if (typeof value === "number" && Number.isFinite(value)) {
+
+                target[nextKey] = value;
+
+                return;
+
+            }
+
+
+            if (typeof value === "string" && value.trim() !== "") {
+
+                const parsed = Number(value);
+
+                if (Number.isFinite(parsed)) {
+
+                    target[nextKey] = parsed;
+
+                }
+
+                return;
+
+            }
+
+
+            if (isPlainObject(value)) {
+
+                flattenNumericFields(value, nextKey, target);
+
+            }
+
+        });
+
+    }
+
+
+    function normalizePoint(input, defaults) {
+
+        const point = isPlainObject(input) ? input : {};
+
+        const payload = isPlainObject(point.payload) ? point.payload : {};
+
+        const tags = Object.assign({}, defaults.tags, point.tags || payload.tags || {});
+
+        const fields = {};
+
+        const measurement = cleanString(point.measurement || payload.measurement || defaults.measurement);
+
+        const timestamp = timestampToPrecision(point.timestamp || payload.timestamp || point.time || payload.time, defaults.precision);
+
+
+        if (isPlainObject(point.fields)) {
+
+            flattenNumericFields(point.fields, "", fields);
+
+        } else if (isPlainObject(payload.fields)) {
+
+            flattenNumericFields(payload.fields, "", fields);
+
+        } else if (isPlainObject(payload)) {
+
+            flattenNumericFields(payload, "", fields);
+
+            delete fields.tags;
+
+            delete fields.fields;
+
+            delete fields.measurement;
+
+            delete fields.timestamp;
+
+            delete fields.time;
+
+        } else if (typeof point.payload === "number" && Number.isFinite(point.payload)) {
+
+            fields.value = point.payload;
+
+        } else if (typeof point.payload === "string" && point.payload.trim() !== "") {
+
+            const parsed = Number(point.payload);
+
+            if (Number.isFinite(parsed)) {
+
+                fields.value = parsed;
+
+            }
+
+        }
+
+
+        if (point.topic && !tags.topic) {
+
+            tags.topic = cleanString(point.topic);
+
+        }
+
+        if (point.meter_id && !tags.meter_id) {
+
+            tags.meter_id = cleanString(point.meter_id);
+
+        }
+
+        if (point.inverter_id && !tags.inverter_id) {
+
+            tags.inverter_id = cleanString(point.inverter_id);
+
+        }
+
+        if (point.battery_id && !tags.battery_id) {
+
+            tags.battery_id = cleanString(point.battery_id);
+
+        }
+
+
+        return {
+
+            measurement: measurement,
+
+            tags: tags,
+
+            fields: fields,
+
+            timestamp: timestamp
+
+        };
+
+    }
+
+
+    function pointToLineProtocol(point) {
+
+        const measurement = escapeMeasurement(point.measurement);
+
+        const tagParts = [];
+
+        const fieldParts = [];
+
+
+        if (!measurement) {
+
+            return "";
+
+        }
+
+
+        Object.keys(point.tags || {}).sort().forEach(function (key) {
+
+            const value = point.tags[key];
+            const tagKey = escapeTag(key);
+
+            if (!tagKey || value === undefined || value === null || value === "") {
+
+                return;
+
+            }
+
+            tagParts.push(tagKey + "=" + escapeTag(value));
+
+        });
+
+
+        Object.keys(point.fields || {}).sort().forEach(function (key) {
+
+            const encoded = fieldValueToLineProtocol(point.fields[key]);
+            const fieldKey = escapeFieldKey(key);
+
+            if (!fieldKey || !encoded) {
+
+                return;
+
+            }
+
+            fieldParts.push(fieldKey + "=" + encoded);
+
+        });
+
+
+        if (!fieldParts.length) {
+
+            return "";
+
+        }
+
+
+        return measurement +
+
+            (tagParts.length ? "," + tagParts.join(",") : "") +
+
+            " " +
+
+            fieldParts.join(",") +
+
+            (point.timestamp ? " " + point.timestamp : "");
+
+    }
+
+
+    function findUnescapedSpace(value) {
+
+        for (let i = 0; i < value.length; i += 1) {
+
+            if (value.charAt(i) === " " && value.charAt(i - 1) !== "\\") {
+
+                return i;
+
+            }
+
+        }
+
+        return -1;
+
+    }
+
+
+    function splitLineProtocol(line) {
+
+        const firstSpace = findUnescapedSpace(line);
+
+        if (firstSpace < 0) {
+
+            return {
+                seriesKey: line,
+                fieldsKey: ""
+            };
+
+        }
+
+        const rest = line.slice(firstSpace + 1);
+        const secondSpace = findUnescapedSpace(rest);
+
+        return {
+            seriesKey: line.slice(0, firstSpace),
+            fieldsKey: secondSpace < 0 ? rest : rest.slice(0, secondSpace)
+        };
+
+    }
+
+
+    function extractPoints(msg, defaults) {
+
+        const source = (msg.influx === true || msg.influxdb === true)
+
+            ? msg
+
+            : (msg.influx || msg.influxdb || (isPlainObject(msg.payload) && (msg.payload.influx || msg.payload.influxdb)) || msg.payload);
+
+        const candidates = Array.isArray(source)
+
+            ? source
+
+            : (source && Array.isArray(source.points) ? source.points : [source]);
+
+
+        return candidates
+
+            .map(function (candidate) {
+
+                if (candidate === msg.payload && !isPlainObject(candidate)) {
+
+                    return normalizePoint(msg, defaults);
+
+                }
+
+                return normalizePoint(candidate, defaults);
+
+            })
+
+            .map(pointToLineProtocol)
+
+            .filter(Boolean);
+
+    }
+
+
+    function buildWriteEndpoint(connection) {
+
+        let endpoint;
+
+        try {
+
+            endpoint = new URL(connection.url);
+
+        } catch (err) {
+
+            throw new Error("URL InfluxDB invalid");
+
+        }
+
+        endpoint.pathname = endpoint.pathname.replace(/\/$/, "") + "/api/v2/write";
+        endpoint.searchParams.set("org", connection.org);
+        endpoint.searchParams.set("bucket", connection.bucket);
+        endpoint.searchParams.set("precision", normalizePrecision(connection.precision));
+
+        return endpoint;
+
+    }
+
+
+    function writeInfluxLines(connection, lines) {
+
+        return new Promise(function (resolve, reject) {
+
+            if (!connection.url || !connection.org || !connection.bucket || !connection.token) {
+
+                reject(new Error("config incompleta"));
+
+                return;
+
+            }
+
+            let endpoint;
+
+            try {
+
+                endpoint = buildWriteEndpoint(connection);
+
+            } catch (err) {
+
+                reject(err);
+
+                return;
+
+            }
+
+            const body = lines.join("\n");
+
+            const transport = endpoint.protocol === "https:" ? https : http;
+
+            const request = transport.request(endpoint, {
+
+                method: "POST",
+
+                headers: {
+
+                    "Authorization": "Token " + connection.token,
+
+                    "Content-Type": "text/plain; charset=utf-8",
+
+                    "Content-Length": Buffer.byteLength(body)
+
+                }
+
+            }, function (response) {
+
+                const chunks = [];
+
+                response.on("data", function (chunk) {
+
+                    chunks.push(chunk);
+
+                });
+
+                response.on("end", function () {
+
+                    const responseBody = Buffer.concat(chunks).toString("utf8");
+
+                    if (response.statusCode >= 200 && response.statusCode < 300) {
+
+                        resolve({
+                            statusCode: response.statusCode,
+                            body: responseBody
+                        });
+
+                        return;
+
+                    }
+
+                    reject(new Error("InfluxDB HTTP " + response.statusCode + (responseBody ? ": " + responseBody : "")));
+
+                });
+
+            });
+
+            request.on("error", reject);
+            request.setTimeout(positiveInteger(connection.requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS), function () {
+                request.destroy(new Error("timeout InfluxDB write"));
+            });
+            request.write(body);
+            request.end();
+
+        });
+
+    }
+
+
+    function getNodeConnection(node) {
+
+        return {
+            url: node.url,
+            org: node.org,
+            bucket: node.bucket,
+            precision: node.precision,
+            token: node.token,
+            requestTimeoutMs: node.requestTimeoutMs
+        };
+
+    }
+
+
+    function buildLogLine(connection, event, fields, extraTags) {
+
+        return pointToLineProtocol({
+            measurement: "Logs",
+            tags: Object.assign({
+                source: "node_red",
+                node_type: "adt-influxdb",
+                event: cleanString(event) || "unknown"
+            }, extraTags || {}),
+            fields: fields,
+            timestamp: timestampToPrecision(Date.now(), connection.precision)
+        });
+
+    }
+
+
+    async function writeLogPoint(connection, event, fields, extraTags) {
+
+        const line = buildLogLine(connection, event, fields, extraTags);
+
+        if (!line) {
+
+            return null;
+
+        }
+
+        return writeInfluxLines(connection, [line]);
+
+    }
+
+
+    function nodeToken(node) {
+
+        return cleanString((node && node.token) || (node && node.credentials && node.credentials.token));
+
+    }
+
+
+    function resolveTestConnection(body) {
+
+        const serverId = cleanString(body.server);
+        const nodeId = cleanString(body.nodeId || body.id);
+        const deployedNode = nodeId ? RED.nodes.getNode(nodeId) : null;
+        const serverNode = (serverId ? RED.nodes.getNode(serverId) : null) || (deployedNode && deployedNode.server);
+        const bucket = cleanString(body.bucket || (deployedNode && deployedNode.bucket));
+
+        if (serverNode) {
+
+            return {
+                url: cleanString(serverNode.url),
+                org: cleanString(serverNode.org),
+                bucket: bucket,
+                precision: normalizePrecision(body.precision || (deployedNode && deployedNode.precision)),
+                token: nodeToken(serverNode),
+                requestTimeoutMs: positiveInteger(body.requestTimeoutMs || (deployedNode && deployedNode.requestTimeoutMs), DEFAULT_REQUEST_TIMEOUT_MS)
+            };
+
+        }
+
+        if (deployedNode) {
+
+            return {
+                url: cleanString(body.url || deployedNode.url),
+                org: cleanString(body.org || deployedNode.org),
+                bucket: bucket,
+                precision: normalizePrecision(body.precision || deployedNode.precision),
+                token: nodeToken(deployedNode),
+                requestTimeoutMs: positiveInteger(body.requestTimeoutMs || deployedNode.requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS)
+            };
+
+        }
+
+        return {
+            url: cleanString(body.url),
+            org: cleanString(body.org),
+            bucket: bucket,
+            precision: normalizePrecision(body.precision),
+            token: cleanString(body.token),
+            requestTimeoutMs: positiveInteger(body.requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS)
+        };
+
+    }
+
+
+    RED.httpAdmin.post("/adt-influxdb/test", async function (req, res) {
+
+        const body = req && req.body && typeof req.body === "object" ? req.body : {};
+        const connection = resolveTestConnection(body);
+
+        try {
+
+            const result = await writeLogPoint(connection, "connection_test", {
+                connection_test: 1,
+                connection_error: 0
+            }, {
+                test: "manual",
+                bucket: connection.bucket || ""
+            });
+
+            res.json({
+                ok: true,
+                statusCode: result.statusCode,
+                bucket: connection.bucket,
+                measurement: "Logs",
+                precision: connection.precision
+            });
+
+        } catch (err) {
+
+            res.json({
+                ok: false,
+                error: err && err.message ? err.message : String(err || "Eroare necunoscuta")
+            });
+
+        }
+
+    });
+
+
+    function InfluxDbServerNode(config) {
+
+        RED.nodes.createNode(this, config);
+
+        const node = this;
+
+        node.name = cleanString(config.name);
+
+        node.url = cleanString(config.url);
+
+        node.org = cleanString(config.org);
+
+        node.token = cleanString(node.credentials && node.credentials.token);
+
+    }
+
+
+    function InfluxDbNode(config) {
+
+        RED.nodes.createNode(this, config);
+
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+
+        node.name = cleanString(config.name);
+
+        node.server = RED.nodes.getNode(config.server);
+
+        node.url = node.server ? cleanString(node.server.url) : cleanString(config.url);
+
+        node.org = node.server ? cleanString(node.server.org) : cleanString(config.org);
+
+        node.bucket = cleanString(config.bucket);
+
+        node.measurement = cleanString(config.measurement || "dispozitiv");
+
+        node.precision = normalizePrecision(config.precision);
+
+        node.staticTags = parseTags(config.staticTags);
+
+        node.batchSize = positiveIntegerWithLegacyDefault(config.batchSize, DEFAULT_BATCH_SIZE, [1]);
+
+        node.flushIntervalMs = positiveInteger(config.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS);
+
+        node.maxQueueSize = positiveInteger(config.maxQueueSize, DEFAULT_MAX_QUEUE_SIZE);
+
+        node.requestTimeoutMs = positiveInteger(config.requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS);
+
+        node.retryBaseMs = positiveInteger(config.retryBaseMs, DEFAULT_RETRY_BASE_MS);
+
+        node.retryMaxMs = positiveInteger(config.retryMaxMs, DEFAULT_RETRY_MAX_MS);
+
+        node.minWriteIntervalMs = nonNegativeInteger(config.minWriteIntervalMs, DEFAULT_MIN_WRITE_INTERVAL_MS);
+
+        node.heartbeatMs = nonNegativeInteger(config.heartbeatMs, DEFAULT_HEARTBEAT_MS);
+
+        node.dropPolicy = normalizeDropPolicy(config.dropPolicy);
+
+        node.errorLogMaxRepeats = positiveInteger(config.errorLogMaxRepeats, DEFAULT_ERROR_LOG_MAX_REPEATS);
+
+        node.errorLogWindowMs = positiveInteger(config.errorLogWindowMs, DEFAULT_ERROR_LOG_WINDOW_MS);
+
+        node.errorLogMuteMs = positiveInteger(config.errorLogMuteMs, DEFAULT_ERROR_LOG_MUTE_MS);
+
+        node.debugMode = !!config.debugMode;
+
+        node.statusOutput = !!config.statusOutput || !!config.debugMode;
+
+        node.includeTopicTag = config.includeTopicTag !== false;
+
+
+        node.token = node.server ? cleanString(node.server.token) : cleanString(node.credentials && node.credentials.token);
+
+        const queue = [];
+        const seriesState = new Map();
+        const errorLogState = new Map();
+
+        let timer = null;
+        let retryTimer = null;
+
+        let flushing = false;
+
+        let closed = false;
+        let retryAttempt = 0;
+        let totalDropped = 0;
+        let totalThrottled = 0;
+        let lastHttpError = "";
+        let hasActiveErrorLogState = false;
+
+
+        function writeLines(lines) {
+            return writeInfluxLines(getNodeConnection(node), lines);
+
+        }
+
+
+        function statusText(text) {
+
+            const suffix = node.debugMode
+                ? " | q " + queue.length + " | drop " + totalDropped + " | skip " + totalThrottled + (retryAttempt ? " | retry " + retryAttempt : "")
+                : "";
+
+            return text + suffix;
+
+        }
+
+
+        function emitStatus(event, payload) {
+
+            if (!node.statusOutput) {
+                return;
+            }
+
+            node.send({
+                topic: "influxdb/" + event,
+                payload: Object.assign({
+                    event: event,
+                    node: node.name || "adt-influxdb",
+                    bucket: node.bucket,
+                    measurement: node.measurement,
+                    precision: node.precision,
+                    queue_length: queue.length,
+                    retry_attempt: retryAttempt,
+                    dropped_total: totalDropped,
+                    throttled_total: totalThrottled,
+                    drop_policy: node.dropPolicy,
+                    last_error: lastHttpError || null,
+                    timestamp: new Date().toISOString()
+                }, payload || {})
+            });
+
+        }
+
+
+        function errorLogKey(event, extraTags) {
+
+            const tags = extraTags || {};
+
+            return [
+                sanitizeKey(event || "state"),
+                sanitizeKey(tags.reason || "unknown"),
+                sanitizeKey(tags.error_class || "")
+            ].join("|");
+
+        }
+
+
+        function writeNodeLog(event, fields, extraTags) {
+
+            writeLogPoint(getNodeConnection(node), event, fields, Object.assign({
+                node: node.name || "adt-influxdb",
+                bucket: node.bucket || "",
+                measurement: node.measurement || ""
+            }, extraTags || {})).catch(function () {
+                // Log writes are best-effort to avoid recursive error storms.
+            });
+
+        }
+
+
+        function logState(event, fields, extraTags) {
+
+            const logFields = Object.assign({}, fields || {});
+            const tags = extraTags || {};
+            const isError = Number(logFields.error) === 1;
+
+            if (!isError) {
+
+                if (!hasActiveErrorLogState && !errorLogState.size) {
+                    return;
+                }
+
+                errorLogState.clear();
+                hasActiveErrorLogState = false;
+                logFields.error = 0;
+                logFields.recovered = 1;
+                logFields.muted = 0;
+                logFields.suppressed_count = 0;
+                writeNodeLog(event, logFields, tags);
+                return;
+
+            }
+
+            hasActiveErrorLogState = true;
+
+            const nowMs = Date.now();
+            const key = errorLogKey(event, tags);
+            const state = errorLogState.get(key) || {
+                count: 0,
+                windowStartMs: nowMs,
+                mutedUntilMs: 0,
+                suppressedCount: 0
+            };
+
+            if (state.mutedUntilMs > nowMs) {
+
+                state.suppressedCount += 1;
+                errorLogState.set(key, state);
+                return;
+
+            }
+
+            if (nowMs - state.windowStartMs > node.errorLogWindowMs) {
+
+                state.count = 0;
+                state.windowStartMs = nowMs;
+                state.suppressedCount = 0;
+                state.mutedUntilMs = 0;
+
+            }
+
+            state.count += 1;
+
+            if (state.count > node.errorLogMaxRepeats) {
+
+                state.suppressedCount += 1;
+                state.mutedUntilMs = nowMs + node.errorLogMuteMs;
+                logFields.muted = 1;
+                logFields.suppressed_count = state.suppressedCount;
+                errorLogState.set(key, state);
+                writeNodeLog(event, logFields, Object.assign({
+                    muted_reason: "repeated_error"
+                }, tags));
+                state.suppressedCount = 0;
+                return;
+
+            }
+
+            logFields.muted = 0;
+            logFields.suppressed_count = 0;
+            errorLogState.set(key, state);
+            writeNodeLog(event, logFields, tags);
+
+        }
+
+
+        function clearRetryTimer() {
+
+            if (retryTimer) {
+                clearTimeout(retryTimer);
+                retryTimer = null;
+            }
+
+        }
+
+
+        function trimQueueToLimit() {
+
+            if (queue.length <= node.maxQueueSize) {
+                return 0;
+            }
+
+            const overflow = queue.length - node.maxQueueSize;
+
+            if (node.dropPolicy === "drop_newest") {
+
+                queue.splice(node.maxQueueSize, overflow);
+
+            } else {
+
+                queue.splice(0, overflow);
+
+            }
+
+            totalDropped += overflow;
+            return overflow;
+
+        }
+
+
+        function filterRepeatedLines(lines, nowMs) {
+
+            const accepted = [];
+            let skippedInterval = 0;
+            let skippedHeartbeat = 0;
+
+            lines.forEach(function (line) {
+
+                const parsed = splitLineProtocol(line);
+                const seriesKey = parsed.seriesKey;
+                const fieldsKey = parsed.fieldsKey;
+                const previous = seriesState.get(seriesKey);
+
+                if (previous) {
+
+                    const elapsedMs = nowMs - previous.writtenAtMs;
+                    const changed = previous.fieldsKey !== fieldsKey;
+
+                    if (changed && node.minWriteIntervalMs > 0 && elapsedMs < node.minWriteIntervalMs) {
+
+                        skippedInterval += 1;
+                        return;
+
+                    }
+
+                    if (!changed) {
+
+                        const holdMs = node.heartbeatMs > 0 ? node.heartbeatMs : node.minWriteIntervalMs;
+
+                        if (holdMs > 0 && elapsedMs < holdMs) {
+
+                            skippedHeartbeat += 1;
+                            return;
+
+                        }
+
+                    }
+
+                }
+
+                seriesState.set(seriesKey, {
+                    fieldsKey: fieldsKey,
+                    writtenAtMs: nowMs
+                });
+                accepted.push(line);
+
+            });
+
+            const skipped = skippedInterval + skippedHeartbeat;
+            totalThrottled += skipped;
+
+            return {
+                lines: accepted,
+                skipped: skipped,
+                skippedInterval: skippedInterval,
+                skippedHeartbeat: skippedHeartbeat
+            };
+
+        }
+
+
+        function scheduleRetry() {
+
+            if (closed || retryTimer) {
+                return;
+            }
+
+            const waitMs = Math.min(node.retryBaseMs * Math.pow(2, retryAttempt), node.retryMaxMs);
+            retryTimer = setTimeout(function () {
+                retryTimer = null;
+                flushQueue("retry");
+            }, waitMs);
+
+        }
+
+
+        async function flushQueue(reason, options) {
+            const opts = options || {};
+            const allowClosed = !!opts.allowClosed;
+
+            if (flushing || !queue.length || (closed && !allowClosed)) {
+
+                return;
+
+            }
+
+
+            if (!node.url || !node.org || !node.bucket || !node.token) {
+
+                lastHttpError = "config incompleta";
+                node.status({ fill: "red", shape: "ring", text: statusText("config incompleta") });
+                logState("config_error", {
+                    error: 1,
+                    write_error: 0,
+                    config_error: 1
+                }, {
+                    reason: "config_incomplete"
+                });
+                emitStatus("error", {
+                    error: lastHttpError,
+                    reason: reason || ""
+                });
+
+                return;
+
+            }
+
+
+            flushing = true;
+
+
+            const batch = queue.splice(0, node.batchSize);
+
+
+            try {
+
+                const result = await writeLines(batch);
+                retryAttempt = 0;
+                lastHttpError = "";
+                clearRetryTimer();
+                logState("write_ok", {
+                    error: 0,
+                    write_error: 0,
+                    config_error: 0
+                }, {
+                    reason: reason || "write"
+                });
+
+                node.status({
+
+                    fill: "green",
+
+                    shape: "dot",
+
+                    text: statusText(String(batch.length) + " puncte trimise" + (reason ? " (" + reason + ")" : ""))
+
+                });
+                emitStatus("write", {
+                    reason: reason || "",
+                    points: batch.length,
+                    http_status: result && result.statusCode ? result.statusCode : null
+                });
+
+            } catch (err) {
+
+                Array.prototype.unshift.apply(queue, batch);
+                const dropped = trimQueueToLimit();
+                retryAttempt += 1;
+                scheduleRetry();
+                lastHttpError = err.message;
+
+                node.status({ fill: "red", shape: "ring", text: statusText(err.message) });
+                logState("write_error", {
+                    error: 1,
+                    write_error: 1,
+                    config_error: 0
+                }, {
+                    reason: reason || "write",
+                    error_class: sanitizeKey(err && err.code ? err.code : "http_or_network")
+                });
+                emitStatus("error", {
+                    reason: reason || "",
+                    error: err.message,
+                    dropped: dropped
+                });
+
+                node.error(err.message);
+
+            } finally {
+
+                flushing = false;
+
+            }
+
+        }
+
+        async function drainQueue(reason) {
+            let previousLength = -1;
+
+            while (flushing) {
+                await new Promise(function (resolve) {
+                    setTimeout(resolve, 25);
+                });
+            }
+
+            while (queue.length && queue.length !== previousLength) {
+                previousLength = queue.length;
+                await flushQueue(reason, { allowClosed: true });
+
+                while (flushing) {
+                    await new Promise(function (resolve) {
+                        setTimeout(resolve, 25);
+                    });
+                }
+            }
+        }
+
+
+        timer = setInterval(function () {
+
+            flushQueue("timer");
+
+        }, node.flushIntervalMs);
+
+
+        node.on("input", function (msg, send, done) {
+
+            done = typeof done === "function" ? done : function () {};
+
+            try {
+
+                const defaults = {
+
+                    measurement: node.measurement,
+
+                    tags: Object.assign({}, node.staticTags),
+
+                    precision: node.precision
+
+                };
+
+
+                if (node.includeTopicTag && msg.topic && !defaults.tags.topic) {
+
+                    defaults.tags.topic = cleanString(msg.topic);
+
+                }
+
+
+                const rawLines = extractPoints(msg, defaults);
+
+
+                if (!rawLines.length) {
+
+                    node.status({ fill: "yellow", shape: "ring", text: statusText("fara campuri numerice") });
+                    emitStatus("empty", {
+                        reason: "no_numeric_fields"
+                    });
+
+                    done();
+
+                    return;
+
+                }
+
+
+                const filtered = filterRepeatedLines(rawLines, Date.now());
+                const lines = filtered.lines;
+
+                if (!lines.length) {
+
+                    node.status({ fill: "grey", shape: "ring", text: statusText("scriere amanata") });
+                    emitStatus("throttle", {
+                        skipped: filtered.skipped,
+                        skipped_interval: filtered.skippedInterval,
+                        skipped_heartbeat: filtered.skippedHeartbeat,
+                        min_write_interval_ms: node.minWriteIntervalMs,
+                        heartbeat_ms: node.heartbeatMs
+                    });
+
+                    done();
+
+                    return;
+
+                }
+
+
+                Array.prototype.push.apply(queue, lines);
+                if (filtered.skipped > 0) {
+                    emitStatus("throttle", {
+                        skipped: filtered.skipped,
+                        skipped_interval: filtered.skippedInterval,
+                        skipped_heartbeat: filtered.skippedHeartbeat,
+                        accepted: lines.length,
+                        min_write_interval_ms: node.minWriteIntervalMs,
+                        heartbeat_ms: node.heartbeatMs
+                    });
+                }
+                const dropped = trimQueueToLimit();
+                if (dropped > 0) {
+                    node.warn("Coada InfluxDB a depasit limita, au fost eliminate " + dropped + " puncte vechi.");
+                    emitStatus("drop", {
+                        dropped: dropped
+                    });
+                }
+
+                node.status({ fill: "blue", shape: "dot", text: statusText(String(queue.length) + " in queue") });
+
+
+                if (queue.length >= node.batchSize || msg.flush === true || (msg.payload && msg.payload.flush === true)) {
+
+                    flushQueue("batch").then(function () {
+
+                        done();
+
+                    }).catch(done);
+
+                    return;
+
+                }
+
+
+                done();
+
+            } catch (err) {
+
+                node.status({ fill: "red", shape: "ring", text: err.message });
+
+                done(err);
+
+            }
+
+        });
+
+
+        node.on("close", function (removed, done) {
+
+            closed = true;
+
+            if (timer) {
+
+                clearInterval(timer);
+
+                timer = null;
+
+            }
+            clearRetryTimer();
+            drainQueue("close").finally(function () {
+                done();
+            });
+
+        });
+
+    
+        });
+    }
+
+
+    RED.nodes.registerType("adt-influxdb-server", InfluxDbServerNode, {
+
+        credentials: {
+
+            token: { type: "password" }
+
+        }
+
+    });
+
+
+    RED.nodes.registerType("adt-influxdb", InfluxDbNode, {
+
+        credentials: {
+
+            token: { type: "password" }
+
+        }
+
+    });
+
+};
+