@nsshunt/stsappframework 2.19.282 → 2.19.284

package/src/influxdb/influxDBManager.ts

@@ -0,0 +1,359 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import { InfluxDB, Point, WriteApi, QueryApi, flux } from '@influxdata/influxdb-client'
+import { Agent } from 'http'
+
+import { InstrumentPayload } from '@nsshunt/stsmodels'
+
+import { $Options } from '@nsshunt/stsconfig'
+import { JSONObject } from '@nsshunt/stsutils'
+const goptions = $Options()
+
+import { InfluxDBManagerBase } from './influxDBManagerBase'
+import { InfluxDBManagerService} from './influxDBManagerService'
+import { InfluxDBManagerAgent } from './influxDBManagerAgent'
+import { IInfluxDBManagerOptions } from './../commonTypes'
+
+/*
+Manual docker run command and setup -------------------------------------------------------
+
+docker run -d -p 8086:8086 --name influxdb \
+      -v $PWD/data:/var/lib/influxdb2 \
+      -v $PWD/config:/etc/influxdb2 \
+      -e DOCKER_INFLUXDB_INIT_MODE=setup \
+      -e DOCKER_INFLUXDB_INIT_USERNAME=my-user \
+      -e DOCKER_INFLUXDB_INIT_PASSWORD=my-password \
+      -e DOCKER_INFLUXDB_INIT_ORG=my-org \
+      -e DOCKER_INFLUXDB_INIT_BUCKET=my-bucket \
+      -e DOCKER_INFLUXDB_INIT_RETENTION=1w \
+      -e DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=my-super-secret-auth-token \
+      --restart unless-stopped \
+      influxdb:latest
+
+Then access admin portal via;
+https://192.168.14.92:8086
+
+Login using credentials above
+username: my-user 
+password: my-password
+
+Select Buckets from the menu
+Create buckets as required
+Example: TestBucket01
+Note: We will not use the default bucket as specified in the docker initial setup (my-bucket)
+
+Select API Tokens from the menu
+Generate an API token / custom API token for read/write access to the bucket about
+Bucket: TestBucket01 (from above bucket create)
+
+Copy the API token and use in the ENV file for access
+INFLUXDB_API_TOKEN=<< generated from InfluxDB web admin tool >> \
+INFLUXDB_URL=http://192.168.14.92:8086 \
+INFLUXDB_ORG=my-org \
+INFLUXDB_BUCKET=TestBucket01 \
+
+Docker compose file --------------------------------------------------------------
+
+version: '2'
+services:
+  influxdb:
+    image: influxdb:latest
+    ports:
+      - "8086:8086"
+    environment:
+      DOCKER_INFLUXDB_INIT_MODE: setup
+      DOCKER_INFLUXDB_INIT_USERNAME: my-user
+      DOCKER_INFLUXDB_INIT_PASSWORD: my-password
+      DOCKER_INFLUXDB_INIT_ORG: my-org
+      DOCKER_INFLUXDB_INIT_BUCKET: my-bucket
+      DOCKER_INFLUXDB_INIT_RETENTION: 1w
+      DOCKER_INFLUXDB_INIT_ADMIN_TOKEN: my-super-secret-auth-token
+    volumes:
+      - /var/run/influxdb/data:/var/lib/influxdb2
+      - /var/run/influxdb/config:/etc/influxdb2
+    restart: unless-stopped
+
+
+// Exam Queries Below ----------------------------------------------------------------------
+
+from(bucket: "TestBucket01")
+  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
+  |> filter(fn: (r) => r["_measurement"] == "stsServicePointV3")
+  |> group(columns: ["serviceId"], mode: "by")
+  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
+  |> yield(name: "mean")
+
+from(bucket: "TestBucket01")
+  |> range(start: -10m)
+  |> filter(fn: (r) => r["_measurement"] == "requestCount")
+  |> group(columns: ["serviceInstanceId"])
+  |> mean()
+
+from(bucket: "TestBucket01")
+  |> range(start: -10m)
+  |> filter(fn: (r) => r["_measurement"] == "cpu")
+  |> group(columns: ["serviceInstanceId"])
+  |> aggregateWindow(every: 1m, fn: mean, createEmpty: false)
+
+from(bucket: "TestBucket01")
+  |> range(start: -2m)
+  |> filter(fn: (r) => r["_measurement"] == "cpu")
+  |> group(columns: ["serviceInstanceId"])
+  |> aggregateWindow(every: 1m, fn: mean, createEmpty: false)
+
+from(bucket: "TestBucket01")
+  |> range(start: -10s)
+  |> filter(fn: (r) => r["_measurement"] == "all")
+  |> filter(fn: (r) => r["_field"] == "requestCount")
+  |> group(columns: ["serviceInstanceId"])
+  |> max()
+
+from(bucket: "TestBucket01")
+  |> range(start: -10s)
+  |> filter(fn: (r) => r["_measurement"] == "all")
+  |> filter(fn: (r) => r["_field"] == "requestCount" or r["_field"] == "errorCount")
+  |> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")
+  |> group(columns: ["serviceInstanceId"])
+  |> max()
+
+from(bucket: "TestBucket01") 
+|> range(start: -5s) 
+|> filter(fn: (r) => r["_measurement"] == "all") |> filter(fn: (r) => r["_field"] == "cpu") 
+|> last()
+|> group(columns: ["serviceInstanceId", "serviceId", "_field"]) 
+|> sum()
+|> group(columns: ["_field"]) 
+|> sum()
+
+// Histo ---------------------------------------
+
+import "math"
+from(bucket: "TestBucket01") 
+|> range(start: -10m) 
+|> filter(fn: (r) => r["_measurement"] == "all") |> filter(fn: (r) => r["_field"] == "latency") 
+|> group(columns: ["serviceInstanceIsssd", "serviceId", "_field"]) 
+|> aggregateWindow(every: 1s, fn: mean, createEmpty: false)
+|> histogram(bins: [0.0, 5.0, 10.0, 20.0, 50.0, math.mInf(sign: 1) ])
+|> difference()
+
+// Velocity ------------------------------------------------------------------------
+
+dostsvelocityex = (r, ds, d) =>
+from(bucket: "TestBucket01") 
+|> range(start: r) 
+|> filter(fn: (r) => r["_measurement"] == "all") 
+|> filter(fn: (r) => r["_field"] == "requestCount") 
+|> group(columns: ["serviceInstanceIsssd", "serviceId", "_field", "serviceInstanceProcessId"]) 
+|> aggregateWindow(every: ds, fn: last, createEmpty: false)
+|> limit(n: 5)
+|> difference()
+|> last()
+|> group(columns: ["serviceInstanceIsssd", "serviceId", "_field"])
+|> sum()
+|> map(fn: (r) => ({r with _value: float(v: r._value) / d}))
+
+dostsvelocity = () =>
+    dostsvelocityex(r: -30s, ds: 5s, d: 5.0)
+
+dostsvelocity()
+
+// Velocity - for a specific service instance ----------------------------------
+
+dostsvelocitybyserviceinstanceex = (sid, r, ds, d) =>
+from(bucket: "TestBucket01") 
+|> range(start: r) 
+|> filter(fn: (r) => r["_measurement"] == "all") 
+|> filter(fn: (r) => r["_field"] == "requestCount") 
+|> filter(fn: (r) => r["serviceId"] == sid) 
+|> group(columns: ["serviceInstanceId", "serviceId", "_field", "serviceInstanceProcessId"]) 
+|> aggregateWindow(every: ds, fn: last, createEmpty: false)
+|> limit(n: 5)
+|> difference()
+|> last()
+|> sum()
+|> map(fn: (r) => ({r with _value: float(v: r._value) / d}))
+
+dostsvelocitybyserviceinstance = (sid) =>
+    dostsvelocitybyserviceinstanceex(sid: sid, r: -30s, ds: 5s, d: 5.0)
+
+dostsvelocitybyserviceinstance(sid: "STSAuth@1.0.0")
+
+// Percentile --------------------------------------------------------------
+
+from(bucket: "TestBucket01") 
+|> range(start: -10m) 
+|> filter(fn: (r) => r["_measurement"] == "all") |> filter(fn: (r) => r["_field"] == "latency") 
+|> group(columns: ["serviceInstanceIsssd", "serviceId", "_field"]) 
+|> aggregateWindow(every: 10s, fn: mean, createEmpty: false)
+|> quantile(q: 0.99, method: "exact_mean")
+*/
+
+// export INFLUXDB_TOKEN=W6GztqLmWEqqpP9hAOW9nucgVfESk32dC0JYzFCaYD2yJtS8Ox_WK_1hwSkPUaheWjwwcavkE7_J2aRzm3-E7w==
+
+
+const _logPrefix = 'InfluxDBManager:'
+
+export class InfluxDBManager
+{
+    #shuttingDown: boolean = false;
+    #options: IInfluxDBManagerOptions;
+
+    //#token = process.env.INFLUXDB_TOKEN;
+    #token = '';
+    #url = '' // 'http://192.168.14.92:8086'
+    #org = '' // `my-org`
+    #bucket = '' // `TestBucket01`
+    #client: InfluxDB;
+    #writeClient: WriteApi;
+    #queryApi: QueryApi;
+    #writeDataPointFlushTimeout: NodeJS.Timeout | null = null;
+    #agent: Agent | null = null;
+    #influxDBManagerClients: Record<string, InfluxDBManagerBase> = { };
+
+    constructor(options: IInfluxDBManagerOptions)
+    {
+        this.#options = options;
+
+        this.#token = options.token;
+        this.#url = options.url;
+        this.#org = options.org;
+        this.#bucket = options.bucket;
+
+        if (options.agent) {
+            this.#agent = new Agent({
+                keepAlive: options.agent.influxDB_keepAlive,
+                keepAliveMsecs: 20000, //@@
+                maxSockets: options.agent.influxDB_maxSockets,
+                maxTotalSockets: options.agent.influxDB_maxTotalSockets,
+                maxFreeSockets: options.agent.influxDB_maxFreeSockets,
+                timeout: options.agent.influxDB_timeout,
+                //.rejectUnauthorized: 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.#queryApi = this.#client.getQueryApi(this.#org)
+        this.#writeClient = this.#client.getWriteApi(this.#org, this.#bucket, 'ns')
+
+        this.CreateInfluxDBManagerClient('service');
+        this.CreateInfluxDBManagerClient('agent');
+
+        const StartWriteClient = () => {
+            this.#writeDataPointFlushTimeout = setTimeout(() => {
+                this.#writeClient.flush()
+                StartWriteClient();
+            }, 1000).unref();
+        }
+
+        StartWriteClient();
+    }
+
+    CreateInfluxDBManagerClient(modelType: string) {
+        switch (modelType) {
+        case 'service':
+            this.#influxDBManagerClients[modelType] = new InfluxDBManagerService(this.#options, this.#queryApi, this.#writeClient);
+            break;
+        case 'agent':
+            this.#influxDBManagerClients[modelType] = new InfluxDBManagerAgent(this.#options, this.#queryApi, this.#writeClient);
+            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;
+    }
+
+    Start = async () => {
+        // perform any setup here
+    }
+
+    Terminate = async () => {
+        if (this.#shuttingDown) {
+            console.log(`${_logPrefix}Terminate: Terminate already called. Ignoring.`.yellow);
+        } else {
+            this.#shuttingDown = true;
+            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;
+                }
+
+                console.log(`ProducerDisconnect`.yellow);
+            } catch (error) {
+                console.error(`${_logPrefix}#Terminate: Error: [${error}]`.red);
+            }
+        }
+    }
+
+    /*
+    .floatField('timer', instrumentPayload.instruments[Gauge.TIMER_GAUGE].val)
+    .floatField('duration', instrumentPayload.instruments[Gauge.DURATION_GAUGE].val)
+    .floatField('latency', instrumentPayload.instruments[Gauge.LATENCY_GAUGE].val)
+    */
+
+    CreateGlobalCountModel = (stscount: any[]) => {
+        try {
+            const results: any = { };
+            stscount.forEach((o: any) => {
+                results[o._field] = o._value;
+            });
+            return results;
+        } catch (error) {
+            console.error(`${_logPrefix}#CreateGlobalCountModel: Error: [${error}]`.red);
+        }
+    }
+
+
+    CreateNestedObject(combinedResults: JSONObject, keyList: string[]): JSONObject {
+        let workingObject = combinedResults;
+        keyList.forEach((key) => {
+            if (!workingObject[key]) {
+                workingObject[key] = { };
+                workingObject = workingObject[key];
+            }
+        });
+        return combinedResults;
+    }
+
+    // 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: InstrumentPayload): Promise<boolean> {
+        try {
+            if (this.#shuttingDown) {
+                return false;
+            }
+            if (instrumentPayload.context.agentName) {
+                return this.#influxDBManagerClients['agent'].OutputInfluxDB(instrumentPayload);
+            } else {
+                return this.#influxDBManagerClients['service'].OutputInfluxDB(instrumentPayload);
+            }
+        } catch (error) {
+            console.error(`${_logPrefix}OutputInfluxDB: Could not write data point: [${error}]`.red);
+            return false;
+        }
+    }
+}

package/src/influxdb/influxDBManagerAgent.ts

@@ -0,0 +1,227 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import { Point, WriteApi, QueryApi } from '@influxdata/influxdb-client'
+
+import { InstrumentPayload } from '@nsshunt/stsmodels'
+import { Gauge, InstrumentVelocity } from '@nsshunt/stsinstrumentation'
+
+import { InfluxDBManagerBase } from './influxDBManagerBase'
+
+import { IInfluxDBManagerOptions } from './../commonTypes'
+
+const _logPrefix = 'InfluxDBManagerService:'
+
+export class InfluxDBManagerAgent extends InfluxDBManagerBase
+{
+    constructor(options: IInfluxDBManagerOptions, queryApi: QueryApi, writeClient: WriteApi) {
+        super(options, queryApi, writeClient);
+    }
+
+    override get modelType(): string {
+        return 'agent'
+    }
+
+    // Queries --------------------------------------------------------------------------------------------------------
+
+    // Counter metrics
+    #GetSTSCountGenericAgent = async (modelType: string, filterClause: string, groupClause: string, showOutput: boolean = false) => {
+        try {
+            const query = `dostscountex = (q, d) => 
+            from(bucket: "${this.options.bucket}") 
+            |> range(start: d) 
+            |> filter(fn: (r) => r["_measurement"] == "all" and r["modelType"] == "${modelType}" ${filterClause}) 
+            |> filter(fn: (r) => r["_field"] == q) 
+            |> last()
+            |> ${groupClause}
+            |> sum()
+            
+            dostscount = (d) =>
+            union(tables: [
+                dostscountex(q: "requestCount", d: d),
+                dostscountex(q: "errorCount", d: d),
+                dostscountex(q: "retryCount", d: d),
+                dostscountex(q: "authenticationCount", d: d),
+                dostscountex(q: "velocity", d: d),
+                dostscountex(q: "coreCount", d: d),
+                dostscountex(q: "timer", d: d),
+                dostscountex(q: "duration", d: d),
+                dostscountex(q: "latency", d: d),
+                dostscountex(q: "activeRequestCount", d: d)
+            ])
+            dostscount(d: -5s)`;
+
+            if (showOutput) {
+                console.log(query);
+            }
+
+            return this.queryApi.collectRows(query)
+        } catch (error) {
+            console.error(`${_logPrefix}#GetSTSCountGeneric: Error: [${error}]`.red);
+        }
+    }
+
+    // Histo metrics
+    #GetSTSHistoGenericService = async (modelType: string, filterClause: string, groupClause: string): Promise<any> => {
+        try {
+            const query = `import "math"
+
+            dostshistoex = (q, d) =>
+            from(bucket: "${this.options.bucket}") 
+            |> range(start: d) 
+            |> filter(fn: (r) => r["_measurement"] == "all") 
+            |> filter(fn: (r) => r["_field"] == q and r["modelType"] == "${modelType}" ${filterClause}) 
+            |> ${groupClause}
+            |> histogram(bins: [0.0, 10.0, 20.0, 50.0, 100.0, 1000.0, 50000.0, math.mInf(sign: 1) ])
+            |> difference()
+            
+            dostshisto = (d) =>
+            union(tables: [
+                dostshistoex(q: "latency", d: d),
+                dostshistoex(q: "duration", d: d)
+            ])
+            
+            dostshisto(d: -10m)`;
+            return this.queryApi.collectRows(query)
+        } catch (error) {
+            console.error(`${_logPrefix}#GetSTSHistoGeneric: Error: [${error}]`.red);
+        }
+    }
+
+    // Quantile metrics
+    #GetSTSQuantileGenericAgent = async (modelType: string, filterClause: string, groupClause: string) => {
+        try {
+            const query = `dostsquantileex = (q, d, i, f) =>
+            from(bucket: "${this.options.bucket}") 
+            |> range(start: d) 
+            |> filter(fn: (r) => r["_measurement"] == "all")
+            |> filter(fn: (r) => r["_field"] == f and r["modelType"] == "${modelType}" ${filterClause})
+            |> ${groupClause}
+            |> aggregateWindow(every: i, fn: max, createEmpty: false)
+            |> quantile(q: q, method: "estimate_tdigest", compression: 1000.0)
+            |> set(key: "quantile", value: string(v:q))
+            |> group(columns: ["LatencyType","quantile"])
+            
+            dostsquantile = (d, i, f) =>
+            union(tables: [
+                dostsquantileex(q: 0.5, d: d, i: i, f: f),
+                dostsquantileex(q: 0.8, d: d, i: i, f: f),
+                dostsquantileex(q: 0.9, d: d, i: i, f: f),
+                dostsquantileex(q: 0.95, d: d, i: i, f: f),
+                dostsquantileex(q: 0.99, d: d, i: i, f: f)
+            ])
+            
+            union(tables: [
+                dostsquantile(d: -10m, i: 5s, f: "latency"),
+                dostsquantile(d: -10m, i: 5s, f: "duration")
+            ])`;
+            
+            return this.queryApi.collectRows(query)
+        } catch (error) {
+            console.error(`${_logPrefix}#GetSTSQuantileGeneric: Error: [${error}]`.red);
+        }
+    }
+    
+    // Metric queries -------------------------------------------------------------------------------------------------
+    // Root level metrics
+    async GetInfluxDBResultsRootAgent() {
+        try {
+            const combinedResults = await this.ProcessInfluxDBResults([
+                this.#GetSTSCountGenericAgent('agent', '', 'group(columns: ["_field"])'),
+                this.#GetSTSQuantileGenericAgent(`agent`, '', 'group(columns: ["_field"])'),
+                this.#GetSTSHistoGenericService('agent', '', 'group(columns: ["_field"])')],
+            [ ])
+        
+            return { SubscriptionType: "ID_Agent_Root", data: combinedResults };
+        } catch (error) {
+            console.error(`${_logPrefix}GetInfluxDBResultsRootAgent: Error: [${error}]`.red);
+        }
+    }
+
+    // Service level metrics
+    async GetInfluxDBResultsAgent() {
+        try {
+            const combinedResults = await this.ProcessInfluxDBResults([
+                this.#GetSTSCountGenericAgent('agent', '', 'group(columns: ["agentName", "_field"])'),
+                this.#GetSTSQuantileGenericAgent(`agent`, '', 'group(columns: ["agentName", "_field"])'),
+                this.#GetSTSHistoGenericService('agent', '', 'group(columns: ["agentName", "_field"])')],
+            ['agentName'])
+            
+            return { SubscriptionType: "ID_Agent_Agents", data: combinedResults};
+        } catch (error) {
+            console.error(`${_logPrefix}GetInfluxDBResultsAgent: Error: [${error}]`.red);
+        }
+    }
+
+    // Service instance metrics for a particular service type
+    async GetInfluxDBResultsAgentThreads(agentName: string) {
+        try {
+
+            const combinedResults = await this.ProcessInfluxDBResults([
+                this.#GetSTSCountGenericAgent('agent', `and r["agentName"] == "${agentName}"`, `group(columns: ["agentName", "threadId", "_field"])`),
+                this.#GetSTSQuantileGenericAgent(`agent`, `and r["agentName"] == "${agentName}"`, 'group(columns: ["agentName", "threadId", "_field"])'),
+                this.#GetSTSHistoGenericService('agent', `and r["agentName"] == "${agentName}"`, 'group(columns: ["agentName", "threadId", "_field"])')],
+            ['agentName', 'threadId'])
+
+            console.log(`${JSON.stringify(combinedResults)}`.magenta);
+
+            return { SubscriptionType: `ID_Agent_Agent_Threads_${agentName}`, data: combinedResults};
+        } catch (error) {
+            console.error(`${_logPrefix}GetInfluxDBResultsAgentThreads: Error: [${error}]`.red);
+        }
+    }
+
+    // Service instance thread metrics for a particular service instance
+    async GetInfluxDBResultsAgentThread(agentName: string, threadId: string) {
+        try {
+            const combinedResults = await this.ProcessInfluxDBResults([
+                this.#GetSTSCountGenericAgent('agent', `and r["agentName"] == "${agentName}" and r["threadId"] == "${threadId}"`, `group(columns: ["agentName", "threadId", "asyncRunnerId", "_field"])`),
+                this.#GetSTSQuantileGenericAgent(`agent`, `and r["agentName"] == "${agentName}" and r["threadId"] == "${threadId}"`, 'group(columns: ["agentName", "threadId", "asyncRunnerId", "_field"])'),
+                this.#GetSTSHistoGenericService('agent', `and r["agentName"] == "${agentName}" and r["threadId"] == "${threadId}"`, 'group(columns: ["agentName", "threadId", "asyncRunnerId", "_field"])')],
+            ['agentName', 'threadId', 'asyncRunnerId'])
+
+            return { SubscriptionType: `ID_Agent_Agent_Thread_${agentName}_${threadId}`, data: combinedResults};
+        } catch (error) {
+            console.error(`${_logPrefix}GetInfluxDBResultsAgentThread: Error: [${error}]`.red);
+        }
+    }
+    
+    // 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: InstrumentPayload): Promise<boolean> {
+        try {
+            const { nid, id, hostName, agentName, threadId, asyncRunnerId } = 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')
+                // Context settings
+                .tag('id', id as string) // Must be unique (uuid)
+                .tag('hostName', hostName as string) // Must be unique (uuid)
+                .tag('agentName', agentName as string) // Must be unique (uuid)
+                .tag('threadId', threadId as string) // Must be unique (uuid)
+                .tag('asyncRunnerId', asyncRunnerId as string)
+                .tag('modelType', 'agent')
+                // Data fields
+                .intField('requestCount', instrumentPayload.instruments[Gauge.REQUEST_COUNT_GAUGE].val) // q
+                .intField('errorCount', instrumentPayload.instruments[Gauge.ERROR_COUNT_GAUGE].val) // j
+                .intField('retryCount', instrumentPayload.instruments[Gauge.RETRY_COUNT_GAUGE].val) // r
+                .intField('authenticationCount', instrumentPayload.instruments[Gauge.AUTHENTICATION_COUNT_GAUGE].val) // b
+                .floatField('velocity', (instrumentPayload.instruments[Gauge.VELOCITY_GAUGE] as InstrumentVelocity).va) // t
+                .intField('coreCount', instrumentPayload.instruments[Gauge.CORE_COUNT_GAUGE].val) // x
+                .floatField('timer', instrumentPayload.instruments[Gauge.TIMER_GAUGE].val) // s
+                .floatField('duration', instrumentPayload.instruments[Gauge.DURATION_GAUGE].val) // h
+                .floatField('latency', instrumentPayload.instruments[Gauge.LATENCY_GAUGE].val) // h
+                .intField('activeRequestCount', instrumentPayload.instruments[Gauge.ACTIVE_REQUEST_GAUGE].val) // a
+                // logger // m
+                // duration histo // i
+            this.writeClient.writePoint(point);
+            return true;
+        } catch (error: any) {
+            console.error(`${_logPrefix}OutputInfluxDBAgent: Could not write data point: [${error}]`.red);
+            return false;
+        }
+    }
+}