@node-red/runtime 4.0.9 → 4.1.0-beta.2

package/lib/api/context.js

@@ -241,7 +241,11 @@ var api = module.exports = {
             } else if (scope === 'node') {
                 var node = runtime.nodes.getNode(id);
                 if (node) {
-                    ctx = node.context();
+                    if (/^subflow:/.test(node.type)) {
+                        ctx = runtime.nodes.getContext(node.id);
+                    } else {
+                        ctx = node.context();
+                    }
                 }
             }
             if (ctx) {

package/lib/api/settings.js

@@ -161,6 +161,8 @@ var api = module.exports = {
                 safeSettings.diagnostics.ui = false; // cannot have UI without endpoint
             }
 
+            safeSettings.telemetryEnabled = runtime.telemetry.isEnabled()
+
             safeSettings.runtimeState = {
                 //unless runtimeState.ui and runtimeState.enabled are explicitly true, they will default to false.
                 enabled: !!runtime.settings.runtimeState && runtime.settings.runtimeState.enabled === true,
@@ -213,7 +215,19 @@ var api = module.exports = {
         }
         var currentSettings = runtime.settings.getUserSettings(username)||{};
         currentSettings = extend(currentSettings, opts.settings);
+
         try {
+            if (currentSettings.hasOwnProperty("telemetryEnabled")) {
+                // This is a global setting that is being set by the user. It should
+                // not be stored per-user as it applies to the whole runtime.
+                const telemetryEnabled = currentSettings.telemetryEnabled;
+                delete currentSettings.telemetryEnabled;
+                if (telemetryEnabled) {
+                    runtime.telemetry.enable()
+                } else {
+                    runtime.telemetry.disable()
+                }
+            }
             return runtime.settings.setUserSettings(username, currentSettings).then(function() {
                 runtime.log.audit({event: "settings.update",username:username}, opts.req);
                 return;

package/lib/flows/Flow.js

@@ -675,6 +675,9 @@ class Flow {
                         count: count
                     }
                 };
+                if (logMessage.hasOwnProperty('code')) {
+                    errorMessage.error.code = logMessage.code;
+                }
                 if (logMessage.hasOwnProperty('stack')) {
                     errorMessage.error.stack = logMessage.stack;
                 }

package/lib/index.js

@@ -23,6 +23,7 @@ var library = require("./library");
 var plugins = require("./plugins");
 var settings = require("./settings");
 const multiplayer = require("./multiplayer");
+const telemetry = require("./telemetry");
 
 var express = require("express");
 var path = require('path');
@@ -135,6 +136,7 @@ function start() {
     return i18n.registerMessageCatalog("runtime",path.resolve(path.join(__dirname,"..","locales")),"runtime.json")
         .then(function() { return storage.init(runtime)})
         .then(function() { return settings.load(storage)})
+        .then(function() { return telemetry.init(runtime)})
         .then(function() { return library.init(runtime)})
         .then(function() { return multiplayer.init(runtime)})
         .then(function() {
@@ -235,8 +237,12 @@ function start() {
                     }
                 }
                 return redNodes.loadContextsPlugin().then(function () {
-                    redNodes.loadFlows().then(() => { redNodes.startFlows() }).catch(function(err) {});
                     started = true;
+                    redNodes.loadFlows().then(() => {
+                        if (started) {
+                            redNodes.startFlows()
+                        }
+                    }).catch(function(err) {});
                 });
             });
         });
@@ -337,6 +343,7 @@ var runtime = {
     library: library,
     exec: exec,
     util: util,
+    telemetry: telemetry,
     get adminApi() { return adminApi },
     get adminApp() { return adminApp },
     get nodeApp() { return nodeApp },

package/lib/storage/localfilesystem/library.js

@@ -135,7 +135,7 @@ function getLibraryEntry(type,path) {
                 throw err;
             });
         } else {
-            throw err;
+            throw new Error(`Library Entry not found ${path}`, { cause: err});
         }
     });
 }

package/lib/storage/localfilesystem/projects/git/index.js

@@ -51,6 +51,8 @@ function runGitCommand(args,cwd,env,emit) {
             err.code = "git_auth_failed";
         } else if(/Authentication failed/i.test(stderr)) {
             err.code = "git_auth_failed";
+        } else if (/The requested URL returned error: 403/i.test(stderr)) {
+            err.code = "git_auth_failed";
         } else if (/commit your changes or stash/i.test(stderr)) {
             err.code = "git_local_overwrite";
         } else if (/CONFLICT/.test(err.stdout)) {

package/lib/telemetry/index.js

@@ -0,0 +1,213 @@
+const path = require('path')
+const fs = require('fs/promises')
+const semver = require('semver')
+const cronosjs = require('cronosjs')
+
+const METRICS_DIR = path.join(__dirname, 'metrics')
+const INITIAL_PING_DELAY = 1000 * 60 * 30 // 30 minutes from startup
+
+/** @type {import("got").Got | undefined} */
+let got
+
+let runtime
+
+let scheduleTask
+
+async function gather () {
+    let metricFiles = await fs.readdir(METRICS_DIR)
+    metricFiles = metricFiles.filter(name => /^\d+-.*\.js$/.test(name))
+    metricFiles.sort()
+
+    const metrics = {}
+
+    for (let i = 0, l = metricFiles.length; i < l; i++) {
+        const metricModule = require(path.join(METRICS_DIR, metricFiles[i]))
+        let result = metricModule(runtime)
+        if (!!result && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function') {
+            result = await result
+        }
+        const keys = Object.keys(result)
+        keys.forEach(key => {
+            const keyParts = key.split('.')
+            let p = metrics
+            keyParts.forEach((part, index) => {
+                if (index < keyParts.length - 1) {
+                    if (!p[part]) {
+                        p[part] = {}
+                    }
+                    p = p[part]
+                } else {
+                    p[part] = result[key]
+                }
+            })
+        })
+    }
+    return metrics
+}
+
+async function report () {
+    if (!isTelemetryEnabled()) {
+        return
+    }
+    // If enabled, gather metrics
+    const metrics = await gather()
+
+    // Post metrics to endpoint - handle any error silently
+
+    if (!got) {
+        got = (await import('got')).got
+    }
+
+    runtime.log.debug('Sending telemetry')
+    const response = await got.post('https://telemetry.nodered.org/ping', {
+        json: metrics,
+        responseType: 'json',
+        headers: {
+            'User-Agent': `Node-RED/${runtime.settings.version}`
+        }
+    }).json().catch(err => {
+        // swallow errors
+        runtime.log.debug('Failed to send telemetry: ' + err.toString())
+    })
+    // Example response:      
+    // { 'node-red': { latest: '4.0.9', next: '4.1.0-beta.1.9' } }
+    runtime.log.debug(`Telemetry response: ${JSON.stringify(response)}`)
+    // Get response from endpoint
+    if (response?.['node-red']) {
+        const currentVersion = metrics.env['node-red']
+        if (semver.valid(currentVersion)) {
+            const latest = response['node-red'].latest
+            const next = response['node-red'].next
+            let updatePayload
+            if (semver.lt(currentVersion, latest)) {
+                // Case one: current < latest
+                runtime.log.info(`A new version of Node-RED is available: ${latest}`)
+                updatePayload = { version: latest }
+            } else if (semver.gt(currentVersion, latest) && semver.lt(currentVersion, next)) {
+                // Case two: current > latest && current < next
+                runtime.log.info(`A new beta version of Node-RED is available: ${next}`)
+                updatePayload = { version: next }
+            }
+
+            if (updatePayload && isUpdateNotificationEnabled()) {
+                runtime.events.emit("runtime-event",{id:"update-available", payload: updatePayload, retain: true});
+            }
+        }
+    }
+}
+
+function isTelemetryEnabled () {
+    // If NODE_RED_DISABLE_TELEMETRY was set, or --no-telemetry was specified,
+    // the settings object will have been updated to disable telemetry explicitly
+
+    // If there are no telemetry settings then the user has not had a chance
+    // to opt out yet - so keep it disabled until they do
+
+    let telemetrySettings
+    try {
+        telemetrySettings = runtime.settings.get('telemetry')
+    } catch (err) {
+        // Settings not available
+    }
+    let runtimeTelemetryEnabled
+    try {
+        runtimeTelemetryEnabled = runtime.settings.get('telemetryEnabled')
+    } catch (err) {
+        // Settings not available
+    }
+
+    if (telemetrySettings === undefined && runtimeTelemetryEnabled === undefined) {
+        // No telemetry settings - so keep it disabled
+        return undefined
+    }
+
+    // User has made a choice; defer to that
+    if (runtimeTelemetryEnabled !== undefined) {
+        return runtimeTelemetryEnabled
+    }
+
+    // If there are telemetry settings, use what it says
+    if (telemetrySettings && telemetrySettings.enabled !== undefined) {
+        return telemetrySettings.enabled
+    }
+
+    // At this point, we have no sign the user has consented to telemetry, so
+    // keep disabled - but return undefined as a false-like value to distinguish
+    // it from the explicit disable above
+    return undefined
+}
+
+function isUpdateNotificationEnabled () {
+    const telemetrySettings = runtime.settings.get('telemetry') || {}
+    return telemetrySettings.updateNotification !== false
+}
+/**
+ * Start the telemetry schedule
+ */
+function startTelemetry () {
+    if (scheduleTask) {
+        // Already scheduled - nothing left to do
+        return
+    }
+
+    const pingTime = new Date(Date.now() + INITIAL_PING_DELAY)
+    const pingMinutes = pingTime.getMinutes()
+    const pingHours = pingTime.getHours()
+    const pingSchedule = `${pingMinutes} ${pingHours} * * *`
+
+    runtime.log.debug(`Telemetry enabled. Schedule: ${pingSchedule}`)
+
+    scheduleTask = cronosjs.scheduleTask(pingSchedule, () => {
+        report()
+    })
+}
+
+function stopTelemetry () {
+    if (scheduleTask) {
+        runtime.log.debug(`Telemetry disabled`)
+        scheduleTask.stop()
+        scheduleTask = null 
+    }
+}
+
+module.exports = {
+    init: (_runtime) => {
+        runtime = _runtime
+
+        if (isTelemetryEnabled()) {
+            startTelemetry()
+        }
+    },
+    /**
+     * Enable telemetry via user opt-in in the editor
+     */
+    enable: () => {
+        if (runtime.settings.available()) {
+            runtime.settings.set('telemetryEnabled', true)
+        }
+        startTelemetry()
+    },
+
+    /**
+     * Disable telemetry via user opt-in in the editor
+     */
+    disable: () => {
+        if (runtime.settings.available()) {
+            runtime.settings.set('telemetryEnabled', false)
+        }
+        stopTelemetry()
+    },
+
+    /**
+     * Get telemetry enabled status
+     * @returns {boolean} true if telemetry is enabled, false if disabled, undefined if not set
+     */
+    isEnabled: isTelemetryEnabled,
+
+    stop: () => {
+        if (scheduleTask) {
+            scheduleTask.stop()
+            scheduleTask = null 
+        }
+    }
+}

package/lib/telemetry/metrics/01-core.js

@@ -0,0 +1,5 @@
+module.exports = (runtime) => {
+    return {
+        instanceId: runtime.settings.get('instanceId')
+    }
+}

package/lib/telemetry/metrics/02-os.js

@@ -0,0 +1,9 @@
+const os = require('os')
+
+module.exports = (_) => {
+    return {
+        'os.type': os.type(),
+        'os.release': os.release(),
+        'os.arch': os.arch()
+    }
+}

package/lib/telemetry/metrics/03-env.js

@@ -0,0 +1,8 @@
+const process = require('process')
+
+module.exports = (runtime) => {
+    return {
+        'env.nodejs': process.version.replace(/^v/, ''),
+        'env.node-red': runtime.settings.version
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@node-red/runtime",
-    "version": "4.0.9",
+    "version": "4.1.0-beta.2",
     "license": "Apache-2.0",
     "main": "./lib/index.js",
     "repository": {
@@ -16,13 +16,15 @@
         }
     ],
     "dependencies": {
-        "@node-red/registry": "4.0.9",
-        "@node-red/util": "4.0.9",
+        "@node-red/registry": "4.1.0-beta.2",
+        "@node-red/util": "4.1.0-beta.2",
         "async-mutex": "0.5.0",
         "clone": "2.1.2",
+        "cronosjs": "1.7.1",
         "express": "4.21.2",
-        "fs-extra": "11.2.0",
+        "fs-extra": "11.3.0",
         "json-stringify-safe": "5.0.1",
-        "rfdc": "^1.3.1"
+        "rfdc": "^1.3.1",
+        "semver": "7.7.1"
     }
 }