@theotherwillembotha/node-red-loki 0.1.0 → 0.3.0

package/build/Nodes.html

@@ -7,7 +7,339 @@
     You have been warned.
     
 -->
+<!-- LokiQueryNode -->
+        
+<script type="text/javascript">
+
+window.PluginCore = window.PluginCore || {};
+
+/**
+ * PluginCore.createLogQLEditor(elementId, initialValue)
+ *
+ * Creates a Monaco editor pre-configured with the LogQL language:
+ * syntax highlighting for stream selectors, pipeline stages, metric
+ * functions, and aggregation operators; plus snippet completions.
+ *
+ * The LogQL language is registered with Monaco lazily on first call.
+ *
+ * @param {string} elementId    - DOM id of the container element.
+ * @param {string} initialValue - Starting content of the editor.
+ * @returns {{ getValue(): string, dispose(): void \}}
+ */
+PluginCore.createLogQLEditor = function(elementId, initialValue) {
+
+    // Register the LogQL language with Monaco once per session.
+    if (!PluginCore._logqlReady) {
+        PluginCore._logqlReady = true;
+
+        monaco.languages.register({ id: 'logql' });
+
+        monaco.languages.setLanguageConfiguration('logql', {
+            brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+            autoClosingPairs: [
+                { open: '{', close: '}' },
+                { open: '[', close: ']' },
+                { open: '(', close: ')' },
+                { open: '"', close: '"' },
+                { open: "'", close: "'" },
+                { open: '`', close: '`' }
+            ],
+            surroundingPairs: [
+                { open: '{', close: '}' },
+                { open: '[', close: ']' },
+                { open: '(', close: ')' },
+                { open: '"', close: '"' },
+                { open: "'", close: "'" }
+            ]
+        });
+
+        monaco.languages.setMonarchTokensProvider('logql', {
+            defaultToken: '',
+            tokenPostfix: '.logql',
+
+            keywords:       ['by', 'without', 'on', 'ignoring', 'group_left', 'group_right', 'bool', 'or', 'and', 'unless', 'offset'],
+            metricFns:      ['rate', 'count_over_time', 'bytes_rate', 'bytes_over_time', 'absent_over_time',
+                             'sum_over_time', 'avg_over_time', 'min_over_time', 'max_over_time',
+                             'first_over_time', 'last_over_time', 'stddev_over_time', 'stdvar_over_time',
+                             'quantile_over_time', 'label_replace', 'vector', 'sort', 'sort_desc'],
+            aggregations:   ['sum', 'avg', 'min', 'max', 'count', 'stddev', 'stdvar', 'bottomk', 'topk'],
+            pipelineStages: ['json', 'logfmt', 'pattern', 'regexp', 'unpack', 'line_format',
+                             'label_format', 'drop', 'keep', 'decolorize', 'unwrap', 'ip',
+                             'duration', 'bytes', 'distinct'],
+
+            tokenizer: {
+                root: [
+                    // Stream selector open brace
+                    [/\{/, { token: 'delimiter.curly', bracket: '@open', next: '@streamSelector' }],
+                    // Range vector e.g. [5m]
+                    [/\[\d+(ms|s|m|h|d|w|y)\]/, 'number.duration'],
+                    // Pipeline filter operators
+                    [/[|!][=~]/, 'operator.filter'],
+                    // Pipe
+                    [/\|/, 'operator.pipe'],
+                    // Comparison operators
+                    [/[><=!]+/, 'operator'],
+                    // Numbers
+                    [/\d+(\.\d+)?/, 'number'],
+                    // Identifiers -> map to keyword/function/aggregation/pipeline categories
+                    [/[a-zA-Z_]\w*/, {
+                        cases: {
+                            '@keywords':       'keyword',
+                            '@aggregations':   'type.aggregate',
+                            '@metricFns':      'type.function',
+                            '@pipelineStages': 'type.pipeline',
+                            '@default':        'identifier'
+                        }
+                    }],
+                    // String literals
+                    [/"/, { token: 'string.quote', bracket: '@open', next: '@dblString' }],
+                    [/'/, { token: 'string.quote', bracket: '@open', next: '@sglString' }],
+                    [/`/, { token: 'string.quote', bracket: '@open', next: '@rawString' }]
+                ],
+
+                streamSelector: [
+                    [/\}/, { token: 'delimiter.curly', bracket: '@close', next: '@pop' }],
+                    [/[a-zA-Z_]\w*/, 'attribute.name'],
+                    [/=~|!=|=|!~/, 'operator'],
+                    [/"/, { token: 'string.quote', bracket: '@open', next: '@dblString' }],
+                    [/'/, { token: 'string.quote', bracket: '@open', next: '@sglString' }],
+                    [/`/, { token: 'string.quote', bracket: '@open', next: '@rawString' }],
+                    [/,/, 'delimiter']
+                ],
+
+                dblString: [
+                    [/[^"\\]+/, 'string'],
+                    [/\\./, 'string.escape'],
+                    [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
+                ],
+                sglString: [
+                    [/[^'\\]+/, 'string'],
+                    [/\\./, 'string.escape'],
+                    [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
+                ],
+                rawString: [
+                    [/[^`]+/, 'string'],
+                    [/`/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
+                ]
+            }
+        });
+
+        monaco.languages.registerCompletionItemProvider('logql', {
+            triggerCharacters: ['{', '|', ' ', '('],
+            provideCompletionItems: function(model, position) {
+                var word  = model.getWordUntilPosition(position);
+                var range = {
+                    startLineNumber: position.lineNumber,
+                    endLineNumber:   position.lineNumber,
+                    startColumn:     word.startColumn,
+                    endColumn:       word.endColumn
+                };
+
+                var mk = monaco.languages.CompletionItemKind;
+                var SR = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+                var suggestions = [];
+
+                // Stream selector template
+                suggestions.push({
+                    label: '{label="value"}',
+                    kind: mk.Snippet,
+                    detail: 'Log stream selector',
+                    documentation: 'Select log streams matching a set of label matchers.',
+                    insertText: '{${1:app}="${2:nodered}"}',
+                    insertTextRules: SR,
+                    range: range
+                });
+
+                // Metric query functions
+                [
+                    { l: 'rate',             d: 'Per-second rate of log entries',           s: 'rate({${1:app}="${2}"} [${3:5m}])' },
+                    { l: 'count_over_time',  d: 'Count of log entries over time range',     s: 'count_over_time({${1:app}="${2}"} [${3:5m}])' },
+                    { l: 'bytes_rate',       d: 'Per-second byte rate of log entries',      s: 'bytes_rate({${1:app}="${2}"} [${3:5m}])' },
+                    { l: 'bytes_over_time',  d: 'Total bytes of log entries over range',    s: 'bytes_over_time({${1:app}="${2}"} [${3:5m}])' },
+                    { l: 'absent_over_time', d: 'Returns 1 if no entries found in range',   s: 'absent_over_time({${1:app}="${2}"} [${3:5m}])' },
+                    { l: 'sum_over_time',    d: 'Sum of unwrapped values over range',       s: 'sum_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])' },
+                    { l: 'avg_over_time',    d: 'Average of unwrapped values over range',   s: 'avg_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])' },
+                    { l: 'min_over_time',    d: 'Minimum of unwrapped values over range',   s: 'min_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])' },
+                    { l: 'max_over_time',    d: 'Maximum of unwrapped values over range',   s: 'max_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])' },
+                    { l: 'quantile_over_time', d: 'Quantile of unwrapped values',           s: 'quantile_over_time(${1:0.99}, {${2:app}="${3}"} | unwrap ${4:field} [${5:5m}])' },
+                    { l: 'first_over_time',  d: 'First unwrapped value over range',         s: 'first_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])' },
+                    { l: 'last_over_time',   d: 'Last unwrapped value over range',          s: 'last_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])' },
+                    { l: 'label_replace',    d: 'Replace label value using regex',          s: 'label_replace(${1:expr}, "${2:dst_label}", "${3:$1}", "${4:src_label}", "${5:(.*)}")' }
+                ].forEach(function(f) {
+                    suggestions.push({ label: f.l, kind: mk.Function, detail: f.d, insertText: f.s, insertTextRules: SR, range: range });
+                });
+
+                // Aggregation operators
+                [
+                    { l: 'sum',     d: 'Sum over dimensions' },
+                    { l: 'avg',     d: 'Average over dimensions' },
+                    { l: 'min',     d: 'Minimum over dimensions' },
+                    { l: 'max',     d: 'Maximum over dimensions' },
+                    { l: 'count',   d: 'Count over dimensions' },
+                    { l: 'stddev',  d: 'Standard deviation' },
+                    { l: 'stdvar',  d: 'Standard variance' },
+                    { l: 'bottomk', d: 'Smallest k elements', s: 'bottomk(${1:5}, ${2:expr})' },
+                    { l: 'topk',    d: 'Largest k elements',  s: 'topk(${1:5}, ${2:expr})' }
+                ].forEach(function(a) {
+                    var snippet = a.s || (a.l + '(${1:by (${2:label})}) (${3:expr})');
+                    suggestions.push({ label: a.l, kind: mk.Keyword, detail: a.d, insertText: snippet, insertTextRules: SR, range: range });
+                });
+
+                // Pipeline stages
+                [
+                    { l: '|= "..."',            s: '|= "${1}"',                              d: 'Filter: line contains string' },
+                    { l: '!= "..."',            s: '!= "${1}"',                             d: 'Filter: line does not contain string' },
+                    { l: '|~ "..."',            s: '|~ "${1}"',                             d: 'Filter: line matches regex' },
+                    { l: '!~ "..."',            s: '!~ "${1}"',                             d: 'Filter: line does not match regex' },
+                    { l: '| json',              s: '| json',                                d: 'Parse JSON log line' },
+                    { l: '| logfmt',            s: '| logfmt',                              d: 'Parse logfmt log line' },
+                    { l: '| pattern "..."',     s: '| pattern "${1:<_> level=<level> <_>}"', d: 'Parse using pattern' },
+                    { l: '| regexp "..."',      s: '| regexp "${1:(?P<level>[a-z]+)}"',      d: 'Parse using named regex groups' },
+                    { l: '| line_format "..."', s: '| line_format "${1:{{.level\}} {{.msg\}}}"', d: 'Reformat the log line' },
+                    { l: '| label_format',      s: '| label_format ${1:new_label}=${2:old_label}', d: 'Rename or transform labels' },
+                    { l: '| unwrap',            s: '| unwrap ${1:label}',                   d: 'Extract numeric value for metric queries' },
+                    { l: '| unpack',            s: '| unpack',                              d: 'Unpack JSON log fields into labels' },
+                    { l: '| drop',              s: '| drop ${1:label}',                     d: 'Drop specified labels' },
+                    { l: '| keep',              s: '| keep ${1:label}',                     d: 'Keep only specified labels' },
+                    { l: '| decolorize',        s: '| decolorize',                          d: 'Strip ANSI colour codes' }
+                ].forEach(function(p) {
+                    suggestions.push({ label: p.l, kind: mk.Operator, detail: p.d, insertText: p.s, insertTextRules: SR, range: range });
+                });
+
+                // Keywords
+                ['by', 'without', 'on', 'or', 'and', 'unless', 'bool', 'offset', 'ignoring'].forEach(function(kw) {
+                    suggestions.push({ label: kw, kind: mk.Keyword, insertText: kw, range: range });
+                });
+
+                return { suggestions: suggestions };
+            }
+        });
+    }
+
+    var editor = monaco.editor.create(document.getElementById(elementId), {
+        value:               initialValue || '',
+        language:            'logql',
+        automaticLayout:     true,
+        minimap:             { enabled: false },
+        lineNumbers:         'off',
+        wordWrap:            'on',
+        scrollBeyondLastLine: false,
+        fontSize:            13,
+        overviewRulerLanes:  0,
+        folding:             false,
+        padding:             { top: 6, bottom: 6 }
+    });
+
+    return {
+        getValue: function()  { return editor.getValue(); },
+        dispose:  function()  { editor.dispose(); }
+    };
+};
+
+</script>
+
+        
+<!-- logger -->
+        
+<style>
+  .editorgroupborder {
+      border-width:1px;
+      border-style:solid;
+      border-color:lightgray;
+      padding: 3px;
+      margin-top: 2px;
+      margin-bottom: 2px;
+  }
+
+  .editorsectionheading {
+      font-weight: 600;
+      margin-bottom:1px !important; 
+      margin-top:6px !important; 
+  }
+
+  .nomargin {
+      margin-bottom:1px !important; 
+      margin-top:1px !important; 
+  }
+
+  .slidecontainer {
+    width: 100%;
+  }
+
+  .slider {
+    -webkit-appearance: none;
+    appearance: none;
+    width: 100%;
+    height: 25px;
+    background: #d3d3d3;
+    outline: none;
+    opacity: 0.7;
+    -webkit-transition: .2s;
+    transition: opacity .2s;
+  }
+  
+  .slider:hover {
+    opacity: 1;
+  }
+  
+  .slider::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    appearance: none;
+    width: 25px;
+    height: 25px;
+    background: #04AA6D;
+    cursor: pointer;
+  }
+  
+  .slider::-moz-range-thumb {
+    width: 25px;
+    height: 25px;
+    background: #04AA6D;
+    cursor: pointer;
+  }
 
+    .towb_editorlabel {
+        width: 120px !important;
+    }
+    input.towb_editorfield, select.towb_editorfield, textarea.towb_editorfield {
+        width: 70% !important;
+    }
+    input.towb_editorfield_short, select.towb_editorfield_short {
+        width: 30% !important;
+    }
+
+</style>
+
+<script type="text/javascript">
+
+    // CSS
+    dropdownStyles = `
+    .loggertype-dropdown {
+        position: absolute;
+        background: white;
+        border: 1px solid #ccc;
+        border-radius: 4px;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.15);
+        max-height: 150px;
+        overflow-y: auto;
+        z-index: 1000;
+        min-width: 150px;
+    }
+    .loggertype-dropdown .dropdown-item {
+        padding: 6px 12px;
+        cursor: pointer;
+    }
+    .loggertype-dropdown .dropdown-item:hover {
+        background: #f0f0f0;
+    }
+    `;
+    $('<style>').text(dropdownStyles).appendTo('head');
+
+</script>
+
+
+
+        
 <script type="text/javascript">
     RED.nodes.registerType('LokiServiceConfigNode', {
       category: 'config',
@@ -130,6 +462,7 @@ Shared connection configuration for a Grafana Loki instance. Referenced by the L
 : *username*   (string) : Username for basic authentication. Leave blank if auth is not required.
 : *auth token* (string) : Password or token for basic authentication.
 </script>
+
 <script type="text/javascript">
     RED.nodes.registerType('LokiLoggerConfigNode', {
       category: 'config',
@@ -256,517 +589,7 @@ Mustache/Handlebars templates build the message string pushed to Loki.
 - [Mustache - Wikipedia](https://en.wikipedia.org/wiki/Mustache_(template_system))
 - [Mustache - Playground](https://jgonggrijp.gitlab.io/wontache/playground.html)
 </script>
-<!-- LokiQueryNode -->
-<script type="text/javascript">
-    window.PluginCore = window.PluginCore || {};
-    /**
-     * PluginCore.createLogQLEditor(elementId, initialValue)
-     *
-     * Creates a Monaco editor pre-configured with the LogQL language:
-     * syntax highlighting for stream selectors, pipeline stages, metric
-     * functions, and aggregation operators; plus snippet completions.
-     *
-     * The LogQL language is registered with Monaco lazily on first call.
-     *
-     * @param {string} elementId    - DOM id of the container element.
-     * @param {string} initialValue - Starting content of the editor.
-     * @returns {{ getValue(): string, dispose(): void \}}
-     */
-    PluginCore.createLogQLEditor = function(elementId, initialValue) {
-      // Register the LogQL language with Monaco once per session.
-      if (!PluginCore._logqlReady) {
-        PluginCore._logqlReady = true;
-        monaco.languages.register({
-          id: 'logql'
-        });
-        monaco.languages.setLanguageConfiguration('logql', {
-          brackets: [
-            ['{', '}'],
-            ['[', ']'],
-            ['(', ')']
-          ],
-          autoClosingPairs: [{
-            open: '{',
-            close: '}'
-          }, {
-            open: '[',
-            close: ']'
-          }, {
-            open: '(',
-            close: ')'
-          }, {
-            open: '"',
-            close: '"'
-          }, {
-            open: "'",
-            close: "'"
-          }, {
-            open: '`',
-            close: '`'
-          }],
-          surroundingPairs: [{
-            open: '{',
-            close: '}'
-          }, {
-            open: '[',
-            close: ']'
-          }, {
-            open: '(',
-            close: ')'
-          }, {
-            open: '"',
-            close: '"'
-          }, {
-            open: "'",
-            close: "'"
-          }]
-        });
-        monaco.languages.setMonarchTokensProvider('logql', {
-          defaultToken: '',
-          tokenPostfix: '.logql',
-          keywords: ['by', 'without', 'on', 'ignoring', 'group_left', 'group_right', 'bool', 'or', 'and', 'unless', 'offset'],
-          metricFns: ['rate', 'count_over_time', 'bytes_rate', 'bytes_over_time', 'absent_over_time', 'sum_over_time', 'avg_over_time', 'min_over_time', 'max_over_time', 'first_over_time', 'last_over_time', 'stddev_over_time', 'stdvar_over_time', 'quantile_over_time', 'label_replace', 'vector', 'sort', 'sort_desc'],
-          aggregations: ['sum', 'avg', 'min', 'max', 'count', 'stddev', 'stdvar', 'bottomk', 'topk'],
-          pipelineStages: ['json', 'logfmt', 'pattern', 'regexp', 'unpack', 'line_format', 'label_format', 'drop', 'keep', 'decolorize', 'unwrap', 'ip', 'duration', 'bytes', 'distinct'],
-          tokenizer: {
-            root: [
-              // Stream selector open brace
-              [/\{/, {
-                token: 'delimiter.curly',
-                bracket: '@open',
-                next: '@streamSelector'
-              }],
-              // Range vector e.g. [5m]
-              [/\[\d+(ms|s|m|h|d|w|y)\]/, 'number.duration'],
-              // Pipeline filter operators
-              [/[|!][=~]/, 'operator.filter'],
-              // Pipe
-              [/\|/, 'operator.pipe'],
-              // Comparison operators
-              [/[><=!]+/, 'operator'],
-              // Numbers
-              [/\d+(\.\d+)?/, 'number'],
-              // Identifiers -> map to keyword/function/aggregation/pipeline categories
-              [/[a-zA-Z_]\w*/, {
-                cases: {
-                  '@keywords': 'keyword',
-                  '@aggregations': 'type.aggregate',
-                  '@metricFns': 'type.function',
-                  '@pipelineStages': 'type.pipeline',
-                  '@default': 'identifier'
-                }
-              }],
-              // String literals
-              [/"/, {
-                token: 'string.quote',
-                bracket: '@open',
-                next: '@dblString'
-              }],
-              [/'/, {
-                token: 'string.quote',
-                bracket: '@open',
-                next: '@sglString'
-              }],
-              [/`/, {
-                token: 'string.quote',
-                bracket: '@open',
-                next: '@rawString'
-              }]
-            ],
-            streamSelector: [
-              [/\}/, {
-                token: 'delimiter.curly',
-                bracket: '@close',
-                next: '@pop'
-              }],
-              [/[a-zA-Z_]\w*/, 'attribute.name'],
-              [/=~|!=|=|!~/, 'operator'],
-              [/"/, {
-                token: 'string.quote',
-                bracket: '@open',
-                next: '@dblString'
-              }],
-              [/'/, {
-                token: 'string.quote',
-                bracket: '@open',
-                next: '@sglString'
-              }],
-              [/`/, {
-                token: 'string.quote',
-                bracket: '@open',
-                next: '@rawString'
-              }],
-              [/,/, 'delimiter']
-            ],
-            dblString: [
-              [/[^"\\]+/, 'string'],
-              [/\\./, 'string.escape'],
-              [/"/, {
-                token: 'string.quote',
-                bracket: '@close',
-                next: '@pop'
-              }]
-            ],
-            sglString: [
-              [/[^'\\]+/, 'string'],
-              [/\\./, 'string.escape'],
-              [/'/, {
-                token: 'string.quote',
-                bracket: '@close',
-                next: '@pop'
-              }]
-            ],
-            rawString: [
-              [/[^`]+/, 'string'],
-              [/`/, {
-                token: 'string.quote',
-                bracket: '@close',
-                next: '@pop'
-              }]
-            ]
-          }
-        });
-        monaco.languages.registerCompletionItemProvider('logql', {
-          triggerCharacters: ['{', '|', ' ', '('],
-          provideCompletionItems: function(model, position) {
-            var word = model.getWordUntilPosition(position);
-            var range = {
-              startLineNumber: position.lineNumber,
-              endLineNumber: position.lineNumber,
-              startColumn: word.startColumn,
-              endColumn: word.endColumn
-            };
-            var mk = monaco.languages.CompletionItemKind;
-            var SR = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
-            var suggestions = [];
-            // Stream selector template
-            suggestions.push({
-              label: '{label="value"}',
-              kind: mk.Snippet,
-              detail: 'Log stream selector',
-              documentation: 'Select log streams matching a set of label matchers.',
-              insertText: '{${1:app}="${2:nodered}"}',
-              insertTextRules: SR,
-              range: range
-            });
-            // Metric query functions
-            [{
-              l: 'rate',
-              d: 'Per-second rate of log entries',
-              s: 'rate({${1:app}="${2}"} [${3:5m}])'
-            }, {
-              l: 'count_over_time',
-              d: 'Count of log entries over time range',
-              s: 'count_over_time({${1:app}="${2}"} [${3:5m}])'
-            }, {
-              l: 'bytes_rate',
-              d: 'Per-second byte rate of log entries',
-              s: 'bytes_rate({${1:app}="${2}"} [${3:5m}])'
-            }, {
-              l: 'bytes_over_time',
-              d: 'Total bytes of log entries over range',
-              s: 'bytes_over_time({${1:app}="${2}"} [${3:5m}])'
-            }, {
-              l: 'absent_over_time',
-              d: 'Returns 1 if no entries found in range',
-              s: 'absent_over_time({${1:app}="${2}"} [${3:5m}])'
-            }, {
-              l: 'sum_over_time',
-              d: 'Sum of unwrapped values over range',
-              s: 'sum_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])'
-            }, {
-              l: 'avg_over_time',
-              d: 'Average of unwrapped values over range',
-              s: 'avg_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])'
-            }, {
-              l: 'min_over_time',
-              d: 'Minimum of unwrapped values over range',
-              s: 'min_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])'
-            }, {
-              l: 'max_over_time',
-              d: 'Maximum of unwrapped values over range',
-              s: 'max_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])'
-            }, {
-              l: 'quantile_over_time',
-              d: 'Quantile of unwrapped values',
-              s: 'quantile_over_time(${1:0.99}, {${2:app}="${3}"} | unwrap ${4:field} [${5:5m}])'
-            }, {
-              l: 'first_over_time',
-              d: 'First unwrapped value over range',
-              s: 'first_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])'
-            }, {
-              l: 'last_over_time',
-              d: 'Last unwrapped value over range',
-              s: 'last_over_time({${1:app}="${2}"} | unwrap ${3:field} [${4:5m}])'
-            }, {
-              l: 'label_replace',
-              d: 'Replace label value using regex',
-              s: 'label_replace(${1:expr}, "${2:dst_label}", "${3:$1}", "${4:src_label}", "${5:(.*)}")'
-            }].forEach(function(f) {
-              suggestions.push({
-                label: f.l,
-                kind: mk.Function,
-                detail: f.d,
-                insertText: f.s,
-                insertTextRules: SR,
-                range: range
-              });
-            });
-            // Aggregation operators
-            [{
-              l: 'sum',
-              d: 'Sum over dimensions'
-            }, {
-              l: 'avg',
-              d: 'Average over dimensions'
-            }, {
-              l: 'min',
-              d: 'Minimum over dimensions'
-            }, {
-              l: 'max',
-              d: 'Maximum over dimensions'
-            }, {
-              l: 'count',
-              d: 'Count over dimensions'
-            }, {
-              l: 'stddev',
-              d: 'Standard deviation'
-            }, {
-              l: 'stdvar',
-              d: 'Standard variance'
-            }, {
-              l: 'bottomk',
-              d: 'Smallest k elements',
-              s: 'bottomk(${1:5}, ${2:expr})'
-            }, {
-              l: 'topk',
-              d: 'Largest k elements',
-              s: 'topk(${1:5}, ${2:expr})'
-            }].forEach(function(a) {
-              var snippet = a.s || (a.l + '(${1:by (${2:label})}) (${3:expr})');
-              suggestions.push({
-                label: a.l,
-                kind: mk.Keyword,
-                detail: a.d,
-                insertText: snippet,
-                insertTextRules: SR,
-                range: range
-              });
-            });
-            // Pipeline stages
-            [{
-              l: '|= "..."',
-              s: '|= "${1}"',
-              d: 'Filter: line contains string'
-            }, {
-              l: '!= "..."',
-              s: '!= "${1}"',
-              d: 'Filter: line does not contain string'
-            }, {
-              l: '|~ "..."',
-              s: '|~ "${1}"',
-              d: 'Filter: line matches regex'
-            }, {
-              l: '!~ "..."',
-              s: '!~ "${1}"',
-              d: 'Filter: line does not match regex'
-            }, {
-              l: '| json',
-              s: '| json',
-              d: 'Parse JSON log line'
-            }, {
-              l: '| logfmt',
-              s: '| logfmt',
-              d: 'Parse logfmt log line'
-            }, {
-              l: '| pattern "..."',
-              s: '| pattern "${1:<_> level=<level> <_>}"',
-              d: 'Parse using pattern'
-            }, {
-              l: '| regexp "..."',
-              s: '| regexp "${1:(?P<level>[a-z]+)}"',
-              d: 'Parse using named regex groups'
-            }, {
-              l: '| line_format "..."',
-              s: '| line_format "${1:{{.level\}} {{.msg\}}}"',
-              d: 'Reformat the log line'
-            }, {
-              l: '| label_format',
-              s: '| label_format ${1:new_label}=${2:old_label}',
-              d: 'Rename or transform labels'
-            }, {
-              l: '| unwrap',
-              s: '| unwrap ${1:label}',
-              d: 'Extract numeric value for metric queries'
-            }, {
-              l: '| unpack',
-              s: '| unpack',
-              d: 'Unpack JSON log fields into labels'
-            }, {
-              l: '| drop',
-              s: '| drop ${1:label}',
-              d: 'Drop specified labels'
-            }, {
-              l: '| keep',
-              s: '| keep ${1:label}',
-              d: 'Keep only specified labels'
-            }, {
-              l: '| decolorize',
-              s: '| decolorize',
-              d: 'Strip ANSI colour codes'
-            }].forEach(function(p) {
-              suggestions.push({
-                label: p.l,
-                kind: mk.Operator,
-                detail: p.d,
-                insertText: p.s,
-                insertTextRules: SR,
-                range: range
-              });
-            });
-            // Keywords
-            ['by', 'without', 'on', 'or', 'and', 'unless', 'bool', 'offset', 'ignoring'].forEach(function(kw) {
-              suggestions.push({
-                label: kw,
-                kind: mk.Keyword,
-                insertText: kw,
-                range: range
-              });
-            });
-            return {
-              suggestions: suggestions
-            };
-          }
-        });
-      }
-      var editor = monaco.editor.create(document.getElementById(elementId), {
-        value: initialValue || '',
-        language: 'logql',
-        automaticLayout: true,
-        minimap: {
-          enabled: false
-        },
-        lineNumbers: 'off',
-        wordWrap: 'on',
-        scrollBeyondLastLine: false,
-        fontSize: 13,
-        overviewRulerLanes: 0,
-        folding: false,
-        padding: {
-          top: 6,
-          bottom: 6
-        }
-      });
-      return {
-        getValue: function() {
-          return editor.getValue();
-        },
-        dispose: function() {
-          editor.dispose();
-        }
-      };
-    };
-
-</script>
-<!-- logger -->
-<style>
-    .editorgroupborder {
-      border-width: 1px;
-      border-style: solid;
-      border-color: lightgray;
-      padding: 3px;
-      margin-top: 2px;
-      margin-bottom: 2px;
-    }
-
-    .editorsectionheading {
-      font-weight: 600;
-      margin-bottom: 1px !important;
-      margin-top: 6px !important;
-    }
-
-    .nomargin {
-      margin-bottom: 1px !important;
-      margin-top: 1px !important;
-    }
 
-    .slidecontainer {
-      width: 100%;
-    }
-
-    .slider {
-      -webkit-appearance: none;
-      appearance: none;
-      width: 100%;
-      height: 25px;
-      background: #d3d3d3;
-      outline: none;
-      opacity: 0.7;
-      -webkit-transition: .2s;
-      transition: opacity .2s;
-    }
-
-    .slider:hover {
-      opacity: 1;
-    }
-
-    .slider::-webkit-slider-thumb {
-      -webkit-appearance: none;
-      appearance: none;
-      width: 25px;
-      height: 25px;
-      background: #04AA6D;
-      cursor: pointer;
-    }
-
-    .slider::-moz-range-thumb {
-      width: 25px;
-      height: 25px;
-      background: #04AA6D;
-      cursor: pointer;
-    }
-
-    .towb_editorlabel {
-      width: 120px !important;
-    }
-
-    input.towb_editorfield,
-    select.towb_editorfield,
-    textarea.towb_editorfield {
-      width: 70% !important;
-    }
-
-    input.towb_editorfield_short,
-    select.towb_editorfield_short {
-      width: 30% !important;
-    }
-
-</style>
-<script type="text/javascript">
-    // CSS
-    dropdownStyles = `
-    .loggertype-dropdown {
-        position: absolute;
-        background: white;
-        border: 1px solid #ccc;
-        border-radius: 4px;
-        box-shadow: 0 2px 8px rgba(0,0,0,0.15);
-        max-height: 150px;
-        overflow-y: auto;
-        z-index: 1000;
-        min-width: 150px;
-    }
-    .loggertype-dropdown .dropdown-item {
-        padding: 6px 12px;
-        cursor: pointer;
-    }
-    .loggertype-dropdown .dropdown-item:hover {
-        background: #f0f0f0;
-    }
-    `;
-    $('<style>').text(dropdownStyles).appendTo('head');
-
-</script>
 <script type="text/javascript">
     RED.nodes.registerType('LokiQueryNode', {
       category: 'loki',
@@ -878,11 +701,14 @@ Mustache/Handlebars templates build the message string pushed to Loki.
         // **** logger **** //
         {
           let node = this;
+          let templateConfig = {};
           // controls.
           let logEnabled = $("#node-input-logEnabled");
           let logTemplateEnabled = $("#node-input-logTemplateOverrideEnabled");
           let logTemplateEnabledSection = $("#section_logTemplateOverrideEnabled");
           let logEnabledSection = $("#section_logEnabled");
+          let loggerSection = $("#section_loggerconfig");
+          loggerSection.hide();
           // functions.
           let getLoggerTypes = async function() {
             let types = [];
@@ -1006,10 +832,15 @@ Mustache/Handlebars templates build the message string pushed to Loki.
               loggerEditButton.removeClass("disabled")
             }
           });
-          // lastly, make sure that we set the correct value on the logger selector.
-          updateLoggerSelectorList().then(() => {
-            loggerSelector.val(node.logger);
-            loggerSelector.trigger('change');
+          // Show the logger section only if at least one logger type is registered.
+          // If nodered_logging (or any other logger provider) is not installed, the section stays hidden.
+          getLoggerTypes().then(loggerTypes => {
+            if (loggerTypes.length === 0) return;
+            loggerSection.show();
+            updateLoggerSelectorList().then(() => {
+              loggerSelector.val(node.logger);
+              loggerSelector.trigger('change');
+            });
           });
         }
       },
@@ -1023,6 +854,8 @@ Mustache/Handlebars templates build the message string pushed to Loki.
         }
         // **** logger **** //
         {
+          let node = this;
+          let templateConfig = {};
           node = this;
           var selectedLogger = $("#logger-selector").val();
           node.logger = (selectedLogger && selectedLogger !== "_ADD_") ? selectedLogger : '';
@@ -1191,5 +1024,4 @@ The query editor provides:
 : *override template* (logconfig)   : if checked, a custom logging template can be provided for the log message.
 : *logger template* (mustache)      : a template in mustache format to generate a message for logging purposes (see LoggerConfig node for more information)
 </script>
-