@theotherwillembotha/node-red-plugincore 0.1.0 → 0.2.0

package/src/core/metrics/MetricsDecorator.ts

@@ -1,221 +1,193 @@
 
 import { BaseNode, NodeManager } from "../NodeConstructor";
-import { BucketType, CounterMetricConfig, DefaultBucketConfig, ExponentialBucketConfig, HistogramMetricConfig, LinearBucketConfig, ManualBucketConfig, MetricsContainer, Metric, MetricConfig, CounterMetric, HistogramMetric, SummaryMetric, GaugeMetric, GaugeMetricConfig } from "./service/MetricsService";
+import {
+  MetricCapability,
+  MetricsContainer,
+  CounterMetricConfig,
+  GaugeMetricConfig,
+  HistogramMetricConfig,
+  BucketType,
+  CounterMetric,
+  HistogramMetric,
+  SummaryMetric,
+  GaugeMetric,
+  DoNothingCounterMetric,
+  DoNothingGaugeMetric,
+  DoNothingHistogramMetric,
+  DoNothingSummaryMetric,
+  DoNothingMetricsContainer,
+} from "./service/MetricsService";
 import { MetricsTemplateConfig } from "./template/MetricsTemplate";
 
 export enum MetricType {
   Counter = "Counter",
-  Timer = "Timer",
-  Gauge = "Gauge",
+  Timer   = "Timer",
+  Gauge   = "Gauge",
 }
 
 export enum MetricCollectorType {
     histogram = "histogram",
-    summary = "summary",
+    summary   = "summary",
 }
 
-
 type BaseMetricDecoratorConfig = {
-    name:string;
-    type:MetricType;
-    description:string;
-}
-
-type CounterMetricDecoratorConfig = BaseMetricDecoratorConfig & {
-  type:MetricType.Counter
+    name: string;
+    type: MetricType;
+    description: string;
 }
 
-type GaugeMetricDecoratorConfig = BaseMetricDecoratorConfig & {
-  type:MetricType.Gauge
-}
+type CounterMetricDecoratorConfig = BaseMetricDecoratorConfig & { type: MetricType.Counter }
+type GaugeMetricDecoratorConfig   = BaseMetricDecoratorConfig & { type: MetricType.Gauge }
 
 type TimerMetricDecoratorConfig = BaseMetricDecoratorConfig & {
-  type:MetricType.Timer,
-  collector:MetricCollectorType,
+  type: MetricType.Timer,
+  collector: MetricCollectorType,
 }
 
 type SummaryTimerMetricDecoratorConfig = TimerMetricDecoratorConfig & {
-  collector:MetricCollectorType.summary,
+  collector: MetricCollectorType.summary,
 }
 
 type HistogramTimerMetricDecoratorConfig = TimerMetricDecoratorConfig & {
-  collector:MetricCollectorType.histogram,
-  buckettype:BucketType,
-  //bucketconfig:DefaultBucketConfig|ManualBucketConfig|LinearBucketConfig|ExponentialBucketConfig,
+  collector: MetricCollectorType.histogram,
+  buckettype: BucketType,
 }
 
 type DefaultHistogramTimerMetricDecoratorConfig = HistogramTimerMetricDecoratorConfig & {
-  buckettype:BucketType.default,
-  bucketconfig?:DefaultBucketConfig
+  buckettype: BucketType.default,
 }
 
-type MetricsConfig = 
-  CounterMetricDecoratorConfig | 
-  GaugeMetricDecoratorConfig | 
-  SummaryTimerMetricDecoratorConfig | 
+type MetricsConfig =
+  CounterMetricDecoratorConfig |
+  GaugeMetricDecoratorConfig |
+  SummaryTimerMetricDecoratorConfig |
   DefaultHistogramTimerMetricDecoratorConfig
 
-export function Metrics(metricsConfig: MetricsConfig):Function {
+function resolveMetric(
+  node: BaseNode<MetricsTemplateConfig>,
+  metricsConfig: MetricsConfig,
+  _metrics: MetricsContainer
+): CounterMetric | GaugeMetric | HistogramMetric | SummaryMetric | undefined {
+
+  const nde = {
+    id:   node.id(),
+    name: node.name(),
+    flow: node.flow(),
+    type: node.type()
+  };
+
+  if (metricsConfig.type === MetricType.Counter) {
+    if (!_metrics.supports(MetricCapability.Counter)) {
+      console.warn(`[PluginCore] @Metrics Counter requested by node "${node.name()}" (${node.type()}) but the selected provider does not support Counter. Using DoNothing.`);
+    }
+    const counterConfig: CounterMetricConfig = {
+      metricname: metricsConfig.name,
+      metricdescription: metricsConfig.description,
+      node: nde
+    };
+    return _metrics.counter(counterConfig);
+  }
+
+  if (metricsConfig.type === MetricType.Gauge) {
+    if (!_metrics.supports(MetricCapability.Gauge)) {
+      console.warn(`[PluginCore] @Metrics Gauge requested by node "${node.name()}" (${node.type()}) but the selected provider does not support Gauge. Using DoNothing.`);
+    }
+    const gaugeConfig: GaugeMetricConfig = {
+      metricname: metricsConfig.name,
+      metricdescription: metricsConfig.description,
+      node: nde
+    };
+    return _metrics.gauge(gaugeConfig);
+  }
+
+  if (metricsConfig.type === MetricType.Timer) {
+    if (metricsConfig.collector === MetricCollectorType.histogram) {
+      if (!_metrics.supports(MetricCapability.Histogram)) {
+        console.warn(`[PluginCore] @Metrics Histogram requested by node "${node.name()}" (${node.type()}) but the selected provider does not support Histogram. Using DoNothing.`);
+      }
+      if (metricsConfig.buckettype === BucketType.default) {
+        const histogramConfig: HistogramMetricConfig = {
+          metricname: metricsConfig.name,
+          metricdescription: metricsConfig.description,
+          buckettype: metricsConfig.buckettype,
+          bucketconfig: {},
+          node: nde
+        };
+        return _metrics.histogram(histogramConfig);
+      }
+    }
+    if (metricsConfig.collector === MetricCollectorType.summary) {
+      if (!_metrics.supports(MetricCapability.Summary)) {
+        console.warn(`[PluginCore] @Metrics Summary requested by node "${node.name()}" (${node.type()}) but the selected provider does not support Summary. Using DoNothing.`);
+      }
+    }
+  }
+
+  console.error("[PluginCore] @Metrics: no factory matched for config", metricsConfig);
+  return undefined;
+}
+
+function resolveContainer(metricsReference: string): MetricsContainer {
+  if (!metricsReference) return new DoNothingMetricsContainer();
+  const refNode = NodeManager.RED.nodes.getNode(metricsReference);
+  return refNode ? (refNode as any).node().metrics() as MetricsContainer : new DoNothingMetricsContainer();
+}
+
+function dudForType(metricsConfig: MetricsConfig): CounterMetric | GaugeMetric | HistogramMetric | SummaryMetric | undefined {
+  if (metricsConfig.type === MetricType.Counter) return new DoNothingCounterMetric();
+  if (metricsConfig.type === MetricType.Gauge)   return new DoNothingGaugeMetric();
+  if (metricsConfig.type === MetricType.Timer) {
+    if (metricsConfig.collector === MetricCollectorType.histogram) return new DoNothingHistogramMetric();
+    if (metricsConfig.collector === MetricCollectorType.summary)   return new DoNothingSummaryMetric();
+  }
+  return undefined;
+}
+
+export function Metrics(metricsConfig: MetricsConfig): Function {
   return function (target: any, propertyKey: string | symbol) {
 
-    // if the type is a string, then its probably defined in the local (core) module.
-    if(typeof propertyKey === "string"){
+    if (typeof propertyKey === "string") {
       const valueSymbol = Symbol(`_${String(propertyKey)}_value`);
 
       Object.defineProperty(target, propertyKey, {
         get: function() {
-          if(this[valueSymbol]){
-            return this[valueSymbol];
-          }
-
-          //console.log("injecting metric", valueSymbol);
-          let node = this as BaseNode<MetricsTemplateConfig>;
-          let config = node.config();
-
-          if(config.metricsEnabled){
-            let _metrics = (NodeManager.RED.nodes.getNode(config.metricsReference) as any).node().metrics() as MetricsContainer;
-            
-            let nde = {
-              id:node.id(),
-              name:node.name(),
-              flow:node.flow(),
-              type:node.type()
-            }
+          if (this[valueSymbol]) return this[valueSymbol];
 
-            // counter metric
-            if(metricsConfig.type === MetricType.Counter){
-              let counterConfig:CounterMetricConfig = {
-                metricname:metricsConfig.name,
-                metricdescription:metricsConfig.description,
-                node:nde
-              };
-              this[valueSymbol] = _metrics.counter(counterConfig);
-              return this[valueSymbol];
-            }
+          const node = this as BaseNode<MetricsTemplateConfig>;
+          const config = node.config();
 
-            // gauge metric
-            if(metricsConfig.type === MetricType.Gauge){
-              let gaugeConfig:GaugeMetricConfig = {
-                metricname:metricsConfig.name,
-                metricdescription:metricsConfig.description,
-                node:nde
-              };
-              this[valueSymbol] = _metrics.gauge(gaugeConfig);
-              return this[valueSymbol];
-            }
+          if (config.metricsEnabled) {
+            const _metrics = resolveContainer(config.metricsReference);
+            this[valueSymbol] = resolveMetric(node, metricsConfig, _metrics);
+          } else {
+            this[valueSymbol] = dudForType(metricsConfig);
+          }
 
-            // timer metric.
-            if(metricsConfig.type === MetricType.Timer){
-
-              // handle it as a histogram collector.
-              if(metricsConfig.collector === MetricCollectorType.histogram){
-
-                // handle it as the default bucket.
-                if(metricsConfig.buckettype === BucketType.default){
-                  let histogramConfig:HistogramMetricConfig = {
-                    metricname:metricsConfig.name,
-                    metricdescription:metricsConfig.description,
-                    buckettype:metricsConfig.buckettype,
-                    bucketconfig:{},
-                    node:nde
-                  };
-                  this[valueSymbol] = _metrics.histogram(histogramConfig);
-              return this[valueSymbol];
-                }
-              }
-            }
-            console.error("No Metric Factory type defined for ", metricsConfig);
-            return this[valueSymbol];
-          }        
-          
-          this[valueSymbol] =
-            (metricsConfig.type === MetricType.Counter) ? { inc(){}, reset(){} } as CounterMetric :
-            (metricsConfig.type === MetricType.Gauge)   ? { inc(){}, dec(){}, reset(){} } as GaugeMetric :
-            (metricsConfig.type === MetricType.Timer)   ? { observe(val:number){} } as HistogramMetric | SummaryMetric 
-            : undefined;
           return this[valueSymbol];
         },
         enumerable: true,
         configurable: false
       });
-      return
-    }
-    else{
+
+    } else {
       let property = propertyKey as any;
-      property.addInitializer(function(this:BaseNode<MetricsTemplateConfig>){
-        let node = this as BaseNode<MetricsTemplateConfig>
+      property.addInitializer(function(this: BaseNode<MetricsTemplateConfig>) {
+        const node = this;
         const valueSymbol = Symbol(`_${String(property.name)}_value`);
 
         Object.defineProperty(node, property.name, {
           get: function() {
-            if(this[valueSymbol]){
-              return this[valueSymbol];
+            if (this[valueSymbol]) return this[valueSymbol];
+
+            const config = node.config();
+
+            if (config.metricsEnabled) {
+              const _metrics = resolveContainer(config.metricsReference);
+              this[valueSymbol] = resolveMetric(node, metricsConfig, _metrics);
+            } else {
+              this[valueSymbol] = dudForType(metricsConfig);
             }
 
-            //console.log("injecting metric", valueSymbol);
-            let config = node.config();
-
-            if(config.metricsEnabled){
-              let _metrics = (NodeManager.RED.nodes.getNode(config.metricsReference) as any).node().metrics() as MetricsContainer;
-              
-              let nde = {
-                id:node.id(),
-                name:node.name(),
-                flow:node.flow(),
-                type:node.type()
-              }
-
-              // counter metric
-              if(metricsConfig.type === MetricType.Counter){
-                let counterConfig:CounterMetricConfig = {
-                  metricname:metricsConfig.name,
-                  metricdescription:metricsConfig.description,
-                  node:nde
-                };
-                this[valueSymbol] = _metrics.counter(counterConfig);
-                return this[valueSymbol];
-              }
-
-              // gauge metric
-              if(metricsConfig.type === MetricType.Gauge){
-                let gaugeConfig:GaugeMetricConfig = {
-                  metricname:metricsConfig.name,
-                  metricdescription:metricsConfig.description,
-                  node:nde
-                };
-                this[valueSymbol] = _metrics.gauge(gaugeConfig);
-                return this[valueSymbol];
-              }
-
-              // timer metric.
-              if(metricsConfig.type === MetricType.Timer){
-
-                // handle it as a histogram collector.
-                if(metricsConfig.collector === MetricCollectorType.histogram){
-
-                  // handle it as the default bucket.
-                  if(metricsConfig.buckettype === BucketType.default){
-                    let histogramConfig:HistogramMetricConfig = {
-                      metricname:metricsConfig.name,
-                      metricdescription:metricsConfig.description,
-                      buckettype:metricsConfig.buckettype,
-                      bucketconfig:{},
-                      node:nde
-                    };
-                    this[valueSymbol] = _metrics.histogram(histogramConfig);
-                    return this[valueSymbol];
-                  }
-                }
-              }
-              console.error("No Metric Factory type defined for ", metricsConfig);
-              return this[valueSymbol];
-            }        
-            
-            this[valueSymbol] =
-              (metricsConfig.type === MetricType.Counter) ? { inc(){}, reset(){} } as CounterMetric :
-              (metricsConfig.type === MetricType.Gauge)   ? { inc(){}, dec(){}, reset(){} } as GaugeMetric :
-              (metricsConfig.type === MetricType.Timer)   ? { observe(val:number){} } as HistogramMetric | SummaryMetric 
-              : undefined;
             return this[valueSymbol];
           },
           enumerable: true,
@@ -224,4 +196,4 @@ export function Metrics(metricsConfig: MetricsConfig):Function {
       });
     }
   };
-}
+}

package/src/core/metrics/node/CounterMetricConfigNode.ts

@@ -1,15 +1,15 @@
 
 import { Node } from "node-red";
-import { ConfigNode, ConfigNodeConfig, NodeDescriptor, NodeManager } from "../../NodeConstructor"
-import { MetricsContainer, MetricsService, MetricsReference, CounterMetric, CounterMetricConfig} from "../service/MetricsService"
+import { ConfigNode, ConfigNodeConfig, NodeManager } from "../../NodeConstructor"
+import { MetricsContainer, MetricsService, MetricsReference, CounterMetric, CounterMetricConfig, DoNothingMetricsContainer} from "../service/MetricsService"
 import { SourceUtility } from "../../NodeGenerator";
 import { MetricsConfigNode } from "./MetricsConfigNode";
 import { MetricsTemplate } from "../template/MetricsTemplate";
 import { NodeDescription } from "../../tagging/NodeDescriptionDecorator";
 
 interface CounterMetricConfigNodeConfig extends ConfigNodeConfig, CounterMetricConfig, MetricsReference {
-    description:string,
-    reset:boolean
+    description: string,
+    reset: boolean
 }
 
 @NodeDescription({
@@ -21,7 +21,7 @@ interface CounterMetricConfigNodeConfig extends ConfigNodeConfig, CounterMetricC
     templates:[
         { template:MetricsTemplate, config: {} }
     ],
-    dependencies:[ MetricsConfigNode, MetricsService ],
+    dependencies:[ MetricsService ],
     tags: [ "MetricType" ]
 })
 export class CounterMetricConfigNode extends ConfigNode<CounterMetricConfigNodeConfig> {
@@ -30,33 +30,33 @@ export class CounterMetricConfigNode extends ConfigNode<CounterMetricConfigNodeC
 
     constructor(node: Node, config: CounterMetricConfigNodeConfig){
         super(node, config);
-        let _this = this;
-
-        this._metrics = (NodeManager.RED.nodes.getNode(config.metricsReference) as any).node().metrics();
-        
-        let counterConfig:CounterMetricConfig = {
-            metricname:config.name,
-            metricdescription:config.description,
-            node:{
-                id:this.id(),
-                name:this.name(),
-                flow:this.flow(),
-                type:this.type()
+
+        const refNode = config.metricsEnabled && config.metricsReference ? NodeManager.RED.nodes.getNode(config.metricsReference) : null;
+        this._metrics = refNode ? (refNode as any).node().metrics() : new DoNothingMetricsContainer();
+
+        const counterConfig: CounterMetricConfig = {
+            metricname: config.name,
+            metricdescription: config.description,
+            node: {
+                id:   this.id(),
+                name: this.name(),
+                flow: this.flow(),
+                type: this.type()
             }
         };
 
         this._counter = this._metrics.counter(counterConfig);
 
-        if(config.reset){
+        if (config.reset) {
             this._counter.reset();
         }
     }
 
-    public metrics():MetricsContainer {
+    public metrics(): MetricsContainer {
         return this._metrics;
     }
 
-    public counter():CounterMetric {
+    public counter(): CounterMetric {
         return this._counter;
     }
 }

package/src/core/metrics/node/GaugeMetricConfigNode.ts

@@ -1,15 +1,14 @@
 
 import { Node } from "node-red";
-import { ConfigNode, ConfigNodeConfig, NodeDescriptor, NodeManager } from "../../NodeConstructor"
-import { MetricsContainer, MetricsService, GaugeMetricConfig, GaugeMetric, MetricsReference} from "../service/MetricsService"
+import { ConfigNode, ConfigNodeConfig, NodeManager } from "../../NodeConstructor"
+import { MetricsContainer, MetricsService, GaugeMetricConfig, GaugeMetric, MetricsReference, DoNothingMetricsContainer} from "../service/MetricsService"
 import { SourceUtility } from "../../NodeGenerator";
-import { MetricsConfigNode } from "./MetricsConfigNode";
 import { MetricsTemplate, MetricsTemplateConfig } from "../template/MetricsTemplate";
 import { NodeDescription } from "../../tagging/NodeDescriptionDecorator";
 
 interface GaugeMetricConfigNodeConfig extends ConfigNodeConfig, GaugeMetricConfig, MetricsTemplateConfig {
-    description:string,
-    reset:boolean
+    description: string,
+    reset: boolean
 }
 
 @NodeDescription({
@@ -19,9 +18,9 @@ interface GaugeMetricConfigNodeConfig extends ConfigNodeConfig, GaugeMetricConfi
     sourceFile:SourceUtility.getSourcePath("/build/", "/src/") + "GaugeMetricConfigNode.html",
     package: "@theotherwillembotha/node-red-plugincore",
     templates: [
-        { template: MetricsTemplate, config: {}}
+        { template: MetricsTemplate, config: {} }
     ],
-    dependencies:[ MetricsConfigNode, MetricsService ],
+    dependencies:[ MetricsService ],
     tags: [ "Core", "Metric" ]
 })
 export class GaugeMetricConfigNode extends ConfigNode<GaugeMetricConfigNodeConfig> {
@@ -30,33 +29,33 @@ export class GaugeMetricConfigNode extends ConfigNode<GaugeMetricConfigNodeConfi
 
     constructor(node: Node, config: GaugeMetricConfigNodeConfig){
         super(node, config);
-        let _this = this;
-
-        this._metrics = (NodeManager.RED.nodes.getNode(config.metricsReference) as any).node().metrics();
-        
-        let gaugeConfig:GaugeMetricConfig = {
-            metricname:config.name,
-            metricdescription:config.description,
-            node:{
-                id:this.id(),
-                flow:this.flow(),
-                type:this.type(),
-                name:this.name()
+
+        const refNode = config.metricsEnabled && config.metricsReference ? NodeManager.RED.nodes.getNode(config.metricsReference) : null;
+        this._metrics = refNode ? (refNode as any).node().metrics() : new DoNothingMetricsContainer();
+
+        const gaugeConfig: GaugeMetricConfig = {
+            metricname: config.name,
+            metricdescription: config.description,
+            node: {
+                id:   this.id(),
+                flow: this.flow(),
+                type: this.type(),
+                name: this.name()
             }
         };
-        
+
         this._gauge = this._metrics.gauge(gaugeConfig);
-        
-        if(config.reset){
-            _this._gauge.reset();
+
+        if (config.reset) {
+            this._gauge.reset();
         }
     }
 
-    public metrics():MetricsContainer {
+    public metrics(): MetricsContainer {
         return this._metrics;
     }
 
-    public gauge():GaugeMetric {
+    public gauge(): GaugeMetric {
         return this._gauge;
     }
 }

package/src/core/metrics/node/MetricsConfigNode.ts

@@ -1,55 +1,36 @@
-
 import { Node } from "node-red";
-import { ConfigNode, ConfigNodeConfig, NodeDescriptor } from "../../NodeConstructor"
-import { MetricsContainer, MetricsService} from "../service/MetricsService"
-import { SourceUtility } from "../../NodeGenerator";
-import { WebhookTemplate, WebhookTemplateConfig } from "../../webhook/template/WebhookTemplate";
-import { Webhook } from "../../webhook/WebhookDecorator";
-import { EndpointMethodType } from "../../webhook/service/WebhookServerService";
-import  {register as PrometheusRegistry, } from "prom-client";
-import express, { Request, Response, Express } from 'express';
-import { NodeDescription } from "../../tagging/NodeDescriptionDecorator";
-
-/*
-Note: the MetricsConfigNode does not actually do the deployment of the metrics / repositories.
-The metrics / repositories are menanaged by the plugin and triggered when the flows are deployed.
-
-The reasoning for this is that the Metrics exist outside of the flow, but is configured using the flow.
-Basically, if the metrics arent changed, we dont have to redeploy the metrics, which means that
-stuff like coutners, gauges and timers are not reset.
-*/
-interface MetricsConfigNodeConfig extends ConfigNodeConfig, WebhookTemplateConfig {
-}
-
-@NodeDescription({
-    id:"MetricsConfigNode",
-    name:"Metrics Config Node",
-    group:"config",
-    sourceFile:SourceUtility.getSourcePath("/build/", "/src/") + "MetricsConfigNode.html",
-    package: "@theotherwillembotha/node-red-plugincore",
-    templates:[
-        { template:WebhookTemplate, config: {} }
-    ],
-    dependencies:[ MetricsService ],
-    tags: [ ]
-})
-export class MetricsConfigNode extends ConfigNode<MetricsConfigNodeConfig> {
-    private _metrics!: MetricsContainer;
-
-    constructor(node: Node, config: MetricsConfigNodeConfig){
+import { ConfigNode, ConfigNodeConfig } from "../../NodeConstructor"
+import { MetricsContainer, MetricsService, MetricsConfig } from "../service/MetricsService"
+
+/**
+ * Abstract base for all metrics provider config nodes.
+ *
+ * Concrete implementations (e.g. PrometheusMetricsConfigNode) extend this class,
+ * decorate with @NodeDescription + tags: ["MetricsProvider"], and implement
+ * createContainer() to return their backend-specific MetricsContainer.
+ *
+ * This class is intentionally NOT decorated with @NodeDescription - it is never
+ * registered as a Node-RED node type directly. Only concrete subclasses are registered.
+ */
+export abstract class MetricsConfigNode extends ConfigNode<ConfigNodeConfig> {
+
+    constructor(node: Node, config: ConfigNodeConfig) {
         super(node, config);
-        let _this = this;
-
-        this._metrics = MetricsService.get({metricsEnabled:false, metricsReference:this.id()});
+        MetricsService.register(
+            config.id,
+            { id: config.id },
+            () => this.createContainer({ id: config.id })
+        );
     }
 
-    public metrics():MetricsContainer {
-        return this._metrics;
-    }
+    /**
+     * Called once on construction to create the backend MetricsContainer.
+     * MetricsService preserves the container across redeploys if the config
+     * has not changed, so metric state (counters, gauges) is not reset.
+     */
+    protected abstract createContainer(config: MetricsConfig): MetricsContainer;
 
-    @Webhook({name:"MetricsConfigNode", methods:[EndpointMethodType.GET]})
-    private onWebhookRequest(request:Request, response:Response):void {
-        response.set('Content-Type', PrometheusRegistry.contentType);
-        this._metrics.registry().metrics().then((data:any) => response.status(200).send(data))
+    public metrics(): MetricsContainer {
+        return MetricsService.get({ metricsEnabled: true, metricsReference: this.id() });
     }
 }