@theotherwillembotha/node-red-plugincore 0.0.53 → 0.0.55

package/src/core/logger/LoggerDecorator.ts

@@ -1,7 +1,6 @@
 import { BaseNode, NodeManager } from "../NodeConstructor";
-import { Log, LoggerRegistration } from "./service/LoggerService";
-import { LoggerTemplateConfig } from "./template/LoggerTemplate";
-
+import { AbstractLogger, Log, BaseLoggerConfig, DoNothingAppender, LoggerConfigNode, LoggerConfigNodeConfig } from "./service/LoggerService";
+import { LoggerTemplateConfig, LoggerTemplateNodeConfig } from "./template/LoggerTemplate";
 
 export function Logger(debug?:string):Function {
 
@@ -10,41 +9,43 @@ export function Logger(debug?:string):Function {
     // if the type is a string, then its probably defined in the local (core) module.
     if(typeof propertyKey ===  "string"){
       const valueSymbol = Symbol(`_${String(propertyKey)}_value`);
+
+      //console.log("BINDING:", "target", target, "propertyKey", propertyKey );
       
       Object.defineProperty(target, propertyKey, {
         get: function() {
+
+          //console.log("setting logger on node " + this.name() + " (localized)");
           
           if(!this[valueSymbol]){
-              let node = this as BaseNode<LoggerTemplateConfig>;
-              //console.log("setting logger on node " + node.name() + " (localized)");
-              let config = node.config();
-              let logger;
 
-              if(config.logEnabled){
-                let registration:LoggerRegistration = {
+              try{
+                let node = this as BaseNode<LoggerTemplateNodeConfig>;
+                let config = node.config();
+
+                if(!config.logEnabled){
+                  return this[valueSymbol] = DoNothingAppender.get();
+                }
+
+                // get the logger config node.
+                let loggerConfigNode:LoggerConfigNode<LoggerConfigNodeConfig, AbstractLogger<BaseLoggerConfig>> =(NodeManager.RED.nodes.getNode(config.logger) as any).node();
+
+                let loggerTemplateConfig:LoggerTemplateConfig = {
                   id:config.id,
                   flow:node.flow(),
                   type:node.type(),
                   name:node.name(),
-                  enabled:config.logEnabled,
-                  override:config.logTemplateOverrideEnabled,
-                  template:config.logTemplateOverride
+                  level:loggerConfigNode.config().level,
+                  template: (config.logTemplateOverrideEnabled) ? config.logTemplateOverride : loggerConfigNode.config().template,
                 };
-              
+
                 // get a reference to the loggerService.
-                try{
-                  logger = (NodeManager.RED.nodes.getNode(config.logger) as any).node().registerLogger(registration) as Log;
-                }
-                catch(e){
-                  console.log("failed getting logger ", config.logger, e);
-                  logger = { log(){} };
-                }
+                return this[valueSymbol] = loggerConfigNode.registerTemplate(loggerTemplateConfig);
               }
-              else{
-                logger = { log(){} };
+              catch(e){
+                console.log(`failed getting logger "${this?.config()?.logger}"`, e);
+                return this[valueSymbol] = DoNothingAppender.get();
               }
-
-              this[valueSymbol] = logger;
           }
           return this[valueSymbol];
         },
@@ -55,43 +56,45 @@ export function Logger(debug?:string):Function {
     }
     else{
       let property = propertyKey as any;
-      //property.addInitializer(() => {
-      property.addInitializer(function(this:BaseNode<LoggerTemplateConfig>){
-        let node = this as BaseNode<LoggerTemplateConfig>
+
+      property.addInitializer(function(this:BaseNode<LoggerTemplateNodeConfig>){
+        let node = this as BaseNode<LoggerTemplateNodeConfig>
         const valueSymbol = Symbol(`_${String(property.name)}_value`);
+
+        //console.log("ADDING INITIALIZER:", "node", node, "property.name", property.name );
+
         Object.defineProperty(node, property.name, {
           get: function() {
+
+            //console.log("setting logger on node " + node.name()+ " (externalized)");
             
             if(!this[valueSymbol]){
-                //console.log("setting logger on node " + node.name()+ " (externalized)");
+              try{
                 let config = node.config();
-                let logger;
-
-                if(config.logEnabled){
-                  let registration:LoggerRegistration = {
-                    id:config.id,
-                    flow:node.flow(),
-                    type:node.type(),
-                    name:node.name(),
-                    enabled:config.logEnabled,
-                    override:config.logTemplateOverrideEnabled,
-                    template:config.logTemplateOverride
-                  };
-                
-                  // get a reference to the loggerService.
-                  try{
-                    logger = (NodeManager.RED.nodes.getNode(config.logger) as any).node().registerLogger(registration) as Log;
-                  }
-                  catch(e){
-                    console.log("failed getting logger ", config.logger, e);
-                    logger = { log(){} };
-                  }
-                }
-                else{
-                  logger = { log(){} };
+
+                if(!config.logEnabled){
+                  return this[valueSymbol] = DoNothingAppender.get();
                 }
 
-                this[valueSymbol] = logger;
+                // get the logger config node.
+                let loggerConfigNode:LoggerConfigNode<LoggerConfigNodeConfig, AbstractLogger<BaseLoggerConfig>> =(NodeManager.RED.nodes.getNode(config.logger) as any).node();
+
+                let loggerTemplateConfig:LoggerTemplateConfig = {
+                  id:config.id,
+                  flow:node.flow(),
+                  type:node.type(),
+                  name:node.name(),
+                  level: loggerConfigNode?.config().level ?? 'info',
+                  template: (config.logTemplateOverrideEnabled) ? config.logTemplateOverride : (loggerConfigNode?.config().template ?? 'message:{{msg}}'),
+                };
+
+                // get a reference to the loggerService.
+                return this[valueSymbol] = loggerConfigNode.registerTemplate(loggerTemplateConfig);
+              }
+              catch(e){
+                console.log("failed getting logger ", e);
+                return this[valueSymbol] = DoNothingAppender.get();
+              }
             }
             return this[valueSymbol];
           },

package/src/core/logger/node/ConsoleLoggerConfigNode.ts

@@ -1,13 +1,11 @@
 
 import { Node } from "node-red";
-import { ConfigNode, ConfigNodeConfig } from "../../NodeConstructor"
-import { NewLogger, Log, LoggerRegistration, LoggerService } from "../service/LoggerService"
+import { LoggerService, LoggerConfigNodeConfig, BaseLoggerConfig, AbstractLogger, TagMap, LoggerConfigNode, Log, Level } from "../service/LoggerService"
 import { SourceUtility } from "../../NodeGenerator";
-import { Level, PlatformType } from "../service/LoggerServiceTypes";
 import { NodeDescription } from "../../tagging/NodeDescriptionDecorator";
+import { LoggerTemplateConfig } from "../template/LoggerTemplate";
 
-interface ConsoleLoggerConfigNodeConfig extends ConfigNodeConfig {
-    id: string;
+interface ConsoleLoggerConfigNodeConfig extends LoggerConfigNodeConfig {
     level:Level;
     template:string;
 }
@@ -21,26 +19,53 @@ interface ConsoleLoggerConfigNodeConfig extends ConfigNodeConfig {
     dependencies:[ LoggerService ],
     tags: [ "LoggerType" ]
 })
-export class ConsoleLoggerConfigNode extends ConfigNode<ConsoleLoggerConfigNodeConfig> {
+export class ConsoleLoggerConfigNode extends LoggerConfigNode<ConsoleLoggerConfigNodeConfig, ConsoleLogger> {
     
-    private _logger!: NewLogger<any>;
+    private _logger!: ConsoleLogger;
     
     constructor(node: Node, config: ConsoleLoggerConfigNodeConfig){
         super(node, config);
         let _this = this;
 
-        // instantiate the logger.
-        let loggerConfig = {
+        // create logger config
+        let loggerConfig:ConsoleLoggerConfig = {
             id:this.id(),
-            type:PlatformType.console,
-            template:config.template,
+            type:"CONSOLE",
             level:config.level,
+            template:config.template,
         }
 
-        this._logger = LoggerService.get(loggerConfig);
+        // create logger instance:
+        this._logger = new ConsoleLogger(loggerConfig);
     }
 
-    public registerLogger(registration:LoggerRegistration):Log {
-        return this._logger.register(registration)
+    protected logger():ConsoleLogger{
+        return this._logger;
     }
 }
+
+export interface ConsoleLoggerConfig extends BaseLoggerConfig  {
+    // no additional values.
+}
+
+class ConsoleLogger extends AbstractLogger<ConsoleLoggerConfig> {
+
+    constructor(config:ConsoleLoggerConfig){
+        super(config);
+    }
+
+    protected createLogger(config: LoggerTemplateConfig): Log {
+        return new ConsoleAppender(config);
+    }
+}
+
+class ConsoleAppender extends Log {
+
+    constructor(config:LoggerTemplateConfig){
+        super(config);
+    }
+
+    protected writeToLog(level:string, message: string, tags: { [key: string]: string | boolean | number; }): void {
+        console.log(new Date().toISOString(), this.config().id, level, tags, message)
+    }
+}

package/src/core/logger/node/RestLoggerConfigNode.ts

@@ -1,19 +1,23 @@
 
 import { Node } from "node-red";
-import { ConfigNode, ConfigNodeConfig, NodeDescriptor } from "../../NodeConstructor"
-import { NewLogger, Log, LoggerRegistration, LoggerService, RestLoggerConfig } from "../service/LoggerService"
+import {ConfigNodeConfig } from "../../NodeConstructor"
+import { LoggerService, LoggerConfigNode, AbstractLogger, BaseLoggerConfig, TagMap, Log } from "../service/LoggerService"
 import { SourceUtility } from "../../NodeGenerator";
-import { ApiKeyMechanismType, Level, PlatformType, RestAuthType } from "../service/LoggerServiceTypes";
+import { ApiKeyMechanismType, Level, RestAuthType } from "../service/LoggerService";
 import { NodeDescription } from "../../tagging/NodeDescriptionDecorator";
+import { LoggerTemplateConfig } from "../template/LoggerTemplate";
+import { parseURL, URLRecord } from "whatwg-url";
+import { HttpTransportOptions } from "winston/lib/winston/transports";
+import { createLogger, format, transports, Logger } from "winston";
 
 interface RestLoggerConfigNodeConfig extends ConfigNodeConfig {
 
     id: string;
-    platform: PlatformType;
     level:Level;
     template:string;
     
     rest_url: string;
+    rest_ignoresslerror:boolean;
     rest_auth_type: RestAuthType;
     rest_auth_basic_username:string;
     rest_auth_basic_password:string;
@@ -31,37 +35,136 @@ interface RestLoggerConfigNodeConfig extends ConfigNodeConfig {
     dependencies:[ LoggerService ],
     tags: [ "LoggerType" ]
 })
-export class RestLoggerConfigNode extends ConfigNode<RestLoggerConfigNodeConfig> {
+export class RestLoggerConfigNode extends LoggerConfigNode<RestLoggerConfigNodeConfig, RestLogger> {
     
-    private _logger!: NewLogger<any>;
+    private _logger!: RestLogger;
     
     constructor(node: Node, config: RestLoggerConfigNodeConfig){
         super(node, config);
         let _this = this;
 
         // instantiate the logger.
-        let loggerConfig:any;
-
-        if(config.platform === PlatformType.rest){
-            loggerConfig = {
-                id:this.id(),
-                type:PlatformType.rest,
-                template:config.template,
-                level:config.level,
-                url: config.rest_url,
-                auth_type: config.rest_auth_type,
-                auth_basic_username:config.rest_auth_basic_username,
-                auth_basic_password:config.rest_auth_basic_password,
-                auth_apikey_mechanism:config.rest_auth_apikey_mechanism,
-                auth_apikey_name:config.rest_auth_apikey_name,
-                auth_apikey_value:config.rest_auth_apikey_value,
-            } as RestLoggerConfig;
+        let loggerConfig:RestLoggerConfig = {
+            id:this.id(),
+            type:"REST",
+            level:config.level,
+            template:config.template,
+            
+            // additional properties.
+            url: config.rest_url,
+            ignoresslerror:config.rest_ignoresslerror,
+            auth_type: config.rest_auth_type,
+            auth_basic_username:config.rest_auth_basic_username,
+            auth_basic_password:config.rest_auth_basic_password,
+            auth_apikey_mechanism:config.rest_auth_apikey_mechanism,
+            auth_apikey_name:config.rest_auth_apikey_name,
+            auth_apikey_value:config.rest_auth_apikey_value,
+        };
+
+        this._logger = new RestLogger(loggerConfig);
+    }
+
+    protected logger():RestLogger{
+        return this._logger;
+    }
+}
+
+class RestLogger extends AbstractLogger<RestLoggerConfig> {
+
+    private winston:Logger;
+
+    constructor(config:RestLoggerConfig){
+        super(config);
+
+        // get the url.
+        let hosturl:URLRecord|null = parseURL(config.url);
+        if(!hosturl){
+            throw Error("could not parse url: " + config.url);
+        }
+
+        // get the options
+        let httpOptions:{[key:string]:any} = {}
+        
+        // get the params.
+        let httpParams:HttpTransportOptions = {
+            host:hosturl.host?.toString(),
+            path:"/" + (hosturl.path ? [...hosturl.path].join("/") : "") + (hosturl.query ? ("?" + hosturl.query) : ""),
+            port:(hosturl.port) ? hosturl.port : undefined,
+            ssl:hosturl.scheme.toLowerCase() === "https",
+            headers: {},
+        };        
+        (httpParams as any).options = httpOptions;
+
+        // add the ignore ssl error flag if need be.
+        if(config.ignoresslerror){
+            httpOptions.rejectUnauthorized = false;
         }
 
-        this._logger = LoggerService.get(loggerConfig);
+        // configure "none" authentication.
+        if(config.auth_type === RestAuthType.none){}
+
+
+        // configure "basic" authentication.
+        if(config.auth_type === RestAuthType.basic){
+            httpParams.auth = {
+                username: config.auth_basic_username,
+                password: config.auth_basic_password
+            }
+        }
+
+        // configure "apikey" authentication.
+        if(config.auth_type === RestAuthType.apikey){
+            if(config.auth_apikey_mechanism === ApiKeyMechanismType.header) {
+                (httpParams.headers as any)[config.auth_apikey_name] = config.auth_apikey_value;
+            }
+            if(config.auth_apikey_mechanism === ApiKeyMechanismType.matrixparam) {
+                httpParams.path = httpParams.path?.replace(`:${config.auth_apikey_name}`, config.auth_apikey_value);
+            }
+            if(config.auth_apikey_mechanism === ApiKeyMechanismType.queryparam) {
+                httpParams.path = httpParams.path + (httpParams.path?.includes("?") ? "&" : "?") + config.auth_apikey_name + "=" + config.auth_apikey_value;
+            }
+        };
+
+        this.winston = createLogger({
+            level: config.level.toString().toLowerCase(),
+            format: format.json(),
+            defaultMeta: {},
+            transports: [
+                new transports.Http(httpParams),
+            ],
+        });
+    }
+
+    protected createLogger(config: LoggerTemplateConfig): Log {
+        return new RestAppender(config, this.winston);
+    }
+}
+
+class RestAppender extends Log {
+    private winston: Logger;
+
+    constructor(config:LoggerTemplateConfig, winston:Logger){
+        super(config);
+        this.winston = winston;
     }
 
-    public registerLogger(registration:LoggerRegistration):Log {
-        return this._logger.register(registration)
+    protected writeToLog(level:string, message: string, tags: { [key: string]: string | boolean | number; }): void {
+        this.winston.log({
+            level:level,
+            message:message, 
+            labels:tags
+        });
     }
+
 }
+
+interface RestLoggerConfig extends BaseLoggerConfig {
+    url: string;
+    ignoresslerror:boolean;
+    auth_type: RestAuthType;
+    auth_basic_username:string;
+    auth_basic_password:string;
+    auth_apikey_mechanism:ApiKeyMechanismType;
+    auth_apikey_name:string;
+    auth_apikey_value:string;
+}