@nsshunt/stsappframework 3.1.214 → 3.1.215

package/src/testertesting/app.ts

@@ -1,349 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import cluster from 'cluster';
-import { Worker } from 'worker_threads';
-
-import { IWorkerFactory, IWorkerOptions } from './commonTypes'
-
-import { STSWorkerManager } from './workerManager';
-
-import chalk from 'chalk';
-// Force chalk level
-chalk.level = 3;
-
-import { IContextBase, IPublishInstrumentControllerOptions, Gauge, TransportType, IPublishTransportRESTServerOptions, 
-    PublishInstrumentController, GetInstruments, InstrumentGaugeTelemetry } from '@nsshunt/stsobservability'
-
-import { ModelDelimeter, defaultLogger } from '@nsshunt/stsutils'
-
-import { v4 as uuidv4 } from 'uuid';
-
-import { goptions } from '@nsshunt/stsconfig'
-
-import { IRunnerOptionsEx } from './testCase01'
-
-import { CreateServiceProcessContext } from './../commonTypes'
-
-declare  interface IAsyncRunnerContext extends IContextBase {
-    id: string;
-    hostName: string;
-    agentName: string;
-    threadId: string;
-    asyncRunnerId: number;
-}
-
-const LogInfoMessage = (message: any) => console.log(chalk.grey(message))
-const LogErrorMessage = (message: any) => console.error(chalk.red(message))
-
-if (cluster.isPrimary) {
-
-    //new MasterProcessBase(ServiceConfigOptions(true, cluster.isPrimary)).SetupServer();
-
-    LogInfoMessage(`Primary ${process.pid} is running`);
-  
-    // Fork workers.
-    cluster.fork();
-  
-    cluster.on('exit', (worker, code, signal) => {
-        LogInfoMessage(`worker ${worker.process.pid} died`);
-    });
-
-    /*
-    const fileName ='./dist/webworkertesting/worker.js';
-    
-    const publishCollectorWebWorker = new Worker(fileName);
-    publishCollectorWebWorker.unref();
-
-    publishCollectorWebWorker.postMessage({cmd: 'text', message: 'Hello World'});
-
-    publishCollectorWebWorker.on('message', (data) => {
-        LogInfoMessage(`cluster.primary (${process.pid}): message from worker = [${JSON.stringify(data)}]`);
-    });
-
-    const { port1, port2 } = new MessageChannel();
-
-    publishCollectorWebWorker.postMessage({cmd: 'portmessage', port: port2}, [ port2 ]);
-    port1.postMessage('sending to port1');
-    port1.on('message', (data) => {
-        LogInfoMessage(`cluster.primary (${process.pid}): message from message port = [${data}]`);
-    });
-    */
-
-    LogInfoMessage(`cluster primary completed ...`);
-
-
-} else {
-
-
-    LogInfoMessage(`Worker ${process.pid} started`);
-
-    //const worker = new WorkerProcessBase(ServiceConfigOptions(true, cluster.isPrimary));
-    //worker.SetupServer();
-
-    const hostName = 'host01';
-    const agentId = 'agent01';
-    const userAgent = 'userAgent01'
-
-    // Root level / master async runner context
-    const asyncRunnerContext: IAsyncRunnerContext = {
-        nid: `\
-    ${hostName}${ModelDelimeter.COMPONENT_SEPERATOR}${agentId}-${userAgent}\
-    ${ModelDelimeter.NID_SEPERATOR}\
-    MainProcess\
-    ${ModelDelimeter.SEPERATOR}\
-    0`,
-        id: uuidv4(),
-        // id: `${applicationStore.applicationConfig.HOST}${ModelDelimeter.COMPONENT_SEPERATOR}${applicationStore.applicationConfig.AGENT_ID}-${applicationStore.applicationConfig.USER_AGENT}`,
-        hostName: (hostName ? hostName : 'host01'),
-        agentName: `${agentId}-${userAgent}`,
-        threadId: 'MainProcess',
-        asyncRunnerId: 0
-    }
-
-    const url = `https://stscore.stsmda.org:3001/stsinstrumentmanager/v1/publishmessage`;
-
-    const publishTransportOptions: IPublishTransportRESTServerOptions = {
-        transportType: TransportType.RESTAPI,
-        //url: `${goptions.imendpoint}:${goptions.import}${goptions.imapiroot}/publishmessage`,
-        url,
-        logger: defaultLogger,
-        agentOptions: {
-            keepAlive: goptions.keepAlive,
-            maxSockets: goptions.maxSockets,
-            maxTotalSockets: goptions.maxTotalSockets,
-            maxFreeSockets: goptions.maxFreeSockets,
-            timeout: 30000, //@@ config
-            rejectUnauthorized: goptions.isProduction // Allows self signed certs in non production mode(s)
-        },
-        showPublishPayload: false
-    };
-
-    LogInfoMessage(`publishTransportOptions: [${publishTransportOptions.url}]`);
-
-    //const fileName1 = './dist/publishInstrumentsWebWorker.js';
-    //const worker1 = new Worker(fileName1);
-
-    const instrumentControllerOptions: IPublishInstrumentControllerOptions = {
-        processContext: asyncRunnerContext,
-        instrumentationObservationInterval: 1000, //@@
-        instrumentationTimeWindow: 600, //@@
-        logger: defaultLogger,
-        publishInterval: 1000, //@@
-        publishPostFailInterval: 5000, //@@
-        instrumentDefinitions: GetInstruments('agent'),
-        publishTransportBaseOptions: publishTransportOptions,
-        autoStart: false
-    }
-
-    const agentInstrumentController = new PublishInstrumentController(instrumentControllerOptions);
-    agentInstrumentController.StartPublish();
-
-    const serviceContext = CreateServiceProcessContext('testingservice', 'v1', uuidv4(),
-        'oshostname', 1, 1)
-
-    //const fileName2 = './dist/publishInstrumentsWebWorker.js';
-    //const worker2 = new Worker(fileName2);
-
-    const serviceInstrumentControllerOptions: IPublishInstrumentControllerOptions = {
-        processContext: serviceContext,
-        //payloadType: InstrumentPayloadType.service,
-        consoleLogging: false,
-        instrumentLogging: true,
-        httpServer: false,
-        instrumentationObservationInterval: 1000,
-        instrumentationTimeWindow: 600,
-        logger: defaultLogger,
-        publishInterval: 1000,
-        publishPostFailInterval: 5000,
-        instrumentDefinitions: GetInstruments('service'),
-        publishTransportBaseOptions: publishTransportOptions,
-        autoStart: false
-    }
-
-    const serviceInstrumentController = new PublishInstrumentController(serviceInstrumentControllerOptions);
-    serviceInstrumentController.StartPublish();
-
-    const serviceContext2 = CreateServiceProcessContext('testingservice', 'v1', uuidv4(),
-        'oshostname', 2, 1);
-    const newPublishInstrumentController2 = serviceInstrumentController.AddPublishInstrumentController(serviceContext2)
-    newPublishInstrumentController2.StartPublish();
-
-    const serviceContext3 = CreateServiceProcessContext('testingservice', 'v1', uuidv4(),
-        'oshostname', 3, 1);
-    const newPublishInstrumentController3 = serviceInstrumentController.AddPublishInstrumentController(serviceContext3)
-    newPublishInstrumentController3.StartPublish();
-
-    // Service types MUST have a CPU in order for the UITerm tool to see the telemetry
-    setInterval(() => {
-        newPublishInstrumentController2.UpdateInstrument(Gauge.CPU_LOAD_GAUGE, {
-            val: 20
-        } as InstrumentGaugeTelemetry);
-
-        newPublishInstrumentController3.UpdateInstrument(Gauge.CPU_LOAD_GAUGE, {
-            val: 30
-        } as InstrumentGaugeTelemetry);
-    }, 1000);
-
-
-    const workerFactory: IWorkerFactory = {
-        createWorkerThreadWorker: (): Worker => {
-            LogInfoMessage(`createWorkerThreadWorker`);
-            const fileName ='./dist/testertesting/workerWorkerTestRunner01.js';
-            const publishCollectorWebWorker = new Worker(fileName);
-            publishCollectorWebWorker.unref();
-            return publishCollectorWebWorker;
-        },
-        get workerThreadWorkerOptions(): IWorkerOptions {
-            return {
-                id: uuidv4(),
-                agentId,
-                hostName,
-                userAgent,
-                workdata: 'worker - hello world'
-            } as IWorkerOptions;
-        }
-    }
-
-    const PerformTesting = async () => {
-        const wm = new STSWorkerManager({ 
-            workerFactory,
-            publishInstrumentController: agentInstrumentController
-        });
-        const worker = await wm.AddWorker();
-
-        const runnerOptions: IRunnerOptionsEx = {
-            testType: 'TestCase01',
-            executionProfile: {
-                iterations: 50,
-                delayBetweenIterations: 250
-            },
-            sleepDuration: 0,
-            logMessageMod: 1
-        };
-
-        const runner1 = worker.AddRunner(runnerOptions);
-        runner1.on('Completed', () => {
-            console.log(chalk.rgb(10, 100, 250)(`Completed event handler for runner 1`));
-        });
-        worker.StartRunner(runner1);
-
-
-        const runner2 = wm.AddRunnerToWorker(worker, runnerOptions);
-        runner2.Start();
-        runner2.on('Completed', () => {
-            console.log(chalk.rgb(100, 10, 250)(`Completed event handler for runner 2`));
-        });
-
-        wm.AddRunnerToWorker(worker, runnerOptions).on('Completed', () => {
-            console.log(chalk.rgb(250, 100, 25)(`Completed event handler for runner 3`));
-        }).Start();
-
-        const runner4 = wm.AddRunnerToWorker(worker, runnerOptions);
-        runner4.Start();
-        runner4.on('Completed', () => {
-            console.log(chalk.rgb(50, 230, 20)(`Completed event handler for runner 4`));
-        });
-
-        setTimeout(async () => {
-            await runner4.Pause();
-            const newOptions = { ...runnerOptions };
-            newOptions.sleepDuration = 500;
-            await runner4.UpdateOptions(newOptions);
-            await runner4.Resume();
-            setTimeout(async () => {
-                newOptions.sleepDuration = 0;
-                await runner4.UpdateOptions(newOptions);
-            }, 3000);
-        }, 2000);
-
-        setTimeout(() => {
-            runner2.Pause();
-            setTimeout(() => {
-                runner2.Resume();
-                setTimeout(() => {
-                    runner2.Reset();
-                    setTimeout(() => {
-                        runner2.Start();
-                        setTimeout(() => {
-                            runner2.Stop();
-                            setTimeout(() => {
-                                runner2.Terminate();
-                            }, 2000);
-                        }, 2000);
-                    }, 100);
-                }, 2000);
-            }, 2000);
-        }, 2000);
-
-        for (let j=0; j < 2; j++) {
-            const worker = await wm.AddWorker();
-
-            const runnerOptions: IRunnerOptionsEx = {
-                testType: 'TestCase01',
-                executionProfile: {
-                    iterations: 50,
-                    delayBetweenIterations: 250
-                },
-                sleepDuration: 0,
-                logMessageMod: 1
-            };
-
-            for (let i=0; i < 5; i++) {
-                const runner = worker.AddRunner(runnerOptions);
-                runner.on('Completed', () => {
-                    console.log(chalk.rgb(10, 100, 250)(`Completed event handler for worker ${j} runner ${i}`));
-                });
-                worker.StartRunner(runner);
-            }
-
-            setTimeout(() => {
-                worker.Pause();
-                setTimeout(() => {
-                    worker.Resume();
-                    setTimeout(() => {
-                        worker.Stop();
-                        setTimeout(async () => {
-                            await worker.Reset();
-                            const newOptions = { ...runnerOptions };
-                            newOptions.sleepDuration = 50; // Simulated time for a work event to occur (actual work like a REST call)
-                            newOptions.logMessageMod = 25; // Send a log message every 25 iterations
-                            newOptions.executionProfile.delayBetweenIterations = 0;
-                            newOptions.executionProfile.iterations = 10000;
-                            await worker.UpdateOptions(newOptions);
-                            await worker.Start();
-                            setTimeout(async () => {
-                                await worker.Pause();
-                                await worker.Execute();
-                                await worker.Execute();
-                                await worker.Execute();
-                                await worker.Execute();
-                                await worker.Execute();
-                                setTimeout(async () => {
-                                    await worker.Resume();
-                                }, 5000);
-                            }, 5000);
-                        }, 5000);
-                    }, 5000);
-                }, 5000);
-            }, 5000);
-        }
-
-    };
-    PerformTesting();
-    
-
-    /*
-    const fileName ='./dist/webworkertesting/worker.js';
-
-    const clusterWorker = new Worker(fileName);
-    clusterWorker.unref();
-
-    clusterWorker.postMessage({cmd: 'text', message: 'Hello World'});
-
-    clusterWorker.on('message', (data: any) => {
-        LogInfoMessage(`cluster.worker (${process.pid}): message from worker = [${JSON.stringify(data)}]`);
-    });
-    */
-
-    LogInfoMessage(`cluster work completed ...`);
-
-}

package/src/testertesting/commonTypes.ts

@@ -1,236 +0,0 @@
-import { Worker, MessagePort } from 'worker_threads';
-
-import { PublishInstrumentController } from '@nsshunt/stsobservability'
-
-import { IContextBase } from '@nsshunt/stsobservability'
-
-export const URI_BASE_VUEUTILS: string = '/';
-
-export interface IAsyncRunnerContext extends IContextBase {
-	id: string
-	hostName: string
-	agentName: string
-	threadId: string
-	asyncRunnerId: number
-}
-
-/**
- * Inter-Worker (IW) Payload context base.
- */
-export interface IIWMessagePayloadContentBase {
-    messageId?: string
-}
-
-/**
- * Inter-Worker (IW) message commands.
- */
-export enum eIWMessageCommands {
-	InstrumentTelemetry ='__STS__InstrumentTelemetry', // Used to send instrument telemetry
-	MessagePort = '__STS__MessagePort',
-	MessagePortResponse = '__STS__MessagePortResponse',
-	AddRunner = '__STS__AddRunner',
-	StopAllRunners = '__STS__StopAllRunners',
-	StartRunner = '__STS__StartRunner',
-	StopRunner = '__STS__StopRunner',
-	PauseRunner = '__STS__PauseRunner',
-	ResumeRunner = '__STS__ResumeRunner',
-	ResetRunner = '__STS__ResetRunner',
-	ExecuteRunner = '__STS__ExecuteRunner',
-	Completed = '__STS__Completed',
-	UpdateOptions = '__STS__UpdateOptions',
-	TerminateRunner = '__STS__TerminateRunner'
-}
-
-/**
- * Inter-Worker (IW) message command.
- */
-export type IIWMessageCommand = eIWMessageCommands
-
-/**
- * Inter-Worker (IW) message payload.
- */
-export interface IIWMessagePayload {
-    command: IIWMessageCommand
-    payload: IIWMessagePayloadContentBase
-}
-
-export interface IObservabilitySubscriberManagerOptions {
-    modelId: string
-    consumeInstrumentationMode: string
-    instrumentManagerEndpoint: string
-    instrumentManagerPort: string
-    instrumentManagerAPIRoot: string
-}
-
-export interface ISTSAgentWorkerMessagePort extends IIWMessagePayloadContentBase {
-    port: MessagePort
-    options: IWorkerOptions
-}
-
-export enum IRunnerState {
-	created = 'created',
-	running = 'running',
-	stopped = 'stopped',
-	paused = 'paused',
-	error = 'error',
-}
-
-export interface IRunnerTelemetry {
-	requestCount: number // requestCount
-	errorCount: number
-	retryCount: number
-	authenticationCount: number
-	authenticationErrorCount: number
-	authenticationRetryCount: number
-	velocity: number
-	coreCount: number
-	timer: number
-	duration: number
-	latency: number
-	activeRequestCount: number
-	message: string[]
-	childCount: number
-	rx: number
-	tx: number
-}
-
-export interface IRunner {
-	get id(): number
-	get asyncRunnerContext(): IAsyncRunnerContext
-	get options(): IRunnerOptions
-	set options(options: IRunnerOptions)
-	get instrumentData(): IRunnerTelemetry
-	set instrumentData(newRunnerTelemetry: IRunnerTelemetry)
-}
-
-export interface IRunnerEx extends IRunner {
-    publishInstrumentController: PublishInstrumentController
-    Start: () => Promise<boolean> // Start runner iterations
-	Stop: () => Promise<boolean> // Stop iteration processing and keep the current iteration number. Currently, this is the same as Pause.
-    Pause: () => Promise<boolean> // Pause iteration processing and keep the current iteration number.
-    Resume: () => Promise<boolean> // Resume iteration processing from the previously paused iteration number.
-	Terminate: () => Promise<boolean> // Stop the runner iterations and terminate the instance, stop any instrument publishers.
-	Reset: () => Promise<boolean> // Stop the current iterations and reset the iteration count back to 0.
-	Execute: (iteration: number) => Promise<boolean> // Execute a single iteration for this test.
-	UpdateOptions: (options: IRunnerOptions) => Promise<boolean>
-	on: (eventName: string, cb: () => void) => IRunnerEx // Register event handler.
-}
-
-export interface IRunnerInstance {
-	StartRunner: () => Promise<boolean>
-	StopRunner: () => Promise<boolean>
-	PauseRunner: () => Promise<boolean>
-	ResumeRunner: () => Promise<boolean>
-	TerminateRunner: () => Promise<boolean>
-	ResetRunner: () => Promise<boolean>
-	Execute: (iteration: number) => Promise<boolean> // Execute a single iteration for this test
-	UpdateOptions: () => Promise<boolean>
-	Completed: () => Promise<boolean>
-}
-
-export enum IWorkerState {
-	starting = 'starting',
-	started = 'started',
-	stopped = 'stopped'
-}
- 
-export interface IWorkerOptions {
-	id: string
-    hostName: string
-    agentId: string
-    userAgent: string
-}
-
-export type Runners = Record<string, IRunner>
-
-export interface IWorker {
-	id: number
-	state: IWorkerState
-	workerThreadWorkerOptions: IWorkerOptions
-	runners?: Runners // Will be created by utility helper
-}
-
-export type Workers = Record<string, IWorker>
-
-export interface IExecutionProfile {
-    iterations: number
-	delayBetweenIterations: number
-}
-
-export interface IRunnerOptions {
-	testType: string
-	executionProfile: IExecutionProfile
-}
-
-export interface IRunnerEvent {
-	eventName: string
-	cb: () => void
-}
-
-export interface IWorkerEx extends IWorker {
-	worker: Worker
-	runnersEx: Record<string, IRunnerEx>
-	runnersEvents: Record<string, IRunnerEvent[]>
-	GetRunner(id: string): IRunnerEx | null
-	AddRunner: (runnerOptions: IRunnerOptions) => IRunnerEx
-
-	StartRunner: (runner: IRunnerEx) => Promise<boolean>
-	StopRunner: (runner: IRunnerEx) => Promise<boolean>
-	PauseRunner: (runner: IRunnerEx) => Promise<boolean>
-	ResumeRunner: (runner: IRunnerEx) => Promise<boolean>
-	TerminateRunner: (runner: IRunnerEx) => Promise<boolean>
-	ResetRunner: (runner: IRunnerEx) => Promise<boolean>
-	ExecuteRunner: (runner: IRunnerEx) => Promise<boolean>
-	UpdateOptionsRunner: (runner: IRunnerEx, options: IRunnerOptions) => Promise<boolean>
-
-	Start: () => Promise<boolean>
-	Stop: () => Promise<boolean>
-	Pause: () => Promise<boolean>
-	Resume: () => Promise<boolean>
-	Terminate: () => Promise<boolean>
-	Reset: () => Promise<boolean>
-	Execute: () => Promise<boolean> // Execute a single iteration
-	UpdateOptions: (options: IRunnerOptions) => Promise<boolean>
-}
-
-export interface ISTSTestWorkerOptions {
-    iterations: number
-}
-
-export interface ITelemetryStore {
-	workers: Workers
-}
-
-export interface ITestRunnerTelemetryPayload extends IIWMessagePayloadContentBase {
-	runner: IRunner
-}
-
-export interface IWorkerFactory {
-	createWorkerThreadWorker: () => Worker // | wt.Worker
-    get workerThreadWorkerOptions(): IWorkerOptions // These options will be passed as a message to the thread worker once setup
-}
-
-export interface IWorkerManagerOptions {
-    workerFactory: IWorkerFactory
-	publishInstrumentController: PublishInstrumentController
-}
-
-export const PublishMessageCommandsTestRunner = {
-    ...eIWMessageCommands,
-    GetAccessToken: '__GetAccessToken',
-    GetAccessTokenResponse: '__GetAccessTokenResponse',
-    GetDataFromPrimary: '__GetDataFromPrimary',
-    ExecuteRefreshToken: '__ExecuteRefreshToken',
-    ExecuteRefreshTokenResponse: '__ExecuteRefreshTokenResponse'
-} as const
-
-export type PublishMessageCommandsTestRunner = typeof PublishMessageCommandsTestRunner[keyof typeof PublishMessageCommandsTestRunner];
-
-export interface IIWMessagePayloadContentBase {
-    messageId?: string;
-}
-
-export interface IIWMessagePayload {
-    command: IIWMessageCommand;
-    payload: IIWMessagePayloadContentBase;
-}

package/src/testertesting/telemetryProcessor.ts

@@ -1,125 +0,0 @@
-import { PublishInstrumentController, InstrumentGaugeTelemetry, Gauge } from "@nsshunt/stsobservability";
-import { IRunnerTelemetry } from "./commonTypes";
-
-export class TelemetryProcessor {
-    ProcessTelemetry = (publishInstrumentController: PublishInstrumentController, telemetry: IRunnerTelemetry): boolean => {
-        let update = false;
-
-        if (telemetry.message) {
-            telemetry.message.forEach((message) => {
-                publishInstrumentController.LogEx(message);
-            });
-            update = true;
-        }
-
-        if (telemetry.requestCount) {
-            publishInstrumentController.UpdateInstrument(Gauge.REQUEST_COUNT_GAUGE, {
-                val: telemetry.requestCount
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.errorCount) {
-            publishInstrumentController.UpdateInstrument(Gauge.ERROR_COUNT_GAUGE, {
-                val: telemetry.errorCount
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.retryCount) {
-            publishInstrumentController.UpdateInstrument(Gauge.RETRY_COUNT_GAUGE, {
-                val: telemetry.retryCount
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.authenticationCount) {
-            publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_COUNT_GAUGE, {
-                val: telemetry.authenticationCount
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.authenticationErrorCount) {
-            publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, {
-                val: telemetry.authenticationErrorCount
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.authenticationRetryCount) {
-            publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, {
-                val: telemetry.authenticationRetryCount
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.coreCount) {
-            publishInstrumentController.UpdateInstrument(Gauge.CORE_COUNT_GAUGE, {
-                val: telemetry.coreCount
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.timer) {
-            publishInstrumentController.UpdateInstrument(Gauge.TIMER_GAUGE, {
-                val: telemetry.timer
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        publishInstrumentController.UpdateInstrument(Gauge.ACTIVE_REQUEST_GAUGE, {
-            val: telemetry.activeRequestCount
-        } as InstrumentGaugeTelemetry);
-
-        if (telemetry.velocity) {
-            publishInstrumentController.UpdateInstrument(Gauge.VELOCITY_GAUGE, {
-                Inc: telemetry.velocity
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.duration) {
-            publishInstrumentController.UpdateInstrument(Gauge.DURATION_GAUGE, {
-                val: telemetry.duration
-            } as InstrumentGaugeTelemetry);
-            publishInstrumentController.UpdateInstrument(Gauge.DURATION_HISTOGRAM_GAUGE, {
-                val: telemetry.duration
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.latency) {
-            publishInstrumentController.UpdateInstrument(Gauge.LATENCY_GAUGE, {
-                val: telemetry.latency
-            } as InstrumentGaugeTelemetry);
-            publishInstrumentController.UpdateInstrument(Gauge.LATENCY_HISTOGRAM_GAUGE, {
-                val: telemetry.latency
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.childCount) {
-            publishInstrumentController.UpdateInstrument(Gauge.CHILD_COUNT, {
-                val: telemetry.childCount
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.rx) {
-            publishInstrumentController.UpdateInstrument(Gauge.NETWORK_RX_GAUGE, {
-                Inc: telemetry.rx
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        if (telemetry.tx) {
-            publishInstrumentController.UpdateInstrument(Gauge.NETWORK_TX_GAUGE, {
-                Inc: telemetry.tx
-            } as InstrumentGaugeTelemetry);
-            update = true;
-        }
-
-        return update;
-    }
-}