@nsshunt/stsappframework 3.1.160 → 3.1.162

package/src/testertesting/app.ts

@@ -0,0 +1,243 @@
+/* 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, IPrimaryWorker, IRunnerOptions } from './commonTypes'
+
+import { WorkerPrimaryTestRunner01 } from './workerPrimaryTestRunner01'
+import { STSWorkerManager } from './workerManager';
+
+import chalk from 'chalk';
+// Force chalk level
+chalk.level = 3;
+
+import { IContextBase, AgentInstrumentController, IPublishInstrumentControllerOptions, Gauge, GaugeTypes, 
+    InstrumentDefinitions, InstrumentLogOptions, InstrumentGaugeOptions, PublishTransportRESTServer, 
+    TransportType, IPublishTransportRESTServerOptions } from '@nsshunt/stsobservability'
+
+import { ModelDelimeter, type ISTSLogger, defaultLogger } from '@nsshunt/stsutils'
+
+import { v4 as uuidv4 } from 'uuid';
+
+import { goptions } from '@nsshunt/stsconfig'
+
+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'
+
+    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 standardInstruments: InstrumentDefinitions = [
+        [ Gauge.TIMER_GAUGE, GaugeTypes.INSTRUMENT_TIMER ],
+        [ Gauge.LOGGER, GaugeTypes.INSTRUMENT_LOG, {
+            consoleLogging: process.env.consoleLogging,
+            instrumentLogging: process.env.instrumentLogging } as InstrumentLogOptions],
+        [ Gauge.NETWORK_RX_GAUGE , GaugeTypes.INSTRUMENT_VELOCITY ],
+        [ Gauge.NETWORK_TX_GAUGE, GaugeTypes.INSTRUMENT_VELOCITY ]
+    ];
+    
+    const agentInstruments: InstrumentDefinitions = [
+        [ Gauge.REQUEST_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of requests serviced
+        [ Gauge.ERROR_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ],
+        [ Gauge.RETRY_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ],
+        [ Gauge.AUTHENTICATION_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of new token requests
+        [ Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of new token requests errors
+        [ Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of new token requests retries
+        [ Gauge.ACTIVE_REQUEST_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, { // Total number of runners (in-flight) requests
+            interval: process.env.instrumentationObservationInterval, 
+            sampleSize: process.env.instrumentationTimeWindow } as InstrumentGaugeOptions],
+        [ Gauge.DURATION_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, { // Duration of latest http(s) request.
+            interval: process.env.instrumentationObservationInterval,
+            sampleSize: process.env.instrumentationTimeWindow } as InstrumentGaugeOptions],
+        [ Gauge.DURATION_HISTOGRAM_GAUGE, GaugeTypes.INSTRUMENT_HISTOGRAM ],
+        [ Gauge.VELOCITY_GAUGE, GaugeTypes.INSTRUMENT_VELOCITY ], // Requests per second
+        [ Gauge.CORE_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Thread count (for http agents)
+        [ Gauge.LATENCY_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
+            interval: process.env.instrumentationObservationInterval,
+            sampleSize: process.env.instrumentationTimeWindow } as InstrumentGaugeOptions],
+        [ Gauge.LATENCY_HISTOGRAM_GAUGE, GaugeTypes.INSTRUMENT_HISTOGRAM ],
+        [ Gauge.CHILD_COUNT, GaugeTypes.INSTRUMENT_GAUGE ] // Number of async runners idle or running
+    ]
+    
+    const instrumentControllerOptions: IPublishInstrumentControllerOptions = {
+        processContext: asyncRunnerContext,
+        instrumentationObservationInterval: 1000, //@@
+        instrumentationTimeWindow: 600, //@@
+        publisherTransport: new PublishTransportRESTServer(publishTransportOptions),
+        logger: defaultLogger,
+        publishInterval: 1000, //@@
+        //instrumentDefinitions: GetInstruments('agent')
+        instrumentDefinitions: [
+            ...standardInstruments,
+            ...agentInstruments
+        ]
+    }
+
+    const agentInstrumentController = new AgentInstrumentController(instrumentControllerOptions);
+    agentInstrumentController.StartPublish();
+
+    const workerFactory: IWorkerFactory = {
+     
+        createPrimaryThreadWorker: (app: any, options: IWorkerOptions): IPrimaryWorker => {
+            return new WorkerPrimaryTestRunner01(app, options);
+        },
+        createWorkerThreadWorker: (): Worker => {
+
+            LogInfoMessage(`createWorkerThreadWorker`);
+
+            const fileName ='./dist/testertesting/workerWorkerTestRunner01.js';
+
+            const publishCollectorWebWorker = new Worker(fileName);
+            publishCollectorWebWorker.unref();
+
+            return publishCollectorWebWorker;
+        },
+        get workerThreadWorkerOptions(): IWorkerOptions {
+            return {
+                agentId,
+                hostName,
+                userAgent,
+                workdata: 'worker - hello world'
+            } as IWorkerOptions;
+        },
+        get primaryThreadWorkerOptions(): IWorkerOptions {
+            return {
+                agentId,
+                hostName,
+                userAgent,
+                primaryoptions: 'primary - hello world'
+            } as IWorkerOptions;
+        }
+    }
+
+    const PerformTesting = async () => {
+        const wm = new STSWorkerManager(null, { 
+            workerFactory,
+            publishInstrumentController: agentInstrumentController
+        });
+        const worker = await wm.AddWorker();
+
+        const runnerOptions: IRunnerOptions = {
+            iterations: 100000,
+            sleepDuration: 250,
+            messageMod: 1,
+            logMessageMod: 1
+        } as IRunnerOptions;
+
+        const runner1 = worker.AddRunner(runnerOptions);
+        runner1.Start();
+
+        const runner2 = wm.AddRunnerToWorker(worker, runnerOptions);
+        runner2.Start();
+
+        wm.AddRunnerToWorker(worker, runnerOptions).Start();
+    };
+    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

@@ -0,0 +1,197 @@
+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',
+	AddAsyncRunner = '__STS__AddAsyncRunner',
+	StopAllAsyncRunners = '__STS__StopAllAsyncRunners',
+	StartRunner = '__STS__StartRunner',
+}
+
+/**
+ * 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 {
+	id: number
+	asyncRunnerContext: IAsyncRunnerContext
+	options: IRunnerOptions
+	state: IRunnerState
+	instrumentData: IRunnerTelemetry
+}
+
+export interface IRunnerEx extends IRunner {
+    publishInstrumentController: PublishInstrumentController
+    Start: () => Promise<boolean>
+    Pause: () => Promise<boolean>
+    Resume: () => Promise<boolean>
+	Stop: () => Promise<boolean>
+	ApplyConfig: (config: IRunnerOptions) => Promise<boolean>
+	GetConfig(): IRunnerOptions
+}
+
+export enum IWorkerState {
+	starting = 'starting',
+	started = 'started',
+	stopped = 'stopped'
+}
+
+ 
+export interface IWorkerOptions {
+    hostName: string
+    agentId: string
+    userAgent: string
+}
+
+export type Runners = Record<string, IRunner>
+
+export interface IWorker {
+	id: number
+	state: IWorkerState
+    primaryThreadWorkerOptions: IWorkerOptions
+	workerThreadWorkerOptions: IWorkerOptions
+	runners?: Runners // Will be created by utility helper
+}
+
+export type Workers = Record<string, IWorker>
+
+export interface IPrimaryWorker {
+    ProcessMessageFromWorker(workerPort: MessagePort, publishMessagePayload: IIWMessagePayload): Promise<void>
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface IRunnerOptions {
+
+}
+
+export interface IWorkerEx extends IWorker {
+	worker: Worker
+    primaryWorker: IPrimaryWorker
+	runnersEx: Record<string, IRunnerEx>
+	GetRunner(id: string): IRunnerEx | null
+	AddRunner: (runnerOptions: IRunnerOptions) => IRunnerEx
+	StartRunner: (runner: IRunnerEx) => Promise<boolean>
+	StopRunner: (runner: IRunnerEx) => Promise<boolean>
+	Stop: () => Promise<boolean>
+}
+
+export interface ISTSTestWorkerOptions {
+    messageMod: number
+    iterations: number
+}
+
+export interface ITelemetryStore {
+	workers: Workers
+}
+
+export interface ITestRunnerTelemetryPayload extends IIWMessagePayloadContentBase {
+	runner: IRunner
+}
+
+export interface IWorkerFactory {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    createPrimaryThreadWorker: (app: any, options: IWorkerOptions) => IPrimaryWorker
+	createWorkerThreadWorker: () => Worker // | wt.Worker
+    get workerThreadWorkerOptions(): IWorkerOptions // These options will be passed as a message to the thread worker once setup
+    get primaryThreadWorkerOptions(): 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/requestResponseHelper.ts

@@ -0,0 +1,95 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import { MessagePort } from 'worker_threads';
+
+import type { IIWMessagePayload } from './commonTypes'
+
+import { defaultLogger } from '@nsshunt/stsutils'
+
+declare interface RequestResponseMessage {
+	publishMessagePayload: IIWMessagePayload
+	publishMessagePayloadResponse?: IIWMessagePayload
+	cb: () => void,
+	timeout: NodeJS.Timeout
+}
+
+declare type RequestResponseMessages = Record<string, RequestResponseMessage>;
+
+//@@ this should become a low level stsutils type helper
+export class RequestResponseHelper
+{
+    #requestResponseMessages: RequestResponseMessages = { }
+    #requestResponseMessageTimeout = 10000; //@@ config
+    #port: MessagePort
+
+    constructor(port: MessagePort) {
+        this.#port = port
+        this.#SetupListener();
+    }
+
+     
+    #debug = (message: any) => {
+        defaultLogger.debug(message);
+    }
+
+    PostMessage = (message: IIWMessagePayload): Promise<IIWMessagePayload> => {
+        return new Promise((resolve, reject) => {
+            const { messageId } = message.payload;
+            if (messageId) {
+                if (this.#requestResponseMessages[messageId]) {
+                    reject(`RequestResponseHelper: Message with id: [${messageId}] already exists within the Request/Response record structure`);
+                } else {
+                    this.#requestResponseMessages[messageId] = {
+                        publishMessagePayload: { ...message },
+                        cb: () => {
+                            const detail = this.#requestResponseMessages[messageId].publishMessagePayloadResponse;
+                            clearTimeout(this.#requestResponseMessages[messageId].timeout);
+                            setTimeout(() => {
+                                delete this.#requestResponseMessages[messageId];
+                            }, 0);
+                            if (detail) {
+                                this.#debug(`RequestResponseHelper: Resolving response message with id: [${messageId}] from target worker port. Details: [${JSON.stringify(detail)}]`);
+                                resolve(detail);
+                            } else {
+                                const msg = `Could not get detail from this.#requestResponseMessages[messageId].publishMessagePayloadResponse`;
+                                this.#debug(msg);
+                                reject(msg);
+                            }
+                        },
+                        timeout: setTimeout(() => {
+                            setTimeout(() => {
+                                delete this.#requestResponseMessages[messageId];
+                            }, 0);
+                            this.#debug(`RequestResponseHelper: Timeout has occurred after: [${this.#requestResponseMessageTimeout}]ms with message id: [${messageId}]. Details: [${JSON.stringify(this.#requestResponseMessages[messageId].publishMessagePayload)}]`);
+                            reject('RequestResponseHelper: Did not receive response form parent process.');
+                        }, this.#requestResponseMessageTimeout) // max message timeout allowed
+                    };
+                    //debug(`RequestResponseHelper: Sending message with id: [${messageId}] to target worker port. Details: [${JSON.stringify(this.#requestResponseMessages[messageId].publishMessagePayload)}]`);
+                    this.#port.postMessage(message);
+                }
+            } else {
+                const msg = `RequestResponseHelper: Response did not include a message id`;
+                this.#debug(msg);
+                reject(msg);
+            }
+        });
+    }
+
+    #SetupListener = () => {
+        //this.#port.onmessage = async (msg: MessageEvent) => {
+        this.#port.on('message', (msg: any) => {
+            const publishMessagePayload: IIWMessagePayload = msg.data as IIWMessagePayload;
+            if (publishMessagePayload.payload.messageId) {
+                const messageId = publishMessagePayload.payload.messageId;
+                if (messageId && messageId !== '') {
+                    if (this.#requestResponseMessages[messageId]) {
+                        const requestResponseMessage: RequestResponseMessage = this.#requestResponseMessages[messageId];
+                        requestResponseMessage.publishMessagePayloadResponse = { ...publishMessagePayload };
+                        requestResponseMessage.cb();
+                    } else {
+                        throw new Error(`RequestResponseHelper: Could not find Request/Response message with id: [${messageId}]`);
+                    }
+                }
+            }
+        });
+    }
+}

package/src/testertesting/telemetryProcessor.ts

@@ -0,0 +1,128 @@
+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.authenticationCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.authenticationRetryCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, {
+                val: telemetry.authenticationCount
+            } 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;
+        }
+
+        if (telemetry.activeRequestCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.ACTIVE_REQUEST_GAUGE, {
+                val: telemetry.activeRequestCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        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;
+    }
+}