@theotherwillembotha/node-red-plugincore 0.0.54 → 0.0.55

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;
+}

package/src/core/logger/service/LoggerService.ts

@@ -1,15 +1,9 @@
 
-import {BaseService, ServiceDescriptor } from "../../NodeConstructor";
-import { NodeAPI, NodeAPISettingsWithData } from "node-red";
+import {BaseService, ServiceDescriptor, ConfigNodeConfig, ConfigNode } from "../../NodeConstructor";
+import { NodeAPI, NodeAPISettingsWithData, Node } from "node-red";
 import Handlebars from "handlebars";
-import { createLogger, format, transports } from "winston";
-import LokiTransport from "winston-loki";
-import { URLRecord, parseURL } from 'whatwg-url';
-import { LoggerTemplate } from "../template/LoggerTemplate";
+import { LoggerTemplate, LoggerTemplateConfig } from "../template/LoggerTemplate";
 var network = require('network');
-import deepEqual from "deep-equal";
-import { HttpTransportOptions } from "winston/lib/winston/transports";
-import { ApiKeyMechanismType, Level, PlatformType, RestAuthType } from "./LoggerServiceTypes";
 
 // helper for serializing json objects inside handlebars tags.
 // you can then convert it like this: {{{json myobject}}}
@@ -17,248 +11,108 @@ Handlebars.registerHelper('json', function(context) {
     return JSON.stringify(context);
 });
 
-type TagMap = { 
-    instance: string; 
-    flow: string; 
-    node: string; 
-    type: string; 
-    id: string; 
+export enum Level{
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARNING = "WARNING",
+    ERROR = "ERROR"
 }
 
-export type Log = {
-    log(message:{[key:string]:any}|string):void;
+export enum RestAuthType {
+    none="none",
+    basic="basic",
+    apikey="apikey",
 }
 
-export class LogImplementation implements Log {
-    
-    private root: NewLogger<any>; 
-    private config:LoggerRegistration;
-    private template?:HandlebarsTemplateDelegate<any>;
-    private tagMap:TagMap;
-    
-    constructor(root:NewLogger<any>, config:LoggerRegistration){
-        this.root = root;
-        this.config = config;
-        this.template = (config.override && config.template) ? Handlebars.compile(config.template) : undefined;
-        this.tagMap = {
-            instance:LoggerService.instanceID,
-            flow:config.flow,
-            node:config.name,
-            type:config.type,
-            id:config.id,
-        };
-    }
-
-    public log(message:{[key:string]:any}|string){
-        // enrich the logged content with additional properties.
-        let content = {
-            currentTime: new Date().toISOString(),
-            msg: message,
-        }
-
-        // send typ the logger.
-        this.root.log(this, content);
-    }
-
-    public serialize(content:{[key:string]:any}) {
-        return !!this.template ? this.template(content) : this.root.serialize(content);
-    }
-
-    public getTags() {
-        return this.tagMap;
-    }
+export enum ApiKeyMechanismType {
+    header="header",
+    queryparam="queryparam",
+    matrixparam="matrixparam",
 }
 
-export interface BaseLoggerConfig {
-    id:string;
-    type:PlatformType;
-    level: Level;
-    template:string;
+export type TagMap = { 
+    id: string; 
+    node: string; 
+    type: string; 
+    flow: string; 
+    instance: string; 
 }
 
-export abstract class NewLogger<ConfigType extends BaseLoggerConfig> {
-    private _config: ConfigType;
-    private template: HandlebarsTemplateDelegate<string>;
+export abstract class Log  {
+    private _config: LoggerTemplateConfig;
+    private template: HandlebarsTemplateDelegate<any>;
+    private tags:TagMap;
 
-    constructor(config:ConfigType){
+    protected constructor(config:LoggerTemplateConfig){
         this._config = config;
         this.template = Handlebars.compile(config.template);
-    }
-
-    public log(reference:LogImplementation, content:{[key:string]:any}) {
-        try{
-            // step 1, attempt to serialize the content.
-            let serializedContent = reference.serialize(content);
-
-            // step 2, get the tags.
-            let tags = reference.getTags();
-
-            // step 3. write to the logger.
-            this.writeToLog(serializedContent, tags);
+        this.tags = {
+            id: config.id,
+            node: config.name,
+            type: config.type,
+            flow: config.flow,
+            instance: LoggerService.instanceID
         }
-        catch(exception){
-            console.log((exception as any).message);
-        }
-    }
-
-    public register(registration:LoggerRegistration):Log{
-        return new LogImplementation(this, registration);
     }
 
-    public serialize(content: any) {
-        return this.template(content);
-    }
-
-    public config():ConfigType {
+    protected config():LoggerTemplateConfig{
         return this._config;
     }
 
-    protected abstract writeToLog(serializedContent: string, tags: TagMap):void;
-}
-
-export interface ConsoleLoggerConfig extends BaseLoggerConfig  {
-
-}
-
-class ConsoleLogger extends NewLogger<ConsoleLoggerConfig> {
-
-    constructor(config:ConsoleLoggerConfig){
-        super(config);
-    }
-
-    protected writeToLog(serializedContent: string, tags: TagMap): void {
-        console.log(tags, serializedContent);
-    } 
-}
-
-export interface LokiLoggerConfig extends BaseLoggerConfig{
-    type:PlatformType.loki;
-    host:string;
-    userid?:string;
-    authtoken?:string;
-    tenantid?:string;
-}
-
-class LokiLogger extends NewLogger<LokiLoggerConfig>{
-    logger: any;
+    public log(payload:{[key:string]:any}|string):void{
+        try{
+            // step 1. serialize the payload using the template engine.
+            let message = (payload instanceof String) ? payload as string : this.template({msg:payload});
 
-    constructor(config:LokiLoggerConfig){
-        super(config);
-        
-        let transportConfig = {
-            host: config.host,
-            json: true,
-            format: format.json(),
-            headers: {
-                "X-Scope-OrgID": (config.tenantid) ? config.tenantid : undefined
-            },
-            replaceTimestamp: true,
-            onConnectionError: (err:unknown) => console.error(err),
-            basicAuth: (config.userid && config.authtoken) 
-                ? `${config.userid}:${config.authtoken}`
-                : undefined
+            // step 2. write to the log appender.
+            this.writeToLog(this.config().level, message, this.tags);
+        }
+        catch(e){
+            console.log(e);
         }
-
-        this.logger = createLogger({
-            level: this.config().level.toString().toLowerCase(),
-            format: format.json(),
-            defaultMeta: {},
-            transports: [
-              new LokiTransport(transportConfig),
-            ],
-        });
-    }
-
-    protected writeToLog(serializedContent: string, tags: TagMap): void {
-        this.logger.log({message:serializedContent, level:this.logger.level, labels:tags});
     }
+    
+    protected abstract writeToLog(level:string, message:string, tags:{[key:string]:string|boolean|number}):void;
 }
 
-export interface RestLoggerConfig extends BaseLoggerConfig{
-    type:PlatformType.rest;
-    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;
+export type BaseLoggerConfig = {
+    id:string;
+    type:string;
+    level: Level;
+    template:string;
 }
 
-class RestLogger extends NewLogger<RestLoggerConfig>{
-    logger: any;
-
-    constructor(config:RestLoggerConfig){
-        super(config);
-
-        let hosturl:URLRecord|null = parseURL(config.url);
+export abstract class AbstractLogger<BaseLoggerConfig>{
     
-        if(!hosturl){
-            throw Error("could not parse url: " + config.url);
-        }
-
-        let httpOptions:{[key:string]:any} = {}
-
-        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;
-
-        if(config.ignoresslerror){
-            httpOptions.rejectUnauthorized = false;
-        }
+    private _config: BaseLoggerConfig;
+    private _appenders:{[key:string]:Log} = {};
+    
+    constructor(config:BaseLoggerConfig){
+        this._config = config;
+    }
 
-        if(config.auth_type === RestAuthType.none){}
+    public config():BaseLoggerConfig{
+        return this._config;
+    }
 
-        if(config.auth_type === RestAuthType.basic){
-            httpParams.auth = {
-                username: config.auth_basic_username,
-                password: config.auth_basic_password
-            }
+    public registerTemplate(config: LoggerTemplateConfig): Log{
+        let appender:Log = this._appenders[config.id];
+        if(appender){
+            return appender;
         }
-        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.logger = createLogger({
-            level: config.level.toString().toLowerCase(),
-            format: format.json(),
-            defaultMeta: {},
-            transports: [
-                new transports.Http(httpParams),
-            ],
-        });
-    }
+        
+        let _this = this;
 
-    protected writeToLog(serializedContent: string, tags: TagMap): void {
-        this.logger.log({level:this.logger.level, message:serializedContent, labels:tags});
+        this._appenders[config.id] = appender = this.createLogger(config);
+        return appender;
     }
-}
 
-let LoggerTypes:{[key:string]:any} = {
-    console: ConsoleLogger,
-    loki: LokiLogger,
-    rest: RestLogger
+    protected abstract createLogger(config: LoggerTemplateConfig):Log;
 }
 
 export class LoggerService extends BaseService {
 
     public static instanceID:string;
-
-    private static loggers:{[key:string]:NewLogger<BaseLoggerConfig>} = {};
     private red!: NodeAPI<NodeAPISettingsWithData>;
 
     constructor(){
@@ -277,22 +131,6 @@ export class LoggerService extends BaseService {
 
     public deinit(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void> {}
 
-    public static get <ConfigType extends BaseLoggerConfig>(config:ConfigType): NewLogger<ConfigType>{
-
-        let logger:NewLogger<ConfigType>  = this.loggers[config.id] as NewLogger<ConfigType>;
-
-        if(logger){
-            if(!deepEqual(config, logger.config())){
-                this.loggers[config.id] = (logger = new (LoggerTypes[config.type])(config));
-            }
-        }
-        else{
-            this.loggers[config.id] = (logger = new (LoggerTypes[config.type])(config));
-        }
-
-        return logger;
-    }
-
     static override getServiceDescriptor():ServiceDescriptor {
         return new ServiceDescriptor(
             "@theotherwillembotha/loggerservice",
@@ -305,12 +143,38 @@ export class LoggerService extends BaseService {
     }
 }
 
-export type LoggerRegistration = {
-    id:string;
-    flow:string;
-    type:string;
-    name:string;
-    enabled:boolean;
-    template?:string;
-    override?:boolean;
+export type LoggerConfigNodeConfig = ConfigNodeConfig & BaseLoggerConfig & {}
+
+export abstract class LoggerConfigNode<CNC extends LoggerConfigNodeConfig, LoggerType extends AbstractLogger<BaseLoggerConfig>> extends ConfigNode<CNC> {
+    
+    protected constructor(node:Node, config: CNC){
+        super(node, config);
+    }
+
+    protected abstract logger():LoggerType;
+    
+    public registerTemplate(config: LoggerTemplateConfig): Log {
+        return this.logger().registerTemplate(config);
+    }
 }
+
+export class DoNothingAppender extends Log{
+
+    private static instance:DoNothingAppender = new DoNothingAppender();
+
+    static get(): any {
+      return DoNothingAppender.instance;
+    }
+
+    private constructor(){
+        super({flow:"",id:"", level:"", name:"", template:"", type:""});
+    }
+
+    public log(payload:{[key:string]:any}|string):void{
+        // do nothing.
+    }
+
+    protected writeToLog(level:string, message: string, tags: { [key: string]: string | boolean | number; }): void {
+        // do nothing.
+    }
+}