node-red-contrib-questdb 0.6.22 → 0.6.24

package/nodes/questdb-value.js

@@ -110,14 +110,30 @@ module.exports = function (RED) {
     }
 
     node.on('input', async function (msg) {
-      // Connection checks
+      // Connection checks (rate-limit error logging to once per 5s)
       if (!connection.connected && !connection.connecting) {
         connection.connect();
-        sendError(msg, 'Not connected to QuestDB, reconnecting...');
+        var now = Date.now();
+        if (now - connection.lastNotConnectedLog > 5000) {
+          connection.lastNotConnectedLog = now;
+          sendError(msg, 'Not connected to QuestDB, reconnecting...');
+        } else {
+          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) {
-        sendError(msg, 'Not connected to QuestDB');
+        var now2 = Date.now();
+        if (now2 - connection.lastNotConnectedLog > 5000) {
+          connection.lastNotConnectedLog = now2;
+          sendError(msg, '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;
       }
       if (
@@ -213,6 +229,25 @@ module.exports = function (RED) {
           connection.sender.at(timestampMicros);
         }
 
+        // 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) {
+            var 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(msg, flushErrMsg);
+            return;
+          }
+        }
+
         var label = type + ': ' + String(castedValue);
         if (label.length > 25) label = label.substring(0, 25) + '...';
         node.status({ fill: 'green', shape: 'dot', text: tableName + ' ' + label });

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) {
@@ -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;
@@ -310,15 +336,32 @@ module.exports = function (RED) {
         node.send([null, errMsg]);
       }
 
-      // Auto-reconnect if disconnected
+      // Auto-reconnect if disconnected (rate-limit error logging to once per 5s)
       if (!connection.connected && !connection.connecting) {
         connection.connect();
-        sendError('Not connected to QuestDB, reconnecting...');
+        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) {
-        sendError('Not connected to QuestDB');
+        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;
       }
 
@@ -485,19 +528,7 @@ module.exports = function (RED) {
               } else if (typeof value === 'boolean') {
                 connection.sender.booleanColumn(key, value);
               } else if (typeof value === 'string') {
-                // Check if it's an ISO date string
-                if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
-                  const dateValue = new Date(value);
-                  if (!isNaN(dateValue.getTime())) {
-                    // Convert to microseconds for QuestDB
-                    const microSeconds = BigInt(dateValue.getTime()) * 1000n;
-                    connection.sender.timestampColumn(key, microSeconds);
-                  } else {
-                    connection.sender.stringColumn(key, value);
-                  }
-                } else {
-                  connection.sender.stringColumn(key, value);
-                }
+                connection.sender.stringColumn(key, value);
               } else if (value instanceof Date) {
                 // Convert to microseconds for QuestDB
                 const microSeconds = BigInt(value.getTime()) * 1000n;
@@ -540,6 +571,25 @@ module.exports = function (RED) {
           }
         }
 
+        // 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, null]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-questdb",
-  "version": "0.6.22",
+  "version": "0.6.24",
   "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"