changes to apply an oop paradigm in metrics

Author: piotrek98

lib/core/http.ts

@@ -3,26 +3,25 @@ import * as https from "https";
 import { Client } from "../node/client";
 import { RequestType } from "../transport/types";
 
-type HttpRequestOptions = {
-  callback?: (stream: http.IncomingMessage) => void;
-  onError?: (error: Error) => void;
+type RequestOptionsType = {
+  body: {};
+  onError: (error: Error) => void;
 };
 export class HttpModule {
   host: string;
   url: URL;
-  body: string;
   method: RequestType;
 
-  constructor(url: string, body?: {}, method: RequestType = "POST") {
+  constructor(url: string, method: RequestType = "POST") {
     this.host = Client.config.url;
 
     this.url = new URL(url, this.host);
-    this.body = JSON.stringify(body);
     this.method = method;
   }
 
-  // TODO: implement callbacks from options later
-  public request(_options?: HttpRequestOptions) {
+  public request(options: RequestOptionsType) {
+    const { body, onError } = options;
+
     const requestOptions = {
       ...this.requestHeaders(),
       ...this.requestOptions(),
@@ -31,16 +30,16 @@ export class HttpModule {
     const httpModule = this.requestModule();
 
     const request = httpModule.request(requestOptions);
-    request.on("error", () => {});
+    request.on("error", () => onError);
 
-    this.requestWriteBody(request);
+    this.requestWriteBody(request, body);
 
     request.end();
   }
 
-  private requestWriteBody(request: http.ClientRequest) {
+  private requestWriteBody(request: http.ClientRequest, body: {}) {
     if (this.method === "POST") {
-      request.write(this.body);
+      request.write(JSON.stringify(body));
     }
   }
 
@@ -73,7 +72,6 @@ export class HttpModule {
     return {
       headers: {
         "Content-Type": "application/json",
-        "Content-Length": this.body.length,
       },
     };
   }

lib/core/interfaces/IMetrics.ts

@@ -0,0 +1,3 @@
+export interface IMetrics<T> {
+  collect(): T;
+}

lib/node/client.ts

@@ -1,18 +1,25 @@
 import { isEmpty } from "../core/is";
 import { TraceoOptions } from "../transport/options";
 import { Logger } from "./logger";
-import { metrics } from "./metrics";
-import { loadRuntimeMetrics } from "./metrics/runtime-data";
+import { MetricsProbe } from "./metrics";
+import { RuntimeData } from "./metrics/runtime-data";
 
 export class Client {
-  options: TraceoOptions;
+  private options: TraceoOptions;
+
+  private metricsProbe: MetricsProbe;
+  private runtimeData: RuntimeData;
+
   readonly logger: Logger;
 
   constructor(options: TraceoOptions) {
     this.configGlobalClient();
 
     this.options = options;
+    this.metricsProbe = new MetricsProbe(this.options);
+
     this.logger = new Logger();
+    this.runtimeData = new RuntimeData();
 
     if (!this.isOffline) {
       this.initSDK();
@@ -44,11 +51,11 @@ export class Client {
   }
 
   private initSDK(): void {
+    this.runtimeData.collect();
+
     if (this.options.metrics.collect) {
-      metrics.collectMetrics(this.options);
+      this.metricsProbe.register();
     }
-
-    loadRuntimeMetrics();
   }
 
   private configGlobalClient(): void {

lib/node/exceptions/handler.ts

@@ -49,8 +49,16 @@ export const catchException = async (error: any, catchOptions?: Catch) => {
 
 const handleException = async (error: TraceoError) => {
   const event: Incident = await prepareException(error);
-  const httpModule = new HttpModule("/api/worker/incident", event);
-  httpModule.request();
+  const httpModule = new HttpModule("/api/worker/incident");
+  httpModule.request({
+    body: event,
+    onError: (error: Error) => {
+      console.error(
+        `Traceo Error. Something went wrong while sending new Incident to Traceo. Please report this issue.`
+      );
+      console.error(`Caused by: ${error.message}`);
+    },
+  });
 };
 
 const prepareException = async (error: TraceoError): Promise<Incident> => {

lib/node/logger.ts

@@ -1,9 +1,13 @@
 import { format } from "util";
 import { HttpModule } from "../core/http";
-import { LogLevel, TraceoLog } from "../transport/logger";
+import { LogLevel } from "../transport/logger";
 
 export class Logger {
-  constructor() {}
+  private readonly http: HttpModule;
+
+  constructor() {
+    this.http = new HttpModule("/api/worker/log");
+  }
 
   public log(...args: any[]): void {
     return this.printMessage(this.getEntryFromArgs(args), LogLevel.Log);
@@ -46,8 +50,15 @@ export class Logger {
       resources: this.resources,
     };
 
-    const httpModule = new HttpModule("/api/worker/log", requestPayload);
-    httpModule.request();
+    this.http.request({
+      body: requestPayload,
+      onError: (error: Error) => {
+        console.error(
+          `Traceo Error. Something went wrong while sending new Log to Traceo. Please report this issue.`
+        );
+        console.error(`Caused by: ${error.message}`);
+      },
+    });
   }
 
   private get timestamp(): string {

lib/node/metrics.ts

@@ -1,35 +1,70 @@
 import { HttpModule } from "../core/http";
 import { Metrics } from "../transport/metrics";
 import { TraceoOptions } from "../transport/options";
-import { cpu } from "./metrics/cpu-usage";
-import * as os from "node:os";
-import { memory } from "./metrics/memory-usage";
-import { heap } from "./metrics/heap";
-import { eventLoop } from "./metrics/event-loop";
 import { toDecimalNumber } from "./helpers";
+import { CpuUsageMetrics } from "./metrics/cpu-usage";
+import { EventLoopMetrics } from "./metrics/event-loop";
+import { HeapMetrics } from "./metrics/heap";
+import { MemoryUsageMetrics } from "./metrics/memory-usage";
+import * as os from "os";
 
 const DEFAULT_INTERVAL = 30; //seconds
 
-const collectMetrics = (options: TraceoOptions) => {
-  const { metrics } = options;
+export class MetricsProbe {
+  private readonly interval: number;
 
-  const INTERVAL =
-    (metrics?.interval < 15 ? DEFAULT_INTERVAL : metrics?.interval) * 1000;
+  private readonly http: HttpModule;
 
-  setInterval(() => {
-    const metrics: Metrics = {
-      cpuUsage: cpu.usage(),
-      memory: memory.usage(),
-      loadAvg: toDecimalNumber(os.loadavg()[0]),
+  private readonly cpuUsage: CpuUsageMetrics;
+  private readonly eventLoop: EventLoopMetrics;
+  private readonly heap: HeapMetrics;
+  private readonly memoryUsage: MemoryUsageMetrics;
+
+  constructor(options: TraceoOptions) {
+    if (!options.metrics.collect) {
+      return;
+    }
+
+    this.interval = options.metrics.interval || DEFAULT_INTERVAL;
+
+    this.http = new HttpModule("/api/worker/metrics");
+
+    this.cpuUsage = new CpuUsageMetrics();
+    this.eventLoop = new EventLoopMetrics();
+    this.heap = new HeapMetrics();
+    this.memoryUsage = new MemoryUsageMetrics();
+  }
+
+  public register() {
+    setInterval(() => this.collectMetrics(), this.interval * 1000);
+  }
+
+  private collectMetrics() {
+    const cpuUsage = this.cpuUsage.collect();
+    const eventLoop = this.eventLoop.collect();
+    const heap = this.heap.collect();
+    const memory = this.memoryUsage.collect();
+
+    const metrics: Partial<Metrics> = {
+      cpuUsage,
+      eventLoopLag: eventLoop,
       heap,
-      eventLoopLag: eventLoop.collect(),
+      memory,
+      loadAvg: this.loadAvg,
     };
 
-    const httpModule = new HttpModule("/api/worker/metrics", metrics);
-    httpModule.request();
-  }, INTERVAL);
-};
+    this.http.request({
+      body: metrics,
+      onError: (error: Error) => {
+        console.error(
+          `Traceo Error. Something went wrong while sending new Log to Traceo. Please report this issue.`
+        );
+        console.error(`Caused by: ${error.message}`);
+      },
+    });
+  }
 
-export const metrics = {
-  collectMetrics,
-};
+  private get loadAvg() {
+    return toDecimalNumber(os.loadavg()[0]);
+  }
+}

lib/node/metrics/cpu-usage.ts

@@ -1,36 +1,44 @@
 import * as os from "node:os";
+import { IMetrics } from "../../core/interfaces/IMetrics";
 
-const averageCpu = (): { idle: number; total: number } => {
-  let totalIdle = 0;
-  let totalTick = 0;
-  const cpus = os.cpus();
-
-  for (let i = 0, len = cpus.length; i < len; i++) {
-    const cpu = cpus[i];
-    for (const type in cpu.times) {
-      totalTick += cpu.times[type];
-    }
+type AverageCpuMetricType = {
+  idle: number;
+  total: number;
+};
+export class CpuUsageMetrics implements IMetrics<number> {
+  measureStart: AverageCpuMetricType;
 
-    totalIdle += cpu.times.idle;
+  constructor() {
+    this.measureStart = this.calculateAverageCpuUsage();
   }
 
-  return { idle: totalIdle / cpus.length, total: totalTick / cpus.length };
-};
+  collect(): number {
+    const endMeasure = this.calculateAverageCpuUsage();
 
-const startMeasure = averageCpu();
+    const idleDifference = endMeasure.idle - this.measureStart.idle;
+    const totalDifference = endMeasure.total - this.measureStart.total;
 
-const getCpuUsage = () => {
-  const endMeasure = averageCpu();
+    const cpuUsage =
+      Math.round((100 - (100 * idleDifference) / totalDifference) * 100) / 100;
 
-  const idleDifference = endMeasure.idle - startMeasure.idle;
-  const totalDifference = endMeasure.total - startMeasure.total;
+    return cpuUsage;
+  }
 
-  const cpuUsage =
-    Math.round((100 - (100 * idleDifference) / totalDifference) * 100) / 100;
+  private calculateAverageCpuUsage(): AverageCpuMetricType {
+    const cpus = os.cpus();
 
-  return cpuUsage;
-};
+    let totalIdle: number = 0;
+    let totalTick: number = 0;
 
-export const cpu = {
-  usage: getCpuUsage,
-};
+    for (let i = 0, len = cpus.length; i < len; i++) {
+      const cpu = cpus[i];
+      for (const type in cpu.times) {
+        totalTick += cpu.times[type];
+      }
+
+      totalIdle += cpu.times.idle;
+    }
+
+    return { idle: totalIdle / cpus.length, total: totalTick / cpus.length };
+  }
+}

lib/node/metrics/event-loop.ts

@@ -1,25 +1,35 @@
 import * as perf_hooks from "perf_hooks";
-import { Metrics } from "../../transport/metrics";
+import { IMetrics } from "../../core/interfaces/IMetrics";
 import { toDecimalNumber } from "../helpers";
 
-const histogram = perf_hooks.monitorEventLoopDelay({
-  resolution: 10,
-});
-histogram.enable();
+type EventLoopMetricType = {
+  min: number;
+  max: number;
+  mean: number;
+  stddev: number;
+};
 
-const collect = () => {
-  const data: Metrics["eventLoopLag"] = {
-    min: toDecimalNumber(histogram.min / 1e6),
-    max: toDecimalNumber(histogram.max / 1e6),
-    mean: toDecimalNumber(histogram.mean / 1e6),
-    stddev: toDecimalNumber(histogram.stddev / 1e6),
-    p50: toDecimalNumber(histogram.percentile(50) / 1e6),
-    p90: toDecimalNumber(histogram.percentile(90) / 1e6),
-    p99: toDecimalNumber(histogram.percentile(99) / 1e6),
-  };
-  histogram.reset();
+export class EventLoopMetrics implements IMetrics<EventLoopMetricType> {
+  //TODO: should be type here, but in different versions there are a different type,
+  //eq. perf_hooks.IntervalHistogram
+  histogram: any;
 
-  return data;
-};
+  constructor() {
+    this.histogram = perf_hooks.monitorEventLoopDelay({
+      resolution: 10,
+    });
+    this.histogram.enable();
+  }
+
+  collect(): EventLoopMetricType {
+    const data: EventLoopMetricType = {
+      min: toDecimalNumber(this.histogram.min / 1e6),
+      max: toDecimalNumber(this.histogram.max / 1e6),
+      mean: toDecimalNumber(this.histogram.mean / 1e6),
+      stddev: toDecimalNumber(this.histogram.stddev / 1e6),
+    };
+    this.histogram.reset();
 
-export const eventLoop = { collect };
+    return data;
+  }
+}