node-red-contrib-questdb 0.6.9 → 0.6.23

package/nodes/questdb.js

@@ -31,17 +31,9 @@ module.exports = function (RED) {
       }
     }
 
-    // Auto-flush options
-    if (configNode.autoFlush === false) {
-      connStr += `auto_flush=off;`;
-    } else {
-      if (configNode.autoFlushRows) {
-        connStr += `auto_flush_rows=${configNode.autoFlushRows};`;
-      }
-      if (configNode.autoFlushInterval) {
-        connStr += `auto_flush_interval=${configNode.autoFlushInterval};`;
-      }
-    }
+    // Always disable sender's built-in auto-flush to prevent uncaught exceptions.
+    // We run our own flush timer with error handling in the connection state.
+    connStr += `auto_flush=off;`;
 
     // Buffer options
     if (configNode.initBufSize) {
@@ -89,7 +81,7 @@ module.exports = function (RED) {
 
     // Auto-flush settings
     configNode.autoFlush = config.autoFlush !== false;
-    configNode.autoFlushRows = parseInt(config.autoFlushRows) || 75000;
+    configNode.autoFlushRows = parseInt(config.autoFlushRows) || 500;
     configNode.autoFlushInterval = parseInt(config.autoFlushInterval) || 1000;
 
     // Buffer settings
@@ -110,8 +102,11 @@ module.exports = function (RED) {
         connecting: false,
         users: 0,
         reconnectTimer: null,
+        flushTimer: null,
+        rowCount: 0,
         emitter: new EventEmitter(),
         lastError: null,
+        lastNotConnectedLog: 0,
 
         // Method to update state and emit event
         updateState: function (newStatus, error = null) {
@@ -171,6 +166,32 @@ module.exports = function (RED) {
 
           connectionState.updateState(true);
 
+          // Start managed flush timer (replaces sender's built-in auto-flush)
+          if (connectionState.flushTimer) {
+            clearInterval(connectionState.flushTimer);
+          }
+          const flushInterval = configNode.autoFlushInterval || 1000;
+          connectionState.flushTimer = setInterval(async () => {
+            if (!connectionState.connected || !connectionState.sender) return;
+            if (connectionState.rowCount === 0) return;
+            try {
+              await connectionState.sender.flush();
+              connectionState.rowCount = 0;
+            } catch (flushErr) {
+              const flushErrMsg = formatError(flushErr, { operation: 'auto-flush' });
+              RED.log.error(`[QuestDB] Flush failed: ${flushErrMsg}`);
+              connectionState.emitter.emit('flushError', flushErr);
+              if (isDisconnectionError(flushErr)) {
+                connectionState.updateState(false, flushErr.message);
+                connectionState.sender = null;
+                connectionState.connect();
+              }
+            }
+          }, flushInterval);
+
+          // Also flush when row count threshold is reached
+          connectionState.flushRows = configNode.autoFlushRows || 500;
+
           RED.log.info(
             `[QuestDB] Connected to ${configNode.protocol}://${configNode.host}:${configNode.port}`
           );
@@ -196,6 +217,11 @@ module.exports = function (RED) {
       };
 
       connectionState.disconnect = async function () {
+        if (connectionState.flushTimer) {
+          clearInterval(connectionState.flushTimer);
+          connectionState.flushTimer = null;
+        }
+
         if (connectionState.reconnectTimer) {
           clearTimeout(connectionState.reconnectTimer);
           connectionState.reconnectTimer = null;
@@ -255,10 +281,6 @@ module.exports = function (RED) {
       return;
     }
 
-    // Configuration from the node properties
-    node.autoFlush = config.autoFlush !== false; // default true
-    node.flushInterval = config.flushInterval || 1000;
-
     // Get shared connection
     const connection = node.questdbConfig.getConnection();
     if (!connection) {
@@ -306,15 +328,40 @@ module.exports = function (RED) {
     stateChangeHandler({ status: initialStatus, error: connection.lastError });
 
     node.on('input', async function (msg) {
-      // Auto-reconnect if disconnected
+      function sendError(errorText) {
+        node.error(errorText, msg);
+        node.status({ fill: 'red', shape: 'ring', text: errorText.substring(0, 30) });
+        var errMsg = RED.util.cloneMessage(msg);
+        errMsg.payload = { success: false, error: errorText };
+        node.send([null, errMsg]);
+      }
+
+      // Auto-reconnect if disconnected (rate-limit error logging to once per 5s)
       if (!connection.connected && !connection.connecting) {
         connection.connect();
-        node.error('Not connected to QuestDB, reconnecting...', msg);
+        var now = Date.now();
+        if (now - connection.lastNotConnectedLog > 5000) {
+          connection.lastNotConnectedLog = now;
+          sendError('Not connected to QuestDB, reconnecting...');
+        } else {
+          // Still send to error output but don't log
+          var errMsg = RED.util.cloneMessage(msg);
+          errMsg.payload = { success: false, error: 'Not connected to QuestDB, reconnecting...' };
+          node.send([null, errMsg]);
+        }
         return;
       }
 
       if (!connection.connected || !connection.sender) {
-        node.error('Not connected to QuestDB', msg);
+        var now2 = Date.now();
+        if (now2 - connection.lastNotConnectedLog > 5000) {
+          connection.lastNotConnectedLog = now2;
+          sendError('Not connected to QuestDB');
+        } else {
+          var errMsg2 = RED.util.cloneMessage(msg);
+          errMsg2.payload = { success: false, error: 'Not connected to QuestDB' };
+          node.send([null, errMsg2]);
+        }
         return;
       }
 
@@ -326,22 +373,21 @@ module.exports = function (RED) {
       ) {
         connection.updateState(false);
         connection.connect();
-        node.error('TCP transport disconnected, reconnecting...', msg);
+        sendError('TCP transport disconnected, reconnecting...');
         return;
       }
 
-      // Validate message
+      // Validate table name
       const tableName = msg.topic;
-      if (!tableName) {
-        node.error(formatError('Topic (table name) not specified', { operation: 'validate' }), msg);
-        node.status({ fill: 'red', shape: 'ring', text: 'no topic' });
+      if (!tableName || typeof tableName !== 'string' || !tableName.trim()) {
+        sendError('Table name (msg.topic) is missing or empty');
         return;
       }
 
+      // Validate payload
       const payload = msg.payload;
       if (payload === undefined || payload === null) {
-        node.error(formatError('Payload is empty', { operation: 'validate' }), msg);
-        node.status({ fill: 'red', shape: 'ring', text: 'no payload' });
+        sendError('Payload is null or undefined');
         return;
       }
 
@@ -503,15 +549,8 @@ module.exports = function (RED) {
                 node.warn(`Skipping unsupported type '${typeof value}' for column '${key}'`);
               }
             }
-          } else if (!payload.symbols) {
-            node.error(
-              formatError(
-                "Payload must have 'symbols' and/or 'columns' properties, or be a number",
-                { operation: 'validate', table: tableName }
-              ),
-              msg
-            );
-            node.status({ fill: 'red', shape: 'ring', text: 'bad format' });
+          } else if (!payload.symbols && !payload.columns) {
+            sendError("Payload must have 'symbols' and/or 'columns' properties, or be a number");
             return;
           }
 
@@ -544,13 +583,28 @@ module.exports = function (RED) {
           }
         }
 
-        if (node.autoFlush) {
-          await connection.sender.flush();
+        // Track rows and flush at threshold
+        connection.rowCount++;
+        if (connection.flushRows && connection.rowCount >= connection.flushRows) {
+          try {
+            await connection.sender.flush();
+            connection.rowCount = 0;
+          } catch (flushErr) {
+            const flushErrMsg = formatError(flushErr, { operation: 'flush', table: tableName });
+            RED.log.error(`[QuestDB] Flush failed: ${flushErrMsg}`);
+            if (isDisconnectionError(flushErr)) {
+              connection.updateState(false, flushErr.message);
+              connection.sender = null;
+              connection.connect();
+            }
+            sendError(flushErrMsg);
+            return;
+          }
         }
 
         node.status({ fill: 'green', shape: 'dot', text: `sent: ${tableName}` });
         msg.payload = { success: true, table: tableName };
-        node.send(msg);
+        node.send([msg, null]);
       } catch (err) {
         const errMsg = formatError(err, { operation: 'write', table: tableName });
 
@@ -575,8 +629,7 @@ module.exports = function (RED) {
           }
         }
 
-        msg.payload = { success: false, error: errMsg };
-        node.send(msg);
+        sendError(errMsg);
         return; // Early return after error handling
       }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-questdb",
-  "version": "0.6.9",
+  "version": "0.6.23",
   "description": "Node-RED nodes for writing high-performance time-series data to QuestDB using Influx Line Protocol (ILP). Supports IoT, industrial monitoring, smart buildings, fleet telematics, healthcare, agriculture, and more.",
   "author": {
     "name": "Holger Amort"
@@ -50,7 +50,9 @@
     "nodes": {
       "questdb": "nodes/questdb.js",
       "questdb-mapper": "nodes/questdb-mapper.js",
-      "questdb-type-router": "nodes/questdb-type-router.js"
+      "questdb-type-router": "nodes/questdb-type-router.js",
+      "questdb-flatten": "nodes/questdb-flatten.js",
+      "questdb-value": "nodes/questdb-value.js"
     }
   },
   "engines": {