@nsshunt/stsappframework 3.1.214 → 3.1.216

package/src/gRPC/ststest/src/route_guide_server2.ts

@@ -1,211 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
-
-// cd /home/marcusbettens/projects/stsappframework/src/gRPC/ststest
-// npx proto-loader-gen-types --longs=String --enums=String --defaults --oneofs --grpcLib=@grpc/grpc-js --outDir=protos/ protos/*.proto
-
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-const PROTO_PATH_SV = __dirname + './../../../../src/gRPC/ststest/protos/route_guide.proto';
-
-import * as grpc from '@grpc/grpc-js';
-import * as protoLoader from '@grpc/proto-loader';
-
-//import { IFeature, IPoint, IRectangle, IRouteNote, IRouteSummary } from './commonTypes'
-
-import chalk from 'chalk'
-
-import fs from 'node:fs'
-
-import { ProtoGrpcType } from './../protos/route_guide'
-
-import { RouteGuideHandlers } from './../protos/routeguide/RouteGuide'
-import { Point, Point__Output } from '../protos/routeguide/Point';
-import { Feature } from './../protos/routeguide/Feature'
-import { RouteSummary } from './../protos/routeguide/RouteSummary'
-import { RouteNote, RouteNote__Output } from './../protos/routeguide/RouteNote'
-
-const packageDefinition = protoLoader.loadSync(
-    PROTO_PATH_SV,
-    {keepCase: true,
-        longs: String,
-        enums: String,
-        defaults: true,
-        oneofs: true
-    });
-//const routeguide = grpc.loadPackageDefinition(packageDefinition).routeguide;
-
-const routeguide = (grpc.loadPackageDefinition(
-    packageDefinition
-) as unknown) as ProtoGrpcType;
-
-const exampleServer: RouteGuideHandlers = {
-    GetFeature(call, callback) {
-        console.log(chalk.grey(`getFeature: call.request: [${JSON.stringify(call.request)}]`));
-        const retVal = checkFeature(call.request);
-        console.log(chalk.grey(`getFeature: return: [${JSON.stringify(retVal)}]`));
-        callback(null, retVal);
-    },
-  
-    ListFeatures(call) {
-        console.log(chalk.green(`listFeatures: forEach: [${JSON.stringify(call.request)}]`));
-        const rectangle = call.request;
-        const lo = rectangle.lo;
-        const hi = rectangle.hi;
-    
-        const feature_list: Feature[] = [ ];
-        for (let i=0; i < 10; i++) {
-            feature_list.push({
-                location: {
-                    latitude: (hi as Point__Output).latitude * 2 * (i+1),
-                    longitude: (lo as Point__Output).longitude * 2 * (i+1)
-                },
-                name: `the name for index: [${i}]`
-            });
-        }
-        feature_list.forEach((feature: Feature) => {
-            console.log(chalk.green(`listFeatures: forEach: [${JSON.stringify(feature)}]`));
-            call.write(feature);
-        });
-        console.log(chalk.green(`listFeatures: call.end()`));
-        call.end();
-    },
-    
-    RecordRoute(call, callback) {
-        let point_count = 0;
-        let feature_count = 0;
-        let distance = 0;
-        let previous: any = null;
-        // Start a timer
-        const start_time = process.hrtime();
-        call.on('data', function(point: Point__Output) {
-            console.log(chalk.magenta(`recordRoute: on data: [${JSON.stringify(point)}]`));
-            point_count += 1;
-            if (checkFeature(point).name !== '') {
-                feature_count += 1;
-            }
-            /* For each point after the first, add the incremental distance from the
-         * previous point to the total distance value */
-            if (previous != null) {
-                distance += 1;
-            }
-            previous = point;
-        });
-        call.on('end', function() {
-            const returnData: RouteSummary = {
-                pointCount: point_count,
-                featureCount: feature_count,
-                // Cast the distance to an integer
-                distance: distance|0,
-                // End the timer
-                elapsedTime: process.hrtime(start_time)[0]
-            }
-            console.log(chalk.magenta(`recordRoute: on end - return data: [${JSON.stringify(returnData)}]`));
-            callback(null, returnData);
-        });
-    },
-    
-    RouteChat(call) {
-        call.on('data', function(note: RouteNote__Output) {
-            console.log(chalk.cyan(`routeChat: on data: [${JSON.stringify(note)}]`));
-            // Send back what we just got
-            const sendBack: RouteNote = JSON.parse(JSON.stringify(note));
-            sendBack.message = `${note.message} reply message`;
-            (sendBack.location as Point).latitude = (note.location as Point__Output).latitude * 2;
-            (sendBack.location as Point).longitude = (note.location as Point__Output).longitude * 2;
-            console.log(chalk.cyan(`routeChat: sending data: [${JSON.stringify(sendBack)}]`));
-            call.write(sendBack);
-        });
-        call.on('end', function() {
-            call.end();
-        });
-    }
-};
-
-/**
- * Get a feature object at the given point, or creates one if it does not exist.
- * @param {point} point The point to check
- * @return {feature} The feature object at the point. Note that an empty name
- *     indicates no feature
- */
-function checkFeature(point: Point__Output): Feature {
-    const feature: Feature = {
-        name: "Some name",
-        location: {
-            latitude: point.latitude * 2,
-            longitude: point.longitude * 2
-        }
-    };
-    return feature;
-}
-
-/**
- * Get a new server with the handler functions in this file bound to the methods
- * it serves.
- * @return {Server} The new server object
- */
-function getServer() {
-    const server = new grpc.Server();
-    server.addService(routeguide.routeguide.RouteGuide.service, exampleServer);
-    return server;
-}
-
-// HTTPS_SERVER_KEY_PATH=/etc/letsencrypt/live/stsmda.org/privkey.pem \
-// HTTPS_SERVER_CERT_PATH=/etc/letsencrypt/live/stsmda.org/fullchain.pem \
-
-/*
-export interface KeyCertPair {
-    private_key: Buffer;
-    cert_chain: Buffer;
-}
-*/
-
-if (require.main === module) {
-    // If this is run as a script, start a server on an unused port
-    const routeServer = getServer();
-    
-    // Secure server
-
-    routeServer.bindAsync('0.0.0.0:3029', grpc.ServerCredentials.createSsl(null,
-        [
-            {
-                private_key: fs.readFileSync('/etc/letsencrypt/live/stsmda.org/privkey.pem'),
-                cert_chain: fs.readFileSync('/etc/letsencrypt/live/stsmda.org/fullchain.pem')
-            }
-        ]), (error, port) => {
-        if (error) {
-            console.log(chalk.red(`Error starting gRPC TLS server on port: [${port}], Error: [${error}]`));
-        } else {
-            console.log(chalk.green(`Started gRPC TLS server on port: [${port}]`));
-        }
-    });
-
-    // Insecure server
-    /*
-    routeServer.bindAsync('0.0.0.0:3029', grpc.ServerCredentials.createInsecure(),
-        (error, port) => {
-            if (error) {
-                console.log(chalk.red(`Error starting gRPC TLS server on port: [${port}], Error: [${error}]`));
-            } else {
-                console.log(chalk.green(`Started gRPC TLS server on port: [${port}]`));
-            }
-        });
-        */
-}
-
-exports.getServer = getServer;

package/src/influxdb/influxDBManager.ts

@@ -1,334 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import { InfluxDB, WriteApi, QueryApi, DEFAULT_WriteOptions, WriteOptions } from '@influxdata/influxdb-client'
-// Use below for production https mode - needs to be config item
-//import { Agent } from 'https'
-import { Agent } from 'http'
-
-import chalk from 'chalk';
-
-import { goptions } from '@nsshunt/stsconfig'
-import { ISTSLogger, JSONObject } from '@nsshunt/stsutils'
-
-import { InfluxDBManagerBase } from './influxDBManagerBase'
-import { InfluxDBManagerService} from './influxDBManagerService'
-import { InfluxDBManagerAgent } from './influxDBManagerAgent'
-import { InfluxDBManagerLambda } from './influxDBManagerLambda'
-import { IInfluxDBManagerOptions } from './../commonTypes'
-import { IInstrumentPayload } from '@nsshunt/stsobservability'
-
-import { TasksAPI, Tasks, Task } from '@influxdata/influxdb-client-apis'
-
-const _logPrefix = 'InfluxDBManager:'
-
-export class InfluxDBManager
-{
-    #shuttingDown: boolean = false;
-
-    //#token = process.env.INFLUXDB_TOKEN;
-    #token = '';
-    #url = '' // 'http://192.168.14.92:8086'
-    #org = '' // `my-org`
-    #bucket = '' // `TestBucket01`
-    #client: InfluxDB;
-    #writeClient: WriteApi | null = null;
-    #queryApi: QueryApi;
-    #writeDataPointFlushTimeout: NodeJS.Timeout | null = null;
-    #agent: Agent | null = null;
-    #influxDBManagerClients: Record<string, InfluxDBManagerBase> = { };
-    #options: IInfluxDBManagerOptions;
-
-    constructor(logger: ISTSLogger)
-    {
-        this.#options = {
-            token: goptions.influxDB_APIToken,
-            url: goptions.influxDB_Url,
-            org: goptions.influxDB_Org,
-            bucket:goptions.influxDB_Bucket,
-            agent: {
-                influxDB_keepAlive: goptions.influxDB_keepAlive,
-                influxDB_maxSockets: goptions.influxDB_maxSockets,
-                influxDB_maxTotalSockets: goptions.influxDB_maxTotalSockets,
-                influxDB_maxFreeSockets: goptions.influxDB_maxFreeSockets,
-                influxDB_timeout: goptions.influxDB_timeout,
-            },
-            logger
-        };
-
-        this.#token = this.#options.token;
-        this.#url = this.#options.url;
-        this.#org = this.#options.org;
-        this.#bucket = this.#options.bucket;
-
-        if (this.#options.agent) {
-            this.#agent = new Agent({
-                keepAlive: this.#options.agent.influxDB_keepAlive,
-                keepAliveMsecs: 20000, //@@
-                maxSockets: this.#options.agent.influxDB_maxSockets,
-                maxTotalSockets: this.#options.agent.influxDB_maxTotalSockets,
-                maxFreeSockets: this.#options.agent.influxDB_maxFreeSockets,
-                timeout: this.#options.agent.influxDB_timeout,
-                //rejectUnauthorized: this.#options.agent.influxDB_rejectUnauthorized, // only for SSL
-            })
-
-            this.#client = new InfluxDB({ 
-                url: this.#url, 
-                token: this.#token,
-                transportOptions: { agent: this.#agent }
-            })
-        } else {
-            this.#agent = null;
-
-            this.#client = new InfluxDB({ 
-                url: this.#url, 
-                token: this.#token
-            })
-        }
-
-        this.#BoostrapInfluxDB();
-
-        this.#queryApi = this.#client.getQueryApi(this.#org);
-        
-        this.CreateInfluxDBManagerClient('service');
-        this.CreateInfluxDBManagerClient('agent');
-        this.CreateInfluxDBManagerClient('lambda');
-    }
-
-    #LogErrorMessage(message: any) {
-        this.#options.logger.error(message);
-    }
-
-    #LogDebugMessage(message: any) {
-        this.#options.logger.debug(message);
-    }
-
-    #BoostrapInfluxDB = async(): Promise<void> => {
-        const tasksAPI = new TasksAPI(this.#client);
-        const tasks: Tasks = await tasksAPI.getTasks({
-            org: 'my-org'
-        });
-        if (tasks.tasks) {
-            this.#LogDebugMessage(chalk.cyan(`[InfluxDB Tasks] - Count: [${tasks.tasks.length}]`));
-            tasks.tasks.forEach((task: Task) => {
-                this.#LogDebugMessage(chalk.cyan(`-- [ Start Task Definition ]--`));
-                this.#LogDebugMessage(chalk.green(`${JSON.stringify(task)}`));
-                this.#LogDebugMessage(chalk.yellow(`authorizationID: [${task.authorizationID}]`));
-                this.#LogDebugMessage(chalk.cyan(`-- [ End Task Definition ]--`));
-            });
-        } else {
-            this.#LogDebugMessage(chalk.magenta(`[InfluxDB Tasks] - Could not get tasks from the InfluxDB API`));
-        }
-    }
-
-    CreateInfluxDBManagerClient(modelType: string) {
-        switch (modelType) {
-        case 'service':
-            this.#influxDBManagerClients[modelType] = new InfluxDBManagerService(this.#options, this.#queryApi);
-            break;
-        case 'agent':
-            this.#influxDBManagerClients[modelType] = new InfluxDBManagerAgent(this.#options, this.#queryApi);
-            break;
-        case 'lambda':
-            this.#influxDBManagerClients[modelType] = new InfluxDBManagerLambda(this.#options, this.#queryApi);
-            break;
-        default:
-            throw new Error(`Model type: [${modelType} not supported.]`);
-        }
-    }
-
-    get serviceManager(): InfluxDBManagerService {
-        return this.#influxDBManagerClients['service'] as InfluxDBManagerService;
-    }
-
-    get agentManager(): InfluxDBManagerAgent {
-        return this.#influxDBManagerClients['agent'] as InfluxDBManagerAgent;
-    }
-
-    get lambdaManager(): InfluxDBManagerLambda {
-        return this.#influxDBManagerClients['lambda'] as InfluxDBManagerLambda;
-    }
-
-    Start = async () => {
-        // perform any setup here
-    }
-
-    Terminate = async () => {
-        if (this.#shuttingDown) {
-            this.#LogDebugMessage(chalk.yellow(`${_logPrefix}Terminate: Terminate already called. Ignoring.`));
-        } else {
-            this.#shuttingDown = true;
-            if (this.#writeClient) {
-                try {
-                    this.#writeClient.flush();
-                    this.#shuttingDown = true;
-                    if (this.#writeDataPointFlushTimeout) {
-                        clearTimeout(this.#writeDataPointFlushTimeout);
-                        this.#writeDataPointFlushTimeout = null;
-                    }
-
-                    if (this.#agent) {
-                        this.#agent?.destroy();
-                        this.#agent = null;
-                    }
-
-                    this.#writeClient = null;
-
-                    this.#LogDebugMessage(chalk.yellow(`ProducerDisconnect`));
-                } catch (error) {
-                    this.#LogErrorMessage(chalk.red(`${_logPrefix}#Terminate: Error: [${error}]`));
-                }
-            }
-        }
-    }
-
-    CreateGlobalCountModel = (stscount: any[]) => {
-        try {
-            const results: any = { };
-            stscount.forEach((o: any) => {
-                results[o._field] = o._value;
-            });
-            return results;
-        } catch (error) {
-            this.#LogErrorMessage(chalk.red(`${_logPrefix}#CreateGlobalCountModel: Error: [${error}]`));
-        }
-    }
-
-
-    CreateNestedObject(combinedResults: JSONObject, keyList: string[]): JSONObject {
-        let workingObject = combinedResults;
-        keyList.forEach((key) => {
-            if (!workingObject[key]) {
-                workingObject[key] = { };
-                workingObject = workingObject[key];
-            }
-        });
-        return combinedResults;
-    }
-
-    get writeClient(): WriteApi {
-        if (!this.#writeClient) {
-            /* Defaults from the library as at 12/11/2023
-            // default RetryDelayStrategyOptions
-            export const DEFAULT_RetryDelayStrategyOptions = {
-                retryJitter: 200,
-                minRetryDelay: 5000,
-                maxRetryDelay: 125000,
-                exponentialBase: 5,
-                randomRetry: true,
-            }
-            
-            // default writeOptions
-            export const DEFAULT_WriteOptions: WriteOptions = {
-                batchSize: 1000,
-                maxBatchBytes: 50_000_000, // default max batch size in the cloud
-                flushInterval: 60000,
-                writeFailed: function () {},
-                writeSuccess: function () {},
-                writeRetrySkipped: function () {},
-                maxRetries: 5,
-                maxRetryTime: 180_000,
-                maxBufferLines: 32_000,
-                // a copy of DEFAULT_RetryDelayStrategyOptions, so that DEFAULT_WriteOptions could be tree-shaken
-                retryJitter: 200,
-                minRetryDelay: 5000,
-                maxRetryDelay: 125000,
-                exponentialBase: 2,
-                gzipThreshold: 1000,
-                randomRetry: true,
-            }
-            */
-    
-            const flushBatchSize = DEFAULT_WriteOptions.batchSize;
-
-            const writeOptions: Partial<WriteOptions> = {
-                /* the maximum points/lines to send in a single batch to InfluxDB server */
-                batchSize: flushBatchSize + 1, // don't let automatically flush data
-                /* default tags to add to every point */
-                //defaultTags: {location: hostname},
-                /* maximum time in millis to keep points in an unflushed batch, 0 means don't periodically flush */
-                flushInterval: 0,
-                // max size of a batch in bytes
-                maxBatchBytes: 50_000_000, // default max batch size in the cloud
-
-                // Retry Options
-
-                /* maximum size of the retry buffer - it contains items that could not be sent for the first time */
-                maxBufferLines: 30000,
-                /* the count of internally-scheduled retries upon write failure, the delays between write attempts follow an exponential backoff strategy if there is no Retry-After HTTP header */
-                maxRetries: 5, // do not retry writes
-                // max time (millis) that can be spent with retries
-                maxRetryTime: 180_000,
-
-                // ... there are more write options that can be customized, see
-                // https://influxdata.github.io/influxdb-client-js/influxdb-client.writeoptions.html and
-                // https://influxdata.github.io/influxdb-client-js/influxdb-client.writeretryoptions.html
-                writeFailed: (error, lines, attempt, expires) => {
-                    this.#LogDebugMessage(chalk.red(`writeOptions:writeSuccess(): Error: [${error}], Attempt: [${attempt}], Expires: [${expires}], Lines: [${lines}]`));
-                },
-                writeSuccess: (lines) => {
-                    // Needs option
-                    //@@this.#LogDebugMessage(chalk.green(`writeOptions:writeSuccess(): Lines: [${lines}]`));
-                },
-                writeRetrySkipped: (entry) => {
-                    this.#LogDebugMessage(chalk.magenta(`writeOptions:writeSuccess(): Expires: [${entry.expires}], Lines: [${entry.lines}]`));
-                }
-            }
-    
-            this.#writeClient = this.#client.getWriteApi(this.#org, this.#bucket, 'ns', writeOptions);
-
-            let attemptCount = 0;
-            const maxAttemptCount = 5;
-            const normalFlushDelay = 1000;
-            const retryFlushDelay = 2500;
-    
-            const StartWriteClient = (delay: number) => {
-                this.#writeDataPointFlushTimeout = setTimeout(async () => {
-                    if (this.#writeClient) {
-                        try {
-                            attemptCount++;
-                            const start = performance.now();
-                            await this.#writeClient.flush();
-                            const end = performance.now();
-                            // Needs option
-                            //@@this.#LogDebugMessage(chalk.gray(`InfluxDB Flush time: [${end-start}]`));
-                            attemptCount = 0;
-                            StartWriteClient(normalFlushDelay); 
-                        } catch (error) {
-                            this.#LogErrorMessage(chalk.red(`InfluxDBManager:StartWriteClient(): Attempt: [${attemptCount}], Error: [${error}]`));
-                            if (attemptCount === maxAttemptCount) {
-                                this.#LogErrorMessage(chalk.red(`InfluxDBManager:StartWriteClient(): Max Attempts reached. Will no longer retry.`));
-                                this.#LogErrorMessage(chalk.red(`InfluxDBManager:StartWriteClient(): InfluxDB data capture ended in permanent faiilure.`));
-                            } else {
-                                StartWriteClient(retryFlushDelay);
-                            }
-                        }
-                    }
-                }, delay).unref();
-            }
-    
-            StartWriteClient(normalFlushDelay);
-        }
-        return this.#writeClient;
-    }
-
-    // Agent context payload
-    // {"nid":"somehost@e58f5d75-6ff6-4e04-92a4-f2bcd722fec0-someuseragent|MainProcess|0","id":"somehost@e58f5d75-6ff6-4e04-92a4-f2bcd722fec0-someuseragent|MainProcess|0","hostName":"somehost","agentName":"e58f5d75-6ff6-4e04-92a4-f2bcd722fec0-someuseragent","threadId":"MainProcess","asyncRunnerId":"0"}
-    async OutputInfluxDB(instrumentPayload: IInstrumentPayload): Promise<boolean> {
-        try {
-            if (this.#shuttingDown) {
-                return false;
-            }
-
-            //@@ Below is terrible - need a specific field on context for the service type
-            if (instrumentPayload.context.agentName) {
-                return this.#influxDBManagerClients['agent'].OutputInfluxDB(this.writeClient, instrumentPayload, 'agent');
-            } else if (instrumentPayload.context.lambdaFunctionName) {
-                return this.#influxDBManagerClients['lambda'].OutputInfluxDB(this.writeClient, instrumentPayload, 'lambda');
-            } else {
-                return this.#influxDBManagerClients['service'].OutputInfluxDB(this.writeClient, instrumentPayload, 'service');
-            }
-        } catch (error) {
-            this.#LogErrorMessage(chalk.red(`${_logPrefix}OutputInfluxDB: Could not write data point: [${error}]`));
-            return false;
-        }
-    }
-}

package/src/influxdb/influxDBManagerAgent.ts

@@ -1,14 +0,0 @@
-import { QueryApi } from '@influxdata/influxdb-client'
-import { InfluxDBManagerBase } from './influxDBManagerBase'
-import { IInfluxDBManagerOptions } from './../commonTypes'
-
-export class InfluxDBManagerAgent extends InfluxDBManagerBase
-{
-    constructor(options: IInfluxDBManagerOptions, queryApi: QueryApi) {
-        super(options, queryApi);
-    }
-
-    override get modelType(): string {
-        return 'agent'
-    }
-}

package/src/influxdb/influxDBManagerBase.ts

@@ -1,108 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-// https://www.influxdata.com/blog/tldr-influxdb-tech-tips-multiple-aggregations-yield-flux/
-// https://www.influxdata.com/blog/top-5-hurdles-for-intermediate-flux-users-and-resources-for-optimizing-flux/
-import { Point, WriteApi, QueryApi } from '@influxdata/influxdb-client'
-
-import { IInfluxDBManagerOptions } from './../commonTypes'
-import { IInstrumentPayload } from '@nsshunt/stsobservability'
-
-import chalk from 'chalk';
-
-import { globalServiceDefinitions, IServiceDefinition, IFieldRecord, influxDBDataType } from '@nsshunt/stsobservability'
-
-const _logPrefix = 'InfluxDBManager:'
-
-export class InfluxDBManagerBase
-{
-    #queryApi: QueryApi;
-    #shuttingDown: boolean = false;
-    #options: IInfluxDBManagerOptions;
-
-    constructor(options: IInfluxDBManagerOptions, queryApi: QueryApi) {
-        this.#queryApi = queryApi;
-        this.#options = options;
-    }
-
-    #LogErrorMessage(message: any) {
-        this.options.logger.error(message);
-    }
-
-    get options() {
-        return this.#options;
-    }
-    get queryApi() {
-        return this.#queryApi;
-    }
-
-    get shuttingDown() {
-        return this.#shuttingDown;
-    }
-    set shuttingDown(val: boolean) {
-        this.#shuttingDown = val;
-    }
-
-    get modelType(): string {
-        throw new Error('modelType(): Must override in sub-class')
-    }
-
-    // Agent context payload
-    // {"nid":"somehost@e58f5d75-6ff6-4e04-92a4-f2bcd722fec0-someuseragent|MainProcess|0","id":"somehost@e58f5d75-6ff6-4e04-92a4-f2bcd722fec0-someuseragent|MainProcess|0","hostName":"somehost","agentName":"e58f5d75-6ff6-4e04-92a4-f2bcd722fec0-someuseragent","threadId":"MainProcess","asyncRunnerId":"0"}
-    async OutputInfluxDB(writeApi: WriteApi, instrumentPayload: IInstrumentPayload, serviceType: string): Promise<boolean> {
-        if (writeApi) {
-            let fieldName = '';
-            try {
-                if (this.shuttingDown) {
-                    return false;
-                }
-
-                const service: IServiceDefinition = globalServiceDefinitions.services[serviceType];
-                const fieldList: IFieldRecord[] = [ 
-                    ...globalServiceDefinitions.coreFieldList, 
-                    ...service.fieldList 
-                ];
-
-                const point = new Point('all').measurement(serviceType)
-
-                service.influxDBContextTags.forEach(v => {
-                    point.tag(v, instrumentPayload.context[v]);
-                });
-
-                fieldList.forEach(v => {
-                    let value;
-                    let useDefault = false;
-                    fieldName = v.fieldName;
-
-                    if (!Object.prototype.hasOwnProperty.call(instrumentPayload.instruments, v.gauge)) {
-                        useDefault = true;
-                    } else if (!Object.prototype.hasOwnProperty.call(instrumentPayload.instruments[v.gauge], v.instrumentProperty)) {
-                        useDefault = true;
-                    }
-
-                    if (useDefault) {
-                        if (v.influxdbDataType.localeCompare(influxDBDataType.floatField) == 0) {
-                            value = 0.0;
-                        } else if (v.influxdbDataType.localeCompare(influxDBDataType.intField) == 0) {
-                            value = 0;
-                        } else {
-                            value = '';
-                        }
-                    } else {
-                        value = (instrumentPayload.instruments[v.gauge] as any)[v.instrumentProperty];
-                    }
-                    point[v.influxdbDataType](v.fieldName, value);
-                });
-
-                writeApi.writePoint(point);
-
-                return true;
-            } catch (error: any) {
-                this.#LogErrorMessage(chalk.red(`${_logPrefix}OutputInfluxDB: Could not write data point: [${error}], FieldName: [${fieldName}]`));
-                this.#LogErrorMessage(chalk.red(`${JSON.stringify(instrumentPayload.context)}`));
-                return false;
-            }
-        } else {
-            this.#LogErrorMessage(chalk.red(`${_logPrefix}OutputInfluxDBService: Could not write data point as writeClient is null`));
-            return false;
-        }
-    }
-}

package/src/influxdb/influxDBManagerLambda.ts

@@ -1,17 +0,0 @@
-import { QueryApi } from '@influxdata/influxdb-client'
-import { InfluxDBManagerBase } from './influxDBManagerBase'
-import { IInfluxDBManagerOptions } from './../commonTypes'
-
-/**
- * Placeholder class for InfluxDB Lambda queries. May not implement as Redis Stacks is now used as replacement for near real time monitoring.
- */
-export class InfluxDBManagerLambda extends InfluxDBManagerBase
-{
-    constructor(options: IInfluxDBManagerOptions, queryApi: QueryApi) {
-        super(options, queryApi);
-    }
-
-    override get modelType(): string {
-        return 'lambda'
-    }
-}