@theotherwillembotha/node-red-plugincore 0.0.53 → 0.0.55

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

package/src/core/logger/template/LoggerTemplate.ts

@@ -1,13 +1,23 @@
 import { SourceUtility } from "../../NodeGenerator";
 import { BaseNodeConfig, Template, TemplateDescriptor } from "../../NodeConstructor"
 
-export interface LoggerTemplateConfig extends BaseNodeConfig{
+// TODO: we need to prefix logger teplate properties with logtemplate_
+export interface LoggerTemplateNodeConfig extends BaseNodeConfig{
     logEnabled:boolean,
     logger:string,
     logTemplateOverrideEnabled:boolean,
     logTemplateOverride:string;
 }
 
+export type LoggerTemplateConfig = {
+    id:string;
+    flow:string;
+    type:string;
+    name:string;
+    template:string;
+    level:string;
+}
+
 export class LoggerTemplate extends Template {
 
     

package/src/core/webhook/WebhookDecorator.ts

@@ -1,4 +1,4 @@
-import { RestAuthType } from "../logger/service/LoggerServiceTypes";
+import { RestAuthType } from "../logger/service/LoggerService";
 import { BaseNode, createPostConstructDecorator, NodeManager } from "../NodeConstructor";
 import { ProxyManagerClient } from "./service/ReverseProxyTypeService";
 import { ApiKeyAuthenticationConfig, BasicAuthenticationConfig, EndpointConfig, EndpointMethodType, NoAuthenticationConfig, WebhookServer } from "./service/WebhookServerService";
@@ -45,8 +45,6 @@ const Webhook = createPostConstructDecorator<WebhookConfig>('Webhook')
                     let proxyClient = reverseProxyNode.client() as ProxyManagerClient;
 
                     console.log("List of known hosts: ", await proxyClient.getHosts());
-
-
                     //console.log("ADD REVERSE PROXY:" + proxy.proxy + " to " + node.id(), proxyClient);
                 }
                 catch(e){

package/src/core/webhook/service/ReverseProxyTypeService.ts

@@ -24,10 +24,6 @@ export interface ProxyManagerClient {
     getHosts():Promise<Partial<HostEntry>[]>;
 }
 
-export abstract class ReverseProxyClient {
-
-}
-
 export type HostEntry = {
     id:number,
     domainNames:string[],

package/src/core/webhook/service/WebhookServerService.ts

@@ -5,7 +5,7 @@ import { WebhookServerConfigNode } from "../node/WebhookServerConfigNode";
 import { WebhookTemplate } from "../template/WebhookTemplate";
 import express, {Express, Request, Response} from "express";
 import { Server } from "http";
-import { ApiKeyMechanismType, RestAuthType } from "../../logger/service/LoggerServiceTypes";
+import { ApiKeyMechanismType, RestAuthType } from "../../logger/service/LoggerService";
 
 var bodyParser = require('body-parser');
 

package/src/core/webhook/template/WebhookTemplate.ts

@@ -1,7 +1,7 @@
 import { BaseNodeConfig, Template, TemplateDescriptor } from "../../NodeConstructor"
 import { WebhookServerConfigNode } from "../node/WebhookServerConfigNode";
 import { SourceUtility } from "../../NodeGenerator";
-import { ApiKeyMechanismType, RestAuthType } from "../../logger/service/LoggerServiceTypes";
+import { RestAuthType, ApiKeyMechanismType } from "../../logger/service/LoggerService";
 
 export interface WebhookTemplateConfig extends BaseNodeConfig{
     webhook:string,

package/src/index.ts

@@ -4,10 +4,10 @@ export * from "./core/NodeConstructor";
 
 // LOGGER
 export * from "./core/logger/service/LoggerService";
-export * from "./core/logger/template/LoggerTemplate";
 export * from "./core/logger/node/ConsoleLoggerConfigNode";
 export * from "./core/logger/node/RestLoggerConfigNode";
-export * from "./core/logger/node/LokiLoggerConfigNode";
+export * from "./core/logger/template/LoggerTemplate";
+
 
 // METRICS
 export * from "./core/metrics/service/MetricsService";

package/build/core/logger/node/LokiLoggerConfigNode.d.ts

@@ -1,20 +0,0 @@
-import { Node } from "node-red";
-import { ConfigNode, ConfigNodeConfig } from "../../NodeConstructor";
-import { Log, LoggerRegistration } from "../service/LoggerService";
-import { Level } from "../service/LoggerServiceTypes";
-interface LokiLoggerConfigNodeConfig extends ConfigNodeConfig {
-    id: string;
-    level: Level;
-    template: string;
-    loki_host: string;
-    loki_userid?: string;
-    loki_authtoken?: string;
-    loki_tenantid?: string;
-}
-export declare class LokiLoggerConfigNode extends ConfigNode<LokiLoggerConfigNodeConfig> {
-    private _logger;
-    constructor(node: Node, config: LokiLoggerConfigNodeConfig);
-    registerLogger(registration: LoggerRegistration): Log;
-}
-export {};
-//# sourceMappingURL=LokiLoggerConfigNode.d.ts.map

package/build/core/logger/node/LokiLoggerConfigNode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LokiLoggerConfigNode.d.ts","sourceRoot":"","sources":["../../../../src/core/logger/node/LokiLoggerConfigNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,EAAa,GAAG,EAAE,kBAAkB,EAAiB,MAAM,0BAA0B,CAAA;AAE5F,OAAO,EAAE,KAAK,EAAgB,MAAM,+BAA+B,CAAC;AAGpE,UAAU,0BAA2B,SAAQ,gBAAgB;IAEzD,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAC,KAAK,CAAC;IACZ,QAAQ,EAAC,MAAM,CAAC;IAEhB,SAAS,EAAC,MAAM,CAAC;IACjB,WAAW,CAAC,EAAC,MAAM,CAAC;IACpB,cAAc,CAAC,EAAC,MAAM,CAAC;IACvB,aAAa,CAAC,EAAC,MAAM,CAAA;CACxB;AAED,qBASa,oBAAqB,SAAQ,UAAU,CAAC,0BAA0B,CAAC;IAE5E,OAAO,CAAC,OAAO,CAAkB;gBAErB,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,0BAA0B;IAqBnD,cAAc,CAAC,YAAY,EAAC,kBAAkB,GAAE,GAAG;CAG7D"}

package/build/core/logger/node/LokiLoggerConfigNode.html

@@ -1,117 +0,0 @@
-
-<script type="text/javascript" template-section="onCompose">
-    node
-        .addDefault("name", {value:"Logger Example", required:true})
-        .addDefault("template", {value:`message:{{msg}}`, required:true})
-        .addDefault("level", {value:"info", required:true})
-
-        .addDefault("loki_host", {})
-        .addDefault("loki_tenantid", {})
-        .addDefault("loki_userid", {})
-        .addDefault("loki_authtoken", {})
-
-        .setPaletteLabel("Loki Logger Config Node")
-        .setLabel(function() {return this.name })
-</script>
-
-<script type="text/javascript" template-section="onIncludeEditPrepare">
-{
-    let node = this;
-
-    let levelSelection = $("#node-config-input-level");
-    levelSelection.typedInput({type:"level", types:[{
-        value: "level",
-        options: [
-            { value: "DEBUG", label: "debug"},
-            { value: "INFO", label: "info"},
-            { value: "WARNING", label: "warning"},
-            { value: "ERROR", label: "error"},
-        ]
-    }]});
-
-    this.editor = RED.editor.createEditor({
-        id: 'node-config-input-templateEditor',
-        mode: 'ace/mode/handlebars',
-        value: this.template
-    });
-}
-</script>
-
-<script type="text/javascript" template-section="onIncludeEditSave">
-{
-    let node = this;
-
-    this.template = this.editor.getValue();
-    this.editor.destroy();
-    delete this.editor;
-}
-
-</script>
-
-<script type="text/html" template-section="onIncludeEditForm">
-<div id="LoggerConfig">
-    <div class="form-row">
-        <label class="towb_editorlabel" for="node-config-input-name"><i class="fa fa-font"></i> Name</label>
-        <input type="text" id="node-config-input-name" />
-    </div>
-
-    <div class="form-row">
-        <label class="towb_editorlabel" for="node-config-input-level"><i class="fa fa-signal"></i> Level</label>
-        <input type="text" id="node-config-input-level" />
-    </div>
-
-    <div class="form-row">
-        <label class="towb_editorlabel" for="node-config-input-loki_host"><i class="fa fa-server"></i> Host</label>
-        <input class="required" type="text" id="node-config-input-loki_host" />
-    </div>
-    <div class="form-row">
-        <label class="towb_editorlabel" for="node-config-input-loki_tenantid"><i class="fa fa-building-o"></i> Tenant ID</label>
-        <input class="" type="text" id="node-config-input-loki_tenantid" />
-    </div>
-    <div class="form-row">
-        <label class="towb_editorlabel" for="node-config-input-loki_userid"><i class="fa fa-user"></i> Username</label>
-        <input class="" type="text" id="node-config-input-loki_userid" />
-    </div>
-    <div class="form-row">
-        <label class="towb_editorlabel" for="node-config-input-loki_authtoken"><i class="fa fa-key"></i> Auth Token</label>
-        <input class="" type="password" id="node-config-input-loki_authtoken" />
-    </div>
-
-    <div class="form-row">
-        <label class="towb_editorlabel" for="node-config-input-templateEditor"><i class="fa fa-code"></i> Template</label>
-        <div style="height: 250px; min-height:150px;" class="node-text-editor" id="node-config-input-templateEditor"></div>
-    </div>
-</div>
-</script>
-
-<script type="text/markdown" template-section="onIncludeDocumentation">
-Pushes log messages to a Grafana Loki instance using the Loki HTTP API.
-
-### Properties
-: *name*        (string)    : A descriptive name for this logger configuration.
-: *level*       (level)     : The minimum log level. Messages below this threshold are suppressed. Options: DEBUG, INFO, WARNING, ERROR.
-: *host*        (string)    : The base URL of the Loki instance, including port (e.g. `http://localhost:3100`).
-: *tenant ID*   (string)    : The tenant identifier for multi-tenant Loki deployments (`X-Scope-OrgID` header). Leave blank for single-tenant deployments.
-: *username*    (string)    : Username for Loki authentication.
-: *auth token*  (string)    : Authentication token or password for Loki.
-: *template*    (mustache)  : A Mustache/Handlebars template that formats the log message body.
-
-### Mustache Templating
-Mustache/Handlebars templates build the message string pushed to Loki.
-
-#### Provided Properties
-: *msg*         (object)    : The Node-RED message object passed through the node.
-: *currentTime* (string)    : The current time in ISO 8601 format.
-
-#### Helpers
-: *json*        (helper)    : Serialises an object to a JSON string using `JSON.stringify`.
-
-#### Examples
-- `{{{json msg}}}` — serialises the full message object as JSON.
-
-#### References
-- [Grafana Loki — HTTP API](https://grafana.com/docs/loki/latest/reference/loki-http-api/)
-- [Mustache — Wikipedia](https://en.wikipedia.org/wiki/Mustache_(template_system))
-- [Mustache — Playground](https://jgonggrijp.gitlab.io/wontache/playground.html)
-</script>
-