feat/rebuilding http module to use him like singleton

Author: piotrek98

packages/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@traceo-sdk/node",
-    "version": "0.31.5",
+    "version": "0.31.6",
     "author": "Traceo",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

packages/node/src/client.ts

@@ -24,7 +24,7 @@ export class Client {
       "x-sdk-key": this.options.apiKey,
     };
 
-    this.logger = new Logger();
+    this.logger = new Logger(options?.scrapLogsInterval);
     this.scrappedData = new Scrapper();
 
     this._metrics = new Metrics();

packages/node/src/core/http.ts

@@ -4,41 +4,55 @@ import { Client } from "../client";
 import { RequestType } from "../types";
 
 type RequestOptionsType = {
+  url: string;
+  method?: RequestType;
   body: {};
   onError: (error: Error) => void;
+  callback?: (resp: http.IncomingMessage) => void;
 };
 export class HttpModule {
-  host: string;
-  url: URL;
-  method: RequestType;
+  private static instance: HttpModule;
+  private host: string;
 
-  constructor(url: string, method: RequestType = "POST") {
+  constructor() {
     this.host = Client.config.url;
-
-    this.url = new URL(url, this.host);
-    this.method = method;
   }
 
-  public request(options: RequestOptionsType) {
-    const { body, onError } = options;
+  public static getInstance() {
+    if (!HttpModule.instance) {
+      HttpModule.instance = new HttpModule();
+    }
+    return HttpModule.instance;
+  }
 
+  public request({
+    url,
+    method = "POST",
+    body,
+    onError,
+    callback,
+  }: RequestOptionsType) {
     const requestOptions = {
-      ...this.requestHeaders(),
-      ...this.requestOptions(),
+      ...this.requestHeaders(method),
+      ...this.requestOptions(url, method),
     };
 
     const httpModule = this.requestModule();
 
-    const request = httpModule.request(requestOptions);
+    const request = httpModule.request(requestOptions, callback);
     request.on("error", () => onError);
 
-    this.requestWriteBody(request, body);
+    this.requestWriteBody(method, request, body);
 
     request.end();
   }
 
-  private requestWriteBody(request: http.ClientRequest, body: {}) {
-    if (this.method === "POST") {
+  private requestWriteBody(
+    method: RequestType,
+    request: http.ClientRequest,
+    body: {}
+  ) {
+    if (method === "POST") {
       request.write(JSON.stringify(body));
     }
   }
@@ -51,28 +65,28 @@ export class HttpModule {
     return new URL(this.host);
   }
 
-  private requestOptions(): http.RequestOptions {
+  private requestOptions(
+    url: string,
+    method: RequestType
+  ): http.RequestOptions {
     const reqUrl = this.clientURL;
+    const path = new URL(url, this.host);
 
     return {
       protocol: reqUrl.protocol,
       port: reqUrl.port,
       host: reqUrl.hostname,
-      method: this.method,
-      path: this.path,
+      method,
+      path: `${path.pathname}/${Client.config.appId}`,
     };
   }
 
-  private get path() {
-    return `${this.url.pathname}/${Client.config.appId}`;
-  }
-
-  private requestHeaders() {
+  private requestHeaders(method: RequestType) {
     const headers = Client.client.headers;
     const baseHeaders = {
       ...headers,
     };
-    if (this.method !== "POST") return baseHeaders;
+    if (method !== "POST") return baseHeaders;
     return {
       headers: {
         "Content-Type": "application/json",

packages/node/src/exceptions/handler.ts

@@ -28,8 +28,9 @@ export const catchException = async (error: any) => {
 
 const handleException = async (error: TraceoError) => {
   const event: Incident = await prepareException(error);
-  const httpModule = new HttpModule("/api/worker/incident");
+  const httpModule = HttpModule.getInstance();
   httpModule.request({
+    url: "/api/worker/incident",
     body: event,
     onError: (error: Error) => {
       console.error(

packages/node/src/logger.ts

@@ -1,12 +1,23 @@
 import { format } from "util";
 import { HttpModule } from "./core/http";
 import { LogLevel } from "./types";
+import * as http from "http";
 
 export class Logger {
   private readonly http: HttpModule;
+  private DEFAULT_INTERVAL = 60; //60s
+  private logsQueue = [];
 
-  constructor() {
-    this.http = new HttpModule("/api/worker/log");
+  constructor(scrapInterval?: number) {
+    this.http = HttpModule.getInstance();
+    this.logsQueue = [];
+
+    let interval = this.DEFAULT_INTERVAL;
+    if (scrapInterval && scrapInterval >= 15) {
+      interval = scrapInterval;
+    }
+
+    setInterval(() => this.sendLogs(), interval * 1000);
   }
 
   public log(...args: any[]): void {
@@ -50,15 +61,25 @@ export class Logger {
       resources: this.resources,
     };
 
-    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}`);
-      },
-    });
+    this.logsQueue.push(requestPayload);
+  }
+
+  private async sendLogs() {
+    if (this.logsQueue.length > 0) {
+      this.http.request({
+        url: "/api/worker/log",
+        body: this.logsQueue,
+        onError: (error: Error) => {
+          console.error(
+            `Traceo Error. Something went wrong while sending new Logs to Traceo. Please report this issue.`
+          );
+          console.error(`Caused by: ${error.message}`);
+        },
+        callback: () => {
+          this.logsQueue = [];
+        },
+      });
+    }
   }
 
   private get timestamp(): string {
@@ -82,8 +103,8 @@ export class Logger {
       packageName: process.env["npm_package_name"],
       packageVersion: process.env["npm_package_version"],
       traceoVersion:
-        process.env["npm_package_dependencies_traceo"] ||
-        process.env["npm_package_devDependencies_traceo"],
+        process.env["npm_package_dependencies_@traceo-sdk/node"] ??
+        process.env["npm_package_devDependencies_@traceo-sdk/node"],
     };
   }
 

packages/node/src/metrics/runner.ts

@@ -41,7 +41,7 @@ export class MetricsRunner {
     this.interval =
       this.client.options.scrapMetricsInterval || DEFAULT_INTERVAL;
 
-    this.http = new HttpModule("/api/worker/metrics");
+    this.http = HttpModule.getInstance();
 
     this.cpuUsage = new CpuUsageMetrics();
     this.eventLoop = new EventLoopMetrics();
@@ -94,17 +94,18 @@ export class MetricsRunner {
     };
 
     this.http.request({
+      url: "/api/worker/metrics",
       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}`);
       },
+      callback: () => {
+        this.clearClientMetrics();
+      }
     });
-
-    // TODO: This shouldn't be called when there is error on http.request
-    this.clearClientMetrics();
   }
 
   private get loadAvg(): number {

packages/node/src/scrapper.ts

@@ -10,7 +10,7 @@ export class Scrapper {
   private readonly http: HttpModule;
 
   constructor() {
-    this.http = new HttpModule("/api/worker/runtime");
+    this.http = HttpModule.getInstance();
   }
 
   collect(): void {
@@ -29,6 +29,7 @@ export class Scrapper {
     };
 
     this.http.request({
+      url: "/api/worker/runtime",
       body: data,
       onError: (error: Error) => {
         console.error(
@@ -41,11 +42,7 @@ export class Scrapper {
 
   private get heap() {
     const heapStats = v8.getHeapStatistics();
-    // const heapCodeStats = v8.getHeapCodeStatistics();
-    return {
-      ...heapStats,
-      // ...heapCodeStats,
-    };
+    return heapStats;
   }
 
   private get packageJsonInfo() {

packages/node/src/types/options.ts

@@ -13,6 +13,11 @@ export interface TraceoOptions {
     then the data will be downloaded just for this time.
   */
   scrapMetricsInterval?: number;
+  /*
+    Default is 60s.
+    Value can't be smaller than 15.
+  */
+  scrapLogsInterval?: number;
 }
 
 export interface ErrorMiddlewareOptions {