@nsshunt/stsappframework 3.0.103 → 3.0.105

package/src_working/influxdb/influxDBManagerService.ts

@@ -1,373 +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/
-
-/*
-option task = { 
-  name: "task-sts-service-stats",
-  every: 1s,
-}
-
-data =
-    from(bucket: "TestBucket01")
-        |> range(start: -5s)
-        |> last()
-        |> filter(fn: (r) => r["_measurement"] == "service" and r["_field"] != "memory")
-
-r1 =
-    data
-        |> filter(
-            fn: (r) =>
-                r["_field"] == "requestCount" or r["_field"] == "errorCount" or r["_field"]
-                    ==
-                    "retryCount" or r["_field"] == "authenticationCount" or r["_field"]
-                    ==
-                    "activeRequestCount" or r["_field"] == "connectionCount" or r["_field"]
-                    ==
-                    "connectionPoolCount" or r["_field"] == "connectionIdleCount" or r["_field"]
-                    ==
-                    "connectionWaitingCount" or r["_field"] == "coreCount" or r["_field"] == "cpu"
-                    or
-                    r["_field"] == "systemcpu" or r["_field"] == "velocity" or r["_field"]
-                    ==
-                    "timer" or r["_field"] == "rx" or r["_field"] == "tx",
-        )
-
-r2 =
-    data
-        |> filter(
-            fn: (r) =>
-                float(v: r["_value"]) > 0.0 and (r["_field"] == "duration" or r["_field"]
-                        ==
-                        "latency"),
-        )
-
-serviceInstanceProcessSum =
-    r1
-        |> group(columns: ["serviceId", "serviceInstanceId", "serviceInstanceProcessId", "_field"])
-        |> sum()
-        |> toFloat()
-
-serviceInstanceProcessMean =
-    r2
-        |> group(columns: ["serviceId", "serviceInstanceId", "serviceInstanceProcessId", "_field"])
-        |> mean()
-        |> toFloat()
-
-union(tables: [serviceInstanceProcessSum, serviceInstanceProcessMean])
-    |> map(fn: (r) => ({r with _time: now(), _measurement: "sts-stats-by-serviceinstanceprocess"}))
-    |> to(org: "my-org", bucket: "TestBucket01")
-
-serviceInstanceSum =
-    r1
-        |> group(columns: ["serviceId", "serviceInstanceId", "_field"])
-        |> sum()
-        |> toFloat()
-
-serviceInstanceMean =
-    r2
-        |> group(columns: ["serviceId", "serviceInstanceId", "_field"])
-        |> mean()
-        |> toFloat()
-
-union(tables: [serviceInstanceSum, serviceInstanceMean])
-    |> map(fn: (r) => ({r with _time: now(), _measurement: "sts-stats-by-serviceinstance"}))
-    |> to(org: "my-org", bucket: "TestBucket01")
-
-serviceSum =
-    r1
-        |> group(columns: ["serviceId", "_field"])
-        |> sum()
-        |> toFloat()
-
-serviceMean =
-    r2
-        |> group(columns: ["serviceId", "_field"])
-        |> mean()
-        |> toFloat()
-
-union(tables: [serviceSum, serviceMean])
-    |> map(fn: (r) => ({r with _time: now(), _measurement: "sts-stats-by-service"}))
-    |> to(org: "my-org", bucket: "TestBucket01")
-
-globalServiceSum =
-    r1
-        |> group(columns: ["_field"])
-        |> sum()
-        |> toFloat()
-
-globalServiceMean =
-    r2
-        |> group(columns: ["_field"])
-        |> mean()
-        |> toFloat()
-
-union(tables: [globalServiceSum, globalServiceMean])
-    |> map(fn: (r) => ({r with _time: now(), _measurement: "sts-stats-globalservice"}))
-    |> to(org: "my-org", bucket: "TestBucket01")
-
-*/
-
-import { Point, WriteApi, QueryApi } from '@influxdata/influxdb-client'
-
-import { Gauge, InstrumentVelocity } from '@nsshunt/stsinstrumentation'
-
-import { InfluxDBManagerBase } from './influxDBManagerBase'
-
-import { IInfluxDBManagerOptions, InstrumentPayload } from './../commonTypes'
-import { ISubscriptionPayload, ISubscriptionKey } from '@nsshunt/stssocketio-client'
-
-const _logPrefix = 'InfluxDBManagerService:'
-
-/*
-const SERVICE_STATS_BY_SERVICE_INSTANCE_PROCESS = "sts-stats-sum-byserviceInstanceprocessid";
-const SERVICE_STATS_BY_SERVICE_INSTANCE = "sts-stats-sum-byserviceinstance";
-const SERVICE_STATS_BY_SERVICE = "sts-stats-sum-byservice";
-const SERVICE_STATS_GLOBAL = "sts-stats-sum";
-*/
-
-const SERVICE_STATS_BY_SERVICE_INSTANCE_PROCESS = "sts-stats-by-serviceinstanceprocess";
-const SERVICE_STATS_BY_SERVICE_INSTANCE = "sts-stats-by-serviceinstance";
-const SERVICE_STATS_BY_SERVICE = "sts-stats-by-service";
-const SERVICE_STATS_GLOBAL = "sts-stats-globalservice";
-
-export class InfluxDBManagerService extends InfluxDBManagerBase
-{
-    constructor(options: IInfluxDBManagerOptions, queryApi: QueryApi) {
-        super(options, queryApi);
-    }
-
-    override get modelType(): string {
-        return 'service'
-    }
-
-    // Queries --------------------------------------------------------------------------------------------------------
-
-    /*
-    data = from(bucket: "my-bucket")
-|> range(start: -task.every)
-|> filter(fn: (r) => r._measurement == "my_measurement")
-
-data
-|> mean()
-|> set(key: "agg_type",value: "mean_temp")
-|> to(bucket: "downsampled", org: "my-org", tagColumns: ["agg_type"])
-
-data
-|> count()
-|> set(key: "agg_type",value: "count_temp")
-|> to(bucket: "downsampled", org: "my-org", tagColumns: ["agg_type"])
-*/
-
-    #GetSTSCountGenericService = async (measurement: string, filterClause: string, showOutput: boolean = false): Promise<any> => {
-        try {
-            const query = `r1 = from(bucket: "${this.options.bucket}") 
-            |> range(start: -5s) 
-            |> last()
-            |> filter(fn: (r) => r["_measurement"] == "${measurement}" ${filterClause})
-
-            r2 = from(bucket: "${this.options.bucket}") 
-            |> range(start: -5s) 
-            |> last()
-            |> filter(fn: (r) => r["_measurement"] == "service" ${filterClause} and r["_field"] == "memory")
-
-            union(tables: [r1, r2])`;
-
-            if (showOutput) {
-                console.log(query);
-            }
-
-            return this.queryApi.collectRows(query)
-        } catch (error) {
-            console.error(`${_logPrefix}#GetSTSCountGeneric: Error: [${error}]`.red);
-        }
-    }
-
-    // Histo metrics
-    #GetSTSHistoGenericService = async (measurement: string, filterClause: string): Promise<any> => {
-        try {
-            const query = `import "math"
-            from(bucket: "${this.options.bucket}") 
-            |> range(start: -10m) 
-            |> filter(fn: (r) => r["_measurement"] == "${measurement}" and (r["_field"] =="latency" or
-                r["_field"] =="duration") ${filterClause})
-            |> histogram(bins: [0.0, 10.0, 20.0, 50.0, 100.0, 1000.0, 50000.0, math.mInf(sign: 1) ])
-            |> difference()`;
-            return this.queryApi.collectRows(query)
-        } catch (error) {
-            console.error(`${_logPrefix}#GetSTSHistoGeneric: Error: [${error}]`.red);
-        }
-    }
-
-    // Quantile metrics
-    #GetSTSQuantileGenericService = async (measurement: string, filterClause: string): Promise<any> => {
-        try {
-            const query = `data = from(bucket: "${this.options.bucket}") 
-            |> range(start: -10m) 
-            |> filter(fn: (r) => r["_measurement"] == "${measurement}" and (r["_field"] == "latency" or
-                r["_field"] == "duration" or
-                r["_field"] == "cpu" or
-                r["_field"] == "systemcpu") ${filterClause})
-            |> aggregateWindow(every: 5s, fn: max, createEmpty: false)
-            
-            dostsquantileex = (q) =>
-            data
-            |> quantile(q: q, method: "estimate_tdigest", compression: 1000.0)
-            |> set(key: "quantile", value: string(v:q))
-            |> group(columns: ["quantile"])
-            
-            union(tables: [
-                dostsquantileex(q: 0.5),
-                dostsquantileex(q: 0.8),
-                dostsquantileex(q: 0.9),
-                dostsquantileex(q: 0.95),
-                dostsquantileex(q: 0.99)
-            ])`;
-            
-            return this.queryApi.collectRows(query)
-        } catch (error) {
-            console.error(`${_logPrefix}#GetSTSQuantileGeneric: Error: [${error}]`.red);
-        }
-    }
-
-    // Metric queries -------------------------------------------------------------------------------------------------
-    // Root level metrics
-    async GetInfluxDBResultsRootService(subscriptionKey: ISubscriptionKey): Promise<ISubscriptionPayload> {
-        let retVal = null;
-        try {
-            retVal = await this.ProcessInfluxDBResults([
-                this.#GetSTSCountGenericService(SERVICE_STATS_GLOBAL, ''),
-                this.#GetSTSQuantileGenericService(SERVICE_STATS_GLOBAL, ''),
-                this.#GetSTSHistoGenericService(SERVICE_STATS_GLOBAL, '')],
-            [ ])
-        } catch (error) {
-            console.error(`${_logPrefix}GetInfluxDBResultsRoot: Error: [${error}]`.red);
-        }
-        return { 
-            subscriptionKey,
-            data: retVal 
-        };
-    }
-
-    // Service level metrics
-    async GetInfluxDBResultsService(subscriptionKey: ISubscriptionKey): Promise<ISubscriptionPayload> {
-        let retVal = null;
-        try {
-            retVal = await this.ProcessInfluxDBResults([
-                this.#GetSTSCountGenericService(SERVICE_STATS_BY_SERVICE, ''),
-                this.#GetSTSQuantileGenericService(SERVICE_STATS_BY_SERVICE, ''),
-                this.#GetSTSHistoGenericService(SERVICE_STATS_BY_SERVICE, '')],
-            ['serviceId'])
-        } catch (error) {
-            console.error(`${_logPrefix}GetInfluxDBResultsService: Error: [${error}]`.red);
-        }
-        return { 
-            subscriptionKey,
-            data: retVal 
-        };
-
-    }
-
-    // Service instance metrics for a particular service type
-    async GetInfluxDBResultsServiceInstances(subscriptionKey: ISubscriptionKey): Promise<ISubscriptionPayload> {
-        let retVal = null;
-        try {
-            const serviceId = subscriptionKey.key as string;
-            retVal = await this.ProcessInfluxDBResults([
-                this.#GetSTSCountGenericService(SERVICE_STATS_BY_SERVICE_INSTANCE, `and r["serviceId"] == "${serviceId}"`),
-                this.#GetSTSQuantileGenericService(SERVICE_STATS_BY_SERVICE_INSTANCE, `and r["serviceId"] == "${serviceId}"`),
-                this.#GetSTSHistoGenericService(SERVICE_STATS_BY_SERVICE_INSTANCE, `and r["serviceId"] == "${serviceId}"`)],
-            ['serviceId', 'serviceInstanceId'])
-        } catch (error) {
-            console.error(`${_logPrefix}GetInfluxDBResultsServiceInstances: Error: [${error}]`.red);
-        }
-        return { 
-            subscriptionKey,
-            data: retVal 
-        };
-    }
-
-    // Service instance thread metrics for a particular service instance
-    async GetInfluxDBResultsServiceInstance(subscriptionKey: ISubscriptionKey): Promise<ISubscriptionPayload> {
-        let retVal = null;
-        try {
-            const serviceInstanceId = subscriptionKey.key as string;
-            retVal = await this.ProcessInfluxDBResults([
-                this.#GetSTSCountGenericService(SERVICE_STATS_BY_SERVICE_INSTANCE_PROCESS, `and r["serviceInstanceId"] == "${serviceInstanceId}"`),
-                this.#GetSTSQuantileGenericService(SERVICE_STATS_BY_SERVICE_INSTANCE_PROCESS, `and r["serviceInstanceId"] == "${serviceInstanceId}"`),
-                this.#GetSTSHistoGenericService(SERVICE_STATS_BY_SERVICE_INSTANCE_PROCESS, `and r["serviceInstanceId"] == "${serviceInstanceId}"`)],
-            ['serviceId', 'serviceInstanceId', 'serviceInstanceProcessId'])
-        } catch (error) {
-            console.error(`${_logPrefix}GetInfluxDBResultsServiceInstance: Error: [${error}]`.red);
-        }
-        return { 
-            subscriptionKey,
-            data: retVal 
-        };
-    }
-    
-    // Write data points ----------------------------------------------------------------------------------------------
-    // 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: InstrumentPayload): Promise<boolean> {
-        if (writeApi) {
-            try {
-                if (this.shuttingDown) {
-                    return false;
-                }
-
-                const { serviceId, serviceInstanceId, hostName, serviceInstanceProcessId, 
-                    pid, ppid, serviceName, serviceVersion } = instrumentPayload.context;
-
-                let systemcpu = 0.0;
-                if (instrumentPayload.instruments[Gauge.CPU_SYSTEM_LOAD_GAUGE]) {
-                    systemcpu = (instrumentPayload.instruments[Gauge.CPU_SYSTEM_LOAD_GAUGE].val as number);
-                }
-
-                const point = new Point('all')
-                    .measurement('service')
-                    // Context settings
-                    .tag('serviceId', serviceId as string)
-                    .tag('serviceName', serviceName as string)
-                    .tag('serviceVersion', serviceVersion as string)
-                    .tag('serviceInstanceId', serviceInstanceId as string)
-                    .tag('serviceInstanceProcessId', serviceInstanceProcessId as string)
-                    .tag('hostName', hostName as string)
-                    .tag('pid', (pid as number).toString())
-                    .tag('ppid', (ppid as number).toString())
-                    // Data fields
-                    .intField('requestCount', instrumentPayload.instruments[Gauge.REQUEST_COUNT_GAUGE].val)
-                    .intField('errorCount', instrumentPayload.instruments[Gauge.ERROR_COUNT_GAUGE].val)
-                    .intField('retryCount', instrumentPayload.instruments[Gauge.RETRY_COUNT_GAUGE].val)
-                    .intField('authenticationCount', instrumentPayload.instruments[Gauge.AUTHENTICATION_COUNT_GAUGE].val)
-                    .floatField('velocity', (instrumentPayload.instruments[Gauge.VELOCITY_GAUGE] as InstrumentVelocity).va) // Note: Using va not val here
-                    .floatField('cpu', instrumentPayload.instruments[Gauge.CPU_LOAD_GAUGE].val)
-                    .intField('activeRequestCount', instrumentPayload.instruments[Gauge.ACTIVE_REQUEST_GAUGE].val)
-                    .intField('connectionCount', instrumentPayload.instruments[Gauge.CONNECTION_COUNT_GAUGE].val)
-                    .intField('connectionPoolCount', instrumentPayload.instruments[Gauge.CONNECTION_POOL_TOTAL_GAUGE].val)
-                    .intField('connectionIdleCount', instrumentPayload.instruments[Gauge.CONNECTION_POOL_IDLE_GAUGE].val)
-                    .intField('connectionWaitingCount', instrumentPayload.instruments[Gauge.CONNECTION_POOL_WAITING_GAUGE].val)
-                    .intField('coreCount', instrumentPayload.instruments[Gauge.CORE_COUNT_GAUGE].val)
-                    //.intField('rx', instrumentPayload.instruments[Gauge.NETWORK_RX_GAUGE].val)
-                    //.intField('tx', instrumentPayload.instruments[Gauge.NETWORK_TX_GAUGE].val)
-                    .floatField('rx', (instrumentPayload.instruments[Gauge.NETWORK_RX_GAUGE] as InstrumentVelocity).va) // Note: Using va not val here
-                    .floatField('tx', (instrumentPayload.instruments[Gauge.NETWORK_TX_GAUGE] as InstrumentVelocity).va) // Note: Using va not val here
-                    .floatField('timer', instrumentPayload.instruments[Gauge.TIMER_GAUGE].val)
-                    .floatField('duration', instrumentPayload.instruments[Gauge.DURATION_GAUGE].val)
-                    .floatField('latency', instrumentPayload.instruments[Gauge.LATENCY_GAUGE].val)
-                    .floatField('systemcpu', systemcpu)
-                    .stringField('memory', JSON.stringify(instrumentPayload.instruments[Gauge.OBJECT_GAUGE].val))
-
-                writeApi.writePoint(point);
-                return true;
-            } catch (error: any) {
-                console.error(`${_logPrefix}OutputInfluxDB: Could not write data point: [${error}]`.red);
-                console.error(`${JSON.stringify(instrumentPayload.context)}`.red);
-                return false;
-            }
-        } else {
-            console.error(`${_logPrefix}OutputInfluxDBService: Could not write data point as writeClient is null`.red);
-            return false;
-        }
-    }
-}

package/src_working/instrumentationsubscriber.ts

@@ -1,283 +0,0 @@
-import { IKafkaConsumer, logFunction } from './commonTypes'
-import { ISubscriptionPayload, ISubscriptionKey, SubscriptionTopic, IKafkaData } from '@nsshunt/stssocketio-client'
-
-import { KafkaManager, IKafkaManagerConfig } from './kafka/kafkamanager'
-import { InfluxDBManager } from './influxdb/influxDBManager'
-import { v4 as uuidv4 } from 'uuid';
-
-import { $Options } from '@nsshunt/stsconfig'
-import { STSOptionsBase } from '@nsshunt/stsutils';
-const goptions = $Options()
-
-declare interface IKafkaSubscription {
-    kafkaTopic: string
-    kafkaGroupId: string
-    kafkaConsumer: IKafkaConsumer
-    kafkaFromBeginning: boolean
-}
-
-declare interface ISubscription {
-    subscriptionKey: ISubscriptionKey
-    kafka?: IKafkaSubscription
-    cb: (payload: ISubscriptionPayload) => void
-}
-
-declare type ISubscriptions = Record<string, ISubscription>;
-
-export interface IInstrumentationSubscriberOptions {
-    SubscriptionInterval: number
-    logger?: logFunction
-}
-
-export class InstrumentationSubscriber extends STSOptionsBase {
-    #subscriptions: ISubscriptions = { };
-    #influxDBManager: InfluxDBManager;
-    #interval: NodeJS.Timer | null = null;
-    #km: KafkaManager;
-    #logger: logFunction | null = null;
-
-    constructor(options: IInstrumentationSubscriberOptions) {
-        super(options);
-
-        if (options.logger) {
-            this.#logger = options.logger;
-        }
-
-        this.#influxDBManager = new InfluxDBManager();
-
-        const kmc: IKafkaManagerConfig = {
-            clientId: `${goptions.kafka_clientId}_${uuidv4()}`,
-            brokers: goptions.kafka_brokers.split(','),
-            keepAlive: goptions.kafka_keep_alive,
-            adminTimeout: goptions.kafka_admin_timeout,
-            connectionTimeout: goptions.kafka_connection_timeout,
-            logLevel: goptions.kafka_log_level,
-            useSSL: goptions.kafka_use_ssl,
-            requestTimeout: goptions.kafka_request_timeout
-        }
-        if (goptions.kafka_use_ssl) {
-            kmc.ssl = {
-                rejectUnauthorized: goptions.kafka_ssl_rejectUnauthorized,
-                cafile: goptions.kafka_ssl_cafile,
-                certfileFile: goptions.kafka_ssl_certfile,
-                keyfile: goptions.kafka_ssl_keyfile
-            }
-        }
-        this.#km = new KafkaManager(kmc);
-    }
-
-    // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-    #Log(msg: any): void {
-        if (this.#logger) {
-            this.#logger(msg);
-        } else {
-            console.log(msg);
-        }
-    }
-
-    async #UnSubscribeKafka(subscription: ISubscription): Promise<void> {
-        const unsubscribeKafka = async () => {
-            const kafka = subscription.kafka;
-            if (kafka) {
-                // Un-Subscribe from this kafka topic
-                this.#Log(`InstrumentationSubscriber:#UnSubscribeKafka(): Unsubscribe from Kafka topc: [${kafka.kafkaTopic}] Starting`.yellow)
-                await kafka.kafkaConsumer?.Stop();
-                await kafka.kafkaConsumer?.Disconnect();
-                this.#Log(`InstrumentationSubscriber:#UnSubscribeKafka(): Unsubscribe from Kafka topc: [${kafka.kafkaTopic}] Completed.`.yellow)
-            } else {
-                this.#Log(`InstrumentationSubscriber:#UnSubscribeKafka(): Kafka details do not exist for this topc: [${JSON.stringify(subscription.subscriptionKey)}].`.magenta)
-            }
-        };
-        return unsubscribeKafka();
-    }
-
-    async #SubscribeKafka(subscription: ISubscription): Promise<void> {
-        const kafkaSubscribe = async () => {
-            if (subscription.subscriptionKey.id) {
-
-                const kafkaSafeKey = `${subscription.subscriptionKey.key}`.replace(/@/g, '_').replace(/\|/g, '_');
-
-                const kafkaGroupId = uuidv4();
-                subscription.kafka = {
-                    kafkaTopic: kafkaSafeKey,
-                    kafkaGroupId: kafkaGroupId,
-                    kafkaConsumer: this.#km.CreateConsumer(kafkaGroupId),
-                    kafkaFromBeginning: goptions.kafka_consume_from_beginning
-                };
-                this.#Log(`InstrumentationSubscriber:#SubscribeKafka(): Subscribe to Kafka topc: [${subscription.kafka.kafkaTopic}] Starting`.yellow)
-
-                const kafka = subscription.kafka;
-                await kafka.kafkaConsumer.Connect();
-                await kafka.kafkaConsumer.Subscribe([kafka.kafkaTopic], subscription.kafka.kafkaFromBeginning );
-                // eslint-disable-next-line  @typescript-eslint/no-unused-vars
-                await kafka.kafkaConsumer.StartConsumingMessages((topic, key, partition, value, headers) => {
-                    try {
-                        if (key != "" && value != "") {
-                            if (topic.localeCompare(key) === 0) {
-                                subscription.cb({
-                                    subscriptionKey: subscription.subscriptionKey,// Original requested topic (may be kafka un-safe)
-                                    data: { 
-                                        kafkaTopic: kafka.kafkaTopic, // Safe kafka topic key with prefix. kafkaTopic, topic and key should be same value
-                                        kafkaGroupId: kafka.kafkaGroupId,
-                                        partition,
-                                        topic, // kafkaTopic, topic and key should be same value
-                                        key, // kafkaTopic, topic and key should be same value
-                                        value
-                                    } as IKafkaData
-                                });
-                            } else {
-                                this.#Log(`InstrumentationSubscriber:#SubscribeKafka(): Invalid message format from Kafka data, topic: [${topic}] and key: [${key}] do not match`.red);
-                            }
-                        } else {
-                            this.#Log(`InstrumentationSubscriber:#SubscribeKafka(): Invalid message format from Kafka data, topic: [${topic}], key: [${key}], value: [${value}]`.red);
-                        }
-                    } catch (error) {
-                        this.#Log(`InstrumentationSubscriber:#SubscribeKafka(): Error: [${error}]`.red);
-                    }
-                });
-                this.#Log(`InstrumentationSubscriber:#SubscribeKafka(): Subscribe to Kafka topc: [${kafka.kafkaTopic}] Completed`.yellow)
-            } else {
-                this.#Log(`InstrumentationSubscriber:#SubscribeKafka(): Could not subscribe to Kafka topc, missing combinedKey for topic: [${JSON.stringify(subscription.subscriptionKey)}]`.magenta);
-            }
-        }
-        return kafkaSubscribe();
-    }
-
-    async #OutputSubscription(subscription: ISubscription): Promise<ISubscriptionPayload> {
-        // Service subscriptions
-        const { subscriptionKey }  = subscription;
-        switch (subscriptionKey.topic) {
-        // Services -------------------------------------------------------------------------------------------
-        case SubscriptionTopic.AllServicesCombined :
-            return this.#influxDBManager.serviceManager.GetInfluxDBResultsRootService(subscriptionKey);
-        case SubscriptionTopic.Services :
-            return this.#influxDBManager.serviceManager.GetInfluxDBResultsService(subscriptionKey);
-        case SubscriptionTopic.ServiceInstances :
-            if (subscriptionKey.key) { // key = service_id
-                return this.#influxDBManager.serviceManager.GetInfluxDBResultsServiceInstances(subscriptionKey);
-            } else {
-                throw new Error(`#OutputSubscription: key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
-            }
-        case SubscriptionTopic.ServiceInstance :
-            if (subscriptionKey.key) { // key = service instance id
-                return this.#influxDBManager.serviceManager.GetInfluxDBResultsServiceInstance(subscriptionKey);
-            } else {
-                throw new Error(`#OutputSubscription: key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
-            }
-
-            // User Agents -------------------------------------------------------------------------------------------
-        case SubscriptionTopic.AllAgentsCombined :
-            return this.#influxDBManager.agentManager.GetInfluxDBResultsRootAgent(subscriptionKey);
-        case  SubscriptionTopic.Agents :
-            return this.#influxDBManager.agentManager.GetInfluxDBResultsAgent(subscriptionKey);
-        case  SubscriptionTopic.AgentWorkers :
-            if (subscriptionKey.key) { // key = agent instance id
-                return this.#influxDBManager.agentManager.GetInfluxDBResultsAgentThreads(subscriptionKey);
-            } else {
-                throw new Error(`#OutputSubscription: key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
-            }
-        case SubscriptionTopic.AgentWorker :
-            if (subscriptionKey.key && subscriptionKey.subkey) { // key = agent instance id, subkey = agent instance worker id
-                return this.#influxDBManager.agentManager.GetInfluxDBResultsAgentThread(subscriptionKey);
-            } else {
-                throw new Error(`#OutputSubscription: key and/or subkey not provided for subscription: [${JSON.stringify(subscriptionKey.topic)}]`);
-            }
-
-            // Logging (both service and agent) -----------------------------------------------------------------------
-        case SubscriptionTopic.LogProcessing :
-            // Kafka processing will be handled by a dedicated kafka run consumer
-            return { subscriptionKey, data: null };
-        default :
-            return { subscriptionKey, data: null };
-        }   
-    }
-
-    #ExecuteSubscriptions = async () => {
-        const promArray: Promise<ISubscriptionPayload>[] = [ ];
-        const indexArray: ISubscription[] = [ ];
-
-        for (const [, subscription] of Object.entries(this.#subscriptions)) {
-            // If NOT Kafka, go get the data from influxdb
-            if (subscription.subscriptionKey.topic.localeCompare(SubscriptionTopic.LogProcessing.toString()) !== 0) {
-                promArray.push(this.#OutputSubscription(subscription));
-                indexArray.push(subscription);
-            }
-        }
-        const retVal = await Promise.all(promArray);
-        try {
-            for (let i=0; i < retVal.length; i++) {
-                // Provided we have data, invoke the callback
-                if (retVal[i].data) {
-                    indexArray[i].cb(retVal[i]);
-                }
-            }
-        } catch (error) {
-            this.#Log(`InstrumentationSubscriber:#ExecuteSubscriptions(): Error: [${error}], [${JSON.stringify(retVal)}]`.red);
-        }
-    }
-
-    Subscribe(subscriptionKey: ISubscriptionKey, cb: (payload: ISubscriptionPayload) => void) {
-        if (this.#interval) {
-            clearInterval(this.#interval);
-            this.#interval = null;
-        }
-        if (this.#subscriptions[subscriptionKey.id]) {
-            // Subscription already exists - ignoring
-            this.#Log(`InstrumentationSubscriber.Subscribe(): Subscription already exists: [${subscriptionKey.id}] - ignoring.`.magenta);
-        } else {
-            this.#subscriptions[subscriptionKey.id] = {
-                subscriptionKey,
-                cb
-            }
-            if (subscriptionKey.topic.localeCompare(SubscriptionTopic.LogProcessing) === 0) {
-                this.#SubscribeKafka(this.#subscriptions[subscriptionKey.id]);
-            }
-            this.#Log(`InstrumentationSubscriber.Subscribe(): subscriptionKey.id: [${subscriptionKey.id}] successfully subscribed.`.grey);
-
-            if (!this.#interval) {
-                // Output subscription immediately and then iterate ...
-                this.#ExecuteSubscriptions();
-                let interval = 1000; // default
-                if (this.options) {
-                    interval = this.options.SubscriptionInterval
-                }
-                this.#interval = setInterval(() => {
-                    this.#ExecuteSubscriptions();
-                }, interval);
-            }
-        }
-    }
-
-    UnSubscribe(subscriptionKey: ISubscriptionKey) {
-        if (!this.#subscriptions[subscriptionKey.id]) {
-            this.#Log(`UnSubscribe(): Warning, subscriptionKey.id: [${subscriptionKey.id}] does not exist within subscription records`.magenta);
-        } else {
-            if (subscriptionKey.topic.localeCompare(SubscriptionTopic.LogProcessing) === 0) {
-                this.#UnSubscribeKafka(this.#subscriptions[subscriptionKey.id]);
-            }
-            delete this.#subscriptions[subscriptionKey.id];
-
-            if (Object.keys(this.#subscriptions).length === 0) {
-                if (this.#interval) {
-                    clearInterval(this.#interval);
-                    this.#interval = null;
-                }
-            }
-        }
-    }
-
-    #UnSubscribeAll() {
-        for (const [, subscription] of Object.entries(this.#subscriptions)) {
-            this.UnSubscribe(subscription.subscriptionKey);
-        }
-    }
-
-    async Start() {
-        return this.#influxDBManager.Start();
-    }
-
-    async Stop() {
-        this.#UnSubscribeAll();
-        return this.#influxDBManager.Terminate();
-    }
-}