@theotherwillembotha/node-red-plugincore 0.0.50

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

@@ -0,0 +1,209 @@
+
+<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})
+
+        // platform rest:
+        .addDefault("est_url", {})
+        .addDefault("est_ignoresslerror", {})
+        .addDefault("rest_auth_type", {})
+        .addDefault("rest_auth_basic_username", {})
+        .addDefault("rest_auth_basic_password", {})
+        .addDefault("rest_auth_apikey_mechanism", {})
+        .addDefault("rest_auth_apikey_name", {})
+        .addDefault("rest_auth_apikey_value", {})
+
+        .setPaletteLabel("Rest Logger Config Node")
+        .setLabel(function() {return this.name })
+
+</script>
+
+<script type="text/javascript" template-section="onIncludeEditPrepare">
+{
+    let node = this;
+
+    let showSelectedRestAuthMethod = (value) => {
+        $("#LoggerConfig")
+            .find(".platform.platform-rest").first()
+            .find(".platform-rest-auth")
+            .each((i, t) => {
+                t = $(t);
+                if(t.hasClass(`auth-${value}`)){ t.show(); }
+                else { t.hide(); }
+            });
+    }
+
+    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"},
+        ]
+    }]});
+
+    let platformRestAuthType = $("#node-config-input-rest_auth_type");
+    platformRestAuthType.typedInput({type:"authtype", types:[{
+        value: "authtype",
+        options: [
+            { value: "none", label: "None"},
+            { value: "basic", label: "Basic"},
+            { value: "apikey", label: "ApiKey"}
+        ]
+    }]});
+    platformRestAuthType.on("change", () => showSelectedRestAuthMethod(platformRestAuthType.val()));
+
+    let apiKeyMechanism = $("#node-config-input-rest_auth_apikey_mechanism");
+    apiKeyMechanism.typedInput({type:"apikeymechansim", types:[{
+        value: "apikeymechansim",
+        options: [
+            { value: "header", label: "Header"},
+            { value: "queryparam", label: "Query Param"},
+            { value: "matrixparam", label: "Matrix Param"}
+        ]
+    }]});
+
+    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 for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-config-input-name" />
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-level"><i class="fa fa-tag"></i> Level</label>
+        <input type="text" id="node-config-input-level" />
+    </div>
+
+    <div class="platform platform-rest">
+        <div class="form-row">
+            <label for="node-config-input-rest_url"><i class="fa fa-tag"></i> URL</label>
+            <input class="platform-rest-input required" type="text" id="node-config-input-rest_url" />
+        </div>
+        <div class="form-row">
+            <label></label>
+            <input type="checkbox" id="node-config-input-rest_ignoresslerror" style="width:20px; margin-right:5px;" />
+            <label style="width:auto" for="node-config-input-rest_ignoresslerror"><span>Ignore Invalid SSL certificates</span></label>
+        </div>
+        <div class="form-row">
+            <label for="node-config-input-rest_auth_type"><i class="fa fa-tag"></i> Authentication</label>
+            <input class="platform-rest-input required" type="text" id="node-config-input-rest_auth_type" />
+        </div>
+        <div class="form-row platform-rest-auth auth-basic">
+            <label for="node-config-input-rest_auth_basic_username"><i class="fa fa-tag"></i> Username</label>
+            <input class="platform-rest-input" type="text" id="node-config-input-rest_auth_basic_username" />
+        </div>
+        <div class="form-row platform-rest-auth auth-basic">
+            <label for="node-config-input-rest_auth_basic_password"><i class="fa fa-tag"></i> Password</label>
+            <input class="platform-rest-input" type="password" id="node-config-input-rest_auth_basic_password" />
+        </div>
+        <div class="form-row platform-rest-auth auth-apikey">
+            <label for="node-config-input-rest_auth_apikey_mechanism"><i class="fa fa-tag"></i> Mechanism</label>
+            <input class="platform-rest-input" type="text" id="node-config-input-rest_auth_apikey_mechanism" />
+        </div>
+        <div class="form-row platform-rest-auth auth-apikey">
+            <label for="node-config-input-rest_auth_apikey_name"><i class="fa fa-tag"></i> APIKey name</label>
+            <input class="platform-rest-input" type="text" id="node-config-input-rest_auth_apikey_name" />
+        </div>
+        <div class="form-row platform-rest-auth auth-apikey">
+            <label for="node-config-input-rest_auth_apikey_value"><i class="fa fa-tag"></i> APIKey value</label>
+            <input class="platform-rest-input" type="text" id="node-config-input-rest_auth_apikey_value" />
+        </div>
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-templateEditor"><i class="fa fa-tag"></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">
+Configuration node for the Logger Integration
+
+## Inputs
+: *name*    (string)    : The common name for the logger Configuration
+: *level*   (level)     : The logging level - debug, info, warning, error
+: *platform*(string)    : The common name for the logger Configuration
+: *template*(mustache)  : A template for the log messages.
+
+## Logger platform
+Currently supported logging platforms
+
+### Console
+The log message will be printed out to stdio
+
+### Http / Https
+Publish the message to an http endpoint using a http / https POST command.
+
+: *url*                 (url)           : The endpoint for the url where requests are to be posted to.
+: *ignore ssl errors*   (boolean)       : If enabled, the invalid ssl certificates will be ignored.
+: *authentication*      (auth method)   : what auth method should be used for the http request. (none, basic, api key)
+
+#### Authentication
+##### Basic
+Provides basic authentication using the Authorization header 
+
+: *username*    (string) : the username used for basic authentication
+: *password*    (string) : the password used for basic authentication
+
+##### APIKey
+Provides authentication using a matrix parameter, header or query parameter and an apikey
+
+: *mechanism*   (mechanism) : the mechanism that will be used for transmitting the key (header, queryparam, matrixparam)
+: *apikey name* (string)    : the name of the key used for api authentication. (path variable or query param name)
+: *apikey value*(string)    : the value of the api key that will be transmitted. (beware of special characters)
+
+### Loki
+Publish the message to a loki endpoint.
+
+: *host*        (string) : the host and port\ of the loki instance that it being logged to
+: *tenant*      (string) : the tenant id that will be used to log to
+: *username*    (string) : the username for the loki instance.
+: *authtoken*   (string) : the authtoken for the loki instance.
+
+# Mustache Templating
+Mustache / Handlebars are used for building up the logged message payloads that are sent to the logging backend.
+The resultant message will be interpreted as a string, meaning care should be taken in the event that a string representation of a json object is built.
+
+### Provided Properties
+A couple of values are provided to the logging context by default.
+
+: *msg*         (object)    : an object containing the payload or message that should be parsed through the template.
+: *currentTime* (object)    : a string containing the current time in ISO8601 format
+
+### Mustache Helpers
+In addition to the provided properties, some "helpers" have also been provided to assist in serialization.
+
+: *json*        (helper)    : converts a json object to a string using the JSON.stringify method.
+
+## Examples
+- {{{json msg}}} - serializes the the msg object to json format.
+
+# References
+- [Mustache - Wikipedia](https://en.wikipedia.org/wiki/Mustache_(template_system))
+- [Mustache - Playground](https://jgonggrijp.gitlab.io/wontache/playground.html)
+</script>
+

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

@@ -0,0 +1,67 @@
+
+import { Node } from "node-red";
+import { ConfigNode, ConfigNodeConfig, NodeDescriptor } from "../../NodeConstructor"
+import { NewLogger, Log, LoggerRegistration, LoggerService, RestLoggerConfig } from "../service/LoggerService"
+import { SourceUtility } from "../../NodeGenerator";
+import { ApiKeyMechanismType, Level, PlatformType, RestAuthType } from "../service/LoggerServiceTypes";
+import { NodeDescription } from "../../tagging/NodeDescriptionDecorator";
+
+interface RestLoggerConfigNodeConfig extends ConfigNodeConfig {
+
+    id: string;
+    platform: PlatformType;
+    level:Level;
+    template:string;
+    
+    rest_url: string;
+    rest_auth_type: RestAuthType;
+    rest_auth_basic_username:string;
+    rest_auth_basic_password:string;
+    rest_auth_apikey_mechanism:ApiKeyMechanismType;
+    rest_auth_apikey_name:string;
+    rest_auth_apikey_value:string;
+}
+
+@NodeDescription({
+    id:"RestLoggerConfigNode",
+    name:"Console Logger",
+    group:"config",
+    sourceFile:SourceUtility.getSourcePath("/build/", "/src/") + "RestLoggerConfigNode.html",
+    package: "@theotherwillembotha/node-red-plugincore",
+    dependencies:[ LoggerService ],
+    tags: [ "LoggerType" ]
+})
+export class RestLoggerConfigNode extends ConfigNode<RestLoggerConfigNodeConfig> {
+    
+    private _logger!: NewLogger<any>;
+    
+    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;
+        }
+
+        this._logger = LoggerService.get(loggerConfig);
+    }
+
+    public registerLogger(registration:LoggerRegistration):Log {
+        return this._logger.register(registration)
+    }
+}

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

@@ -0,0 +1,317 @@
+
+import {BaseService, ServiceDescriptor } from "../../NodeConstructor";
+import { NodeAPI, NodeAPISettingsWithData } 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 { LoggerConfigNode } from "../node/LoggerConfigNode";
+import { LoggerTemplate } 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}}}
+Handlebars.registerHelper('json', function(context) {
+    return JSON.stringify(context);
+});
+
+type TagMap = { 
+    instance: string; 
+    flow: string; 
+    node: string; 
+    type: string; 
+    id: string; 
+}
+
+export type Log = {
+    log(message:{[key:string]:any}|string):void;
+}
+
+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 interface BaseLoggerConfig {
+    id:string;
+    type:PlatformType;
+    level: Level;
+    template:string;
+}
+
+export abstract class NewLogger<ConfigType extends BaseLoggerConfig> {
+    private _config: ConfigType;
+    private template: HandlebarsTemplateDelegate<string>;
+
+    constructor(config:ConfigType){
+        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);
+        }
+        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 {
+        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;
+
+    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
+        }
+
+        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});
+    }
+}
+
+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;
+}
+
+class RestLogger extends NewLogger<RestLoggerConfig>{
+    logger: any;
+
+    constructor(config:RestLoggerConfig){
+        super(config);
+
+        let hosturl:URLRecord|null = parseURL(config.url);
+    
+        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;
+        }
+
+        if(config.auth_type === RestAuthType.none){}
+
+        if(config.auth_type === RestAuthType.basic){
+            httpParams.auth = {
+                username: config.auth_basic_username,
+                password: config.auth_basic_password
+            }
+        }
+        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),
+            ],
+        });
+    }
+
+    protected writeToLog(serializedContent: string, tags: TagMap): void {
+        this.logger.log({level:this.logger.level, message:serializedContent, labels:tags});
+    }
+}
+
+let LoggerTypes:{[key:string]:any} = {
+    console: ConsoleLogger,
+    loki: LokiLogger,
+    rest: RestLogger
+}
+
+export class LoggerService extends BaseService {
+
+    public static instanceID:string;
+
+    private static loggers:{[key:string]:NewLogger<BaseLoggerConfig>} = {};
+    private red!: NodeAPI<NodeAPISettingsWithData>;
+
+    constructor(){
+        super("logger")
+    }
+
+    public init(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void> {
+        this.red = red;
+
+        return new Promise<void>((resolve) => {
+            network.get_active_interface((err:any, obj:any) => {
+                LoggerService.instanceID = obj.ip_address;
+            });
+        });
+    }
+
+    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",
+            "LoggerService",
+            "services-plugin",
+            "@theotherwillembotha/node-red-plugincore",
+            LoggerService,
+            [LoggerConfigNode, LoggerTemplate]
+        );
+    }
+}
+
+export type LoggerRegistration = {
+    id:string;
+    flow:string;
+    type:string;
+    name:string;
+    enabled:boolean;
+    template?:string;
+    override?:boolean;
+}

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

@@ -0,0 +1,26 @@
+export enum Level{
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARNING = "WARNING",
+    ERROR = "ERROR"
+}
+
+export enum PlatformType {
+    console = 'console',
+    rest = 'rest',
+    loki = 'loki',
+    elasticsearch = 'elasticsearch',
+    datadog = 'datadog',
+}
+
+export enum RestAuthType {
+    none="none",
+    basic="basic",
+    apikey="apikey",
+}
+
+export enum ApiKeyMechanismType {
+    header="header",
+    queryparam="queryparam",
+    matrixparam="matrixparam",
+}