@theotherwillembotha/node-red-plugincore 0.0.50

package/build/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/build/core/logger/node/RestLoggerConfigNode.js

@@ -0,0 +1,57 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestLoggerConfigNode = void 0;
+const NodeConstructor_1 = require("../../NodeConstructor");
+const LoggerService_1 = require("../service/LoggerService");
+const NodeGenerator_1 = require("../../NodeGenerator");
+const LoggerServiceTypes_1 = require("../service/LoggerServiceTypes");
+const NodeDescriptionDecorator_1 = require("../../tagging/NodeDescriptionDecorator");
+let RestLoggerConfigNode = class RestLoggerConfigNode extends NodeConstructor_1.ConfigNode {
+    constructor(node, config) {
+        super(node, config);
+        let _this = this;
+        // instantiate the logger.
+        let loggerConfig;
+        if (config.platform === LoggerServiceTypes_1.PlatformType.rest) {
+            loggerConfig = {
+                id: this.id(),
+                type: LoggerServiceTypes_1.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,
+            };
+        }
+        this._logger = LoggerService_1.LoggerService.get(loggerConfig);
+    }
+    registerLogger(registration) {
+        return this._logger.register(registration);
+    }
+};
+exports.RestLoggerConfigNode = RestLoggerConfigNode;
+exports.RestLoggerConfigNode = RestLoggerConfigNode = __decorate([
+    (0, NodeDescriptionDecorator_1.NodeDescription)({
+        id: "RestLoggerConfigNode",
+        name: "Console Logger",
+        group: "config",
+        sourceFile: NodeGenerator_1.SourceUtility.getSourcePath("/build/", "/src/") + "RestLoggerConfigNode.html",
+        package: "@theotherwillembotha/node-red-plugincore",
+        dependencies: [LoggerService_1.LoggerService],
+        tags: ["LoggerType"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], RestLoggerConfigNode);

package/build/core/logger/service/LoggerService.d.ts

@@ -0,0 +1,88 @@
+import { BaseService, ServiceDescriptor } from "../../NodeConstructor";
+import { NodeAPI, NodeAPISettingsWithData } from "node-red";
+import { ApiKeyMechanismType, Level, PlatformType, RestAuthType } from "./LoggerServiceTypes";
+type TagMap = {
+    instance: string;
+    flow: string;
+    node: string;
+    type: string;
+    id: string;
+};
+export type Log = {
+    log(message: {
+        [key: string]: any;
+    } | string): void;
+};
+export declare class LogImplementation implements Log {
+    private root;
+    private config;
+    private template?;
+    private tagMap;
+    constructor(root: NewLogger<any>, config: LoggerRegistration);
+    log(message: {
+        [key: string]: any;
+    } | string): void;
+    serialize(content: {
+        [key: string]: any;
+    }): string;
+    getTags(): TagMap;
+}
+export interface BaseLoggerConfig {
+    id: string;
+    type: PlatformType;
+    level: Level;
+    template: string;
+}
+export declare abstract class NewLogger<ConfigType extends BaseLoggerConfig> {
+    private _config;
+    private template;
+    constructor(config: ConfigType);
+    log(reference: LogImplementation, content: {
+        [key: string]: any;
+    }): void;
+    register(registration: LoggerRegistration): Log;
+    serialize(content: any): string;
+    config(): ConfigType;
+    protected abstract writeToLog(serializedContent: string, tags: TagMap): void;
+}
+export interface ConsoleLoggerConfig extends BaseLoggerConfig {
+}
+export interface LokiLoggerConfig extends BaseLoggerConfig {
+    type: PlatformType.loki;
+    host: string;
+    userid?: string;
+    authtoken?: string;
+    tenantID?: string;
+}
+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 declare class LoggerService extends BaseService {
+    static instanceID: string;
+    private static loggers;
+    private red;
+    constructor();
+    init(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void>;
+    deinit(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void>;
+    static get<ConfigType extends BaseLoggerConfig>(config: ConfigType): NewLogger<ConfigType>;
+    static getServiceDescriptor(): ServiceDescriptor;
+}
+export type LoggerRegistration = {
+    id: string;
+    flow: string;
+    type: string;
+    name: string;
+    enabled: boolean;
+    template?: string;
+    override?: boolean;
+};
+export {};
+//# sourceMappingURL=LoggerService.d.ts.map

package/build/core/logger/service/LoggerService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerService.d.ts","sourceRoot":"","sources":["../../../../src/core/logger/service/LoggerService.ts"],"names":[],"mappings":"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"}

package/build/core/logger/service/LoggerService.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerService = exports.NewLogger = exports.LogImplementation = void 0;
+const NodeConstructor_1 = require("../../NodeConstructor");
+const handlebars_1 = __importDefault(require("handlebars"));
+const winston_1 = require("winston");
+const winston_loki_1 = __importDefault(require("winston-loki"));
+const whatwg_url_1 = require("whatwg-url");
+const LoggerConfigNode_1 = require("../node/LoggerConfigNode");
+const LoggerTemplate_1 = require("../template/LoggerTemplate");
+var network = require('network');
+const deep_equal_1 = __importDefault(require("deep-equal"));
+const LoggerServiceTypes_1 = require("./LoggerServiceTypes");
+// helper for serializing json objects inside handlebars tags.
+// you can then convert it like this: {{{json myobject}}}
+handlebars_1.default.registerHelper('json', function (context) {
+    return JSON.stringify(context);
+});
+class LogImplementation {
+    constructor(root, config) {
+        this.root = root;
+        this.config = config;
+        this.template = (config.override && config.template) ? handlebars_1.default.compile(config.template) : undefined;
+        this.tagMap = {
+            instance: LoggerService.instanceID,
+            flow: config.flow,
+            node: config.name,
+            type: config.type,
+            id: config.id,
+        };
+    }
+    log(message) {
+        // enrich the logged content with additional properties.
+        let content = {
+            currentTime: new Date().toISOString(),
+            msg: message,
+        };
+        // send typ the logger.
+        this.root.log(this, content);
+    }
+    serialize(content) {
+        return !!this.template ? this.template(content) : this.root.serialize(content);
+    }
+    getTags() {
+        return this.tagMap;
+    }
+}
+exports.LogImplementation = LogImplementation;
+class NewLogger {
+    constructor(config) {
+        this._config = config;
+        this.template = handlebars_1.default.compile(config.template);
+    }
+    log(reference, content) {
+        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.message);
+        }
+    }
+    register(registration) {
+        return new LogImplementation(this, registration);
+    }
+    serialize(content) {
+        return this.template(content);
+    }
+    config() {
+        return this._config;
+    }
+}
+exports.NewLogger = NewLogger;
+class ConsoleLogger extends NewLogger {
+    constructor(config) {
+        super(config);
+    }
+    writeToLog(serializedContent, tags) {
+        console.log(tags, serializedContent);
+    }
+}
+class LokiLogger extends NewLogger {
+    constructor(config) {
+        super(config);
+        let transportConfig = {
+            host: config.host,
+            json: true,
+            format: winston_1.format.json(),
+            headers: {
+                "X-Scope-OrgID": (config.tenantID) ? config.tenantID : undefined
+            },
+            replaceTimestamp: true,
+            onConnectionError: (err) => console.error(err),
+            basicAuth: (config.userid && config.authtoken)
+                ? `${config.userid}:${config.authtoken}`
+                : undefined
+        };
+        this.logger = (0, winston_1.createLogger)({
+            level: this.config().level.toString().toLowerCase(),
+            format: winston_1.format.json(),
+            defaultMeta: {},
+            transports: [
+                new winston_loki_1.default(transportConfig),
+            ],
+        });
+    }
+    writeToLog(serializedContent, tags) {
+        this.logger.log({ message: serializedContent, level: this.logger.level, labels: tags });
+    }
+}
+class RestLogger extends NewLogger {
+    constructor(config) {
+        super(config);
+        let hosturl = (0, whatwg_url_1.parseURL)(config.url);
+        if (!hosturl) {
+            throw Error("could not parse url: " + config.url);
+        }
+        let httpOptions = {};
+        let httpParams = {
+            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.options = httpOptions;
+        if (config.ignoresslerror) {
+            httpOptions.rejectUnauthorized = false;
+        }
+        if (config.auth_type === LoggerServiceTypes_1.RestAuthType.none) { }
+        if (config.auth_type === LoggerServiceTypes_1.RestAuthType.basic) {
+            httpParams.auth = {
+                username: config.auth_basic_username,
+                password: config.auth_basic_password
+            };
+        }
+        if (config.auth_type === LoggerServiceTypes_1.RestAuthType.apikey) {
+            if (config.auth_apikey_mechanism === LoggerServiceTypes_1.ApiKeyMechanismType.header) {
+                httpParams.headers[config.auth_apikey_name] = config.auth_apikey_value;
+            }
+            if (config.auth_apikey_mechanism === LoggerServiceTypes_1.ApiKeyMechanismType.matrixparam) {
+                httpParams.path = httpParams.path?.replace(`:${config.auth_apikey_name}`, config.auth_apikey_value);
+            }
+            if (config.auth_apikey_mechanism === LoggerServiceTypes_1.ApiKeyMechanismType.queryparam) {
+                httpParams.path = httpParams.path + (httpParams.path?.includes("?") ? "&" : "?") + config.auth_apikey_name + "=" + config.auth_apikey_value;
+            }
+        }
+        ;
+        this.logger = (0, winston_1.createLogger)({
+            level: config.level.toString().toLowerCase(),
+            format: winston_1.format.json(),
+            defaultMeta: {},
+            transports: [
+                new winston_1.transports.Http(httpParams),
+            ],
+        });
+    }
+    writeToLog(serializedContent, tags) {
+        this.logger.log({ level: this.logger.level, message: serializedContent, labels: tags });
+    }
+}
+let LoggerTypes = {
+    console: ConsoleLogger,
+    loki: LokiLogger,
+    rest: RestLogger
+};
+class LoggerService extends NodeConstructor_1.BaseService {
+    constructor() {
+        super("logger");
+    }
+    init(red) {
+        this.red = red;
+        return new Promise((resolve) => {
+            network.get_active_interface((err, obj) => {
+                LoggerService.instanceID = obj.ip_address;
+            });
+        });
+    }
+    deinit(red) { }
+    static get(config) {
+        let logger = this.loggers[config.id];
+        if (logger) {
+            if (!(0, deep_equal_1.default)(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 getServiceDescriptor() {
+        return new NodeConstructor_1.ServiceDescriptor("@theotherwillembotha/loggerservice", "LoggerService", "services-plugin", "@theotherwillembotha/node-red-plugincore", LoggerService, [LoggerConfigNode_1.LoggerConfigNode, LoggerTemplate_1.LoggerTemplate]);
+    }
+}
+exports.LoggerService = LoggerService;
+LoggerService.loggers = {};

package/build/core/logger/service/LoggerServiceTypes.d.ts

@@ -0,0 +1,24 @@
+export declare enum Level {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARNING = "WARNING",
+    ERROR = "ERROR"
+}
+export declare enum PlatformType {
+    console = "console",
+    rest = "rest",
+    loki = "loki",
+    elasticsearch = "elasticsearch",
+    datadog = "datadog"
+}
+export declare enum RestAuthType {
+    none = "none",
+    basic = "basic",
+    apikey = "apikey"
+}
+export declare enum ApiKeyMechanismType {
+    header = "header",
+    queryparam = "queryparam",
+    matrixparam = "matrixparam"
+}
+//# sourceMappingURL=LoggerServiceTypes.d.ts.map

package/build/core/logger/service/LoggerServiceTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerServiceTypes.d.ts","sourceRoot":"","sources":["../../../../src/core/logger/service/LoggerServiceTypes.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK;IACb,KAAK,UAAU;IACf,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,KAAK,UAAU;CAClB;AAED,oBAAY,YAAY;IACpB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,aAAa,kBAAkB;IAC/B,OAAO,YAAY;CACtB;AAED,oBAAY,YAAY;IACpB,IAAI,SAAO;IACX,KAAK,UAAQ;IACb,MAAM,WAAS;CAClB;AAED,oBAAY,mBAAmB;IAC3B,MAAM,WAAS;IACf,UAAU,eAAa;IACvB,WAAW,gBAAc;CAC5B"}

package/build/core/logger/service/LoggerServiceTypes.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyMechanismType = exports.RestAuthType = exports.PlatformType = exports.Level = void 0;
+var Level;
+(function (Level) {
+    Level["DEBUG"] = "DEBUG";
+    Level["INFO"] = "INFO";
+    Level["WARNING"] = "WARNING";
+    Level["ERROR"] = "ERROR";
+})(Level || (exports.Level = Level = {}));
+var PlatformType;
+(function (PlatformType) {
+    PlatformType["console"] = "console";
+    PlatformType["rest"] = "rest";
+    PlatformType["loki"] = "loki";
+    PlatformType["elasticsearch"] = "elasticsearch";
+    PlatformType["datadog"] = "datadog";
+})(PlatformType || (exports.PlatformType = PlatformType = {}));
+var RestAuthType;
+(function (RestAuthType) {
+    RestAuthType["none"] = "none";
+    RestAuthType["basic"] = "basic";
+    RestAuthType["apikey"] = "apikey";
+})(RestAuthType || (exports.RestAuthType = RestAuthType = {}));
+var ApiKeyMechanismType;
+(function (ApiKeyMechanismType) {
+    ApiKeyMechanismType["header"] = "header";
+    ApiKeyMechanismType["queryparam"] = "queryparam";
+    ApiKeyMechanismType["matrixparam"] = "matrixparam";
+})(ApiKeyMechanismType || (exports.ApiKeyMechanismType = ApiKeyMechanismType = {}));

package/build/core/logger/template/LoggerTemplate.d.ts

@@ -0,0 +1,11 @@
+import { BaseNodeConfig, Template, TemplateDescriptor } from "../../NodeConstructor";
+export interface LoggerTemplateConfig extends BaseNodeConfig {
+    logEnabled: boolean;
+    logger: string;
+    logTemplateOverrideEnabled: boolean;
+    logTemplateOverride: string;
+}
+export declare class LoggerTemplate extends Template {
+    static getTemplateDescriptor(): TemplateDescriptor;
+}
+//# sourceMappingURL=LoggerTemplate.d.ts.map

package/build/core/logger/template/LoggerTemplate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerTemplate.d.ts","sourceRoot":"","sources":["../../../../src/core/logger/template/LoggerTemplate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAGpF,MAAM,WAAW,oBAAqB,SAAQ,cAAc;IACxD,UAAU,EAAC,OAAO,CAAC;IACnB,MAAM,EAAC,MAAM,CAAC;IACd,0BAA0B,EAAC,OAAO,CAAC;IACnC,mBAAmB,EAAC,MAAM,CAAC;CAC9B;AAED,qBAAa,cAAe,SAAQ,QAAQ;IAGxC,MAAM,CAAC,qBAAqB,IAAI,kBAAkB;CAQrD"}