new client version based on oop paradigm

Author: piotrek98

lib/core/global.ts

@@ -1,8 +1,3 @@
-import { TraceoGlobal } from "../transport/base";
+import { Client } from "../node/client";
 
-export const getGlobalClientData = (): TraceoGlobal =>
-  global["__TRACEO__"] || {};
-
-export const setGlobalClientData = (data: TraceoGlobal): void => {
-  global.__TRACEO__ = { ...data };
-};
+export const getGlobalClientData = (): Client => global["__TRACEO__"];

lib/core/http.ts

@@ -1,103 +1,80 @@
 import * as http from "http";
-import { EventResponse, Incident } from "../transport/events";
-import {
-  TraceoIncomingMessage,
-  RequestOptions,
-  HTTP_ENDPOINT,
-} from "../transport/http";
-import { TraceoLog } from "../transport/logger";
-import { Metrics } from "../transport/metrics";
+import * as https from "https";
+import { Client } from "../node/client";
 import { RequestType } from "../transport/types";
-import { getGlobalClientData } from "./global";
-import { TRACEO_SDK_VERSION } from "./version";
 
-const createHttpOptions = (
-  path: string,
-  method: RequestType = "POST"
-): http.RequestOptions => {
-  const client = getGlobalClientData();
-
-  const { host, port } = client.connection;
-  const baseOptions: RequestOptions = {
-    hostname: host,
-    port,
-    method,
-    headers: {
-      "Content-Type": "application/json",
-    },
-  };
-
-  return {
-    path,
-    ...baseOptions,
-  };
-};
-
-const sendLog = async (log: TraceoLog) => {
-  const httpOptions = createHttpOptions(HTTP_ENDPOINT.LOG);
-  await sendEvent(log, httpOptions);
-};
-
-const sendRuntimeMetrics = async (data: {}) => {
-  const httpOptions = createHttpOptions(HTTP_ENDPOINT.RUNTIME);
-  await sendEvent(data, httpOptions);
+type HttpRequestOptions = {
+  callback?: (stream: http.IncomingMessage) => void;
+  onError?: (error: Error) => void;
 };
+export class HttpModule {
+  host: string;
+  url: URL;
+  body: string;
+  method: RequestType;
+
+  constructor(url: string, body?: {}, method: RequestType = "POST") {
+    this.host = Client.config.url;
+
+    this.url = new URL(url, this.host);
+    this.body = JSON.stringify(body);
+    this.method = method;
+  }
 
-const sendMetrics = async (data: Metrics) => {
-  const httpOptions = createHttpOptions(HTTP_ENDPOINT.METRICS);
-  await sendEvent(data, httpOptions);
-};
+  // TODO: implement callbacks from options later
+  public request(_options?: HttpRequestOptions) {
+    const requestOptions = {
+      ...this.requestHeaders(),
+      ...this.requestOptions(),
+    };
 
-const sendIncident = async (incident: Incident) => {
-  const version = TRACEO_SDK_VERSION;
-  const baseData = { version };
+    const httpModule = this.requestModule();
 
-  const payload = Object.assign(incident, baseData);
+    const request = httpModule.request(requestOptions);
+    request.on("error", () => {});
 
-  const httpOptions = createHttpOptions(HTTP_ENDPOINT.INCIDENT);
-  await sendEvent(payload, httpOptions);
-};
+    this.requestWriteBody(request);
 
-const sendEvent = async (
-  payload: any,
-  httpOptions: http.RequestOptions
-): Promise<EventResponse | void> => {
-  const { connection, appId } = getGlobalClientData();
+    request.end();
+  }
 
-  if (!connection || !appId) {
-    return;
+  private requestWriteBody(request: http.ClientRequest) {
+    if (this.method === "POST") {
+      request.write(this.body);
+    }
   }
 
-  return new Promise<EventResponse>((_, reject) => {
-    const options: http.RequestOptions = {
-      ...httpOptions,
-      path: `${httpOptions.path}/${appId}`,
-    };
+  private requestModule(): typeof http | typeof https {
+    return this.clientURL.protocol == "http:" ? http : https;
+  }
 
-    const request = http.request(options, (res: TraceoIncomingMessage) => {
-      res.setEncoding("utf8");
-      res.on("error", reject);
-    });
+  private get clientURL(): URL {
+    return new URL(this.host);
+  }
 
-    request.on("error", () => {});
+  private requestOptions(): http.RequestOptions {
+    const reqUrl = this.clientURL;
 
-    request.on("timeout", () => {
-      request.destroy();
-      reject({
-        statusCode: 400,
-        statusMessage:
-          "[Traceo] Error during sending event to Traceo. Connection timeout.",
-      });
-    });
+    return {
+      protocol: reqUrl.protocol,
+      port: reqUrl.port,
+      host: reqUrl.hostname,
+      method: this.method,
+      path: this.path,
+    };
+  }
 
-    request.write(JSON.stringify(payload));
-    request.end();
-  });
-};
+  private get path() {
+    return `${this.url.pathname}/${Client.config.appId}`;
+  }
 
-export const httpService = {
-  sendLog,
-  sendIncident,
-  sendRuntimeMetrics,
-  sendMetrics,
-};
+  private requestHeaders() {
+    if (this.method != "POST") return {};
+    return {
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": this.body.length,
+      },
+    };
+  }
+}

lib/core/types/global.d.ts

@@ -1,6 +1,6 @@
-import { TraceoGlobal } from "../../transport/base";
+import { Client } from "../../node/client";
 
 declare global {
-  var __TRACEO__: TraceoGlobal;
+  var __TRACEO__: Client;
 }
 export {};

lib/core/version.ts

@@ -1 +1,3 @@
-export const TRACEO_SDK_VERSION = "0.0.84";
+const pkg = require("../package.json");
+
+export const TRACEO_SDK_VERSION = pkg.version;

lib/node/client.ts

@@ -0,0 +1,57 @@
+import { isEmpty } from "../core/is";
+import { TraceoOptions } from "../transport/options";
+import { Logger } from "./logger";
+import { metrics } from "./metrics";
+import { loadRuntimeMetrics } from "./metrics/runtime-data";
+
+export class Client {
+  options: TraceoOptions;
+  readonly logger: Logger;
+
+  constructor(options: TraceoOptions) {
+    this.configGlobalClient();
+
+    this.options = options;
+    this.logger = new Logger();
+
+    if (!this.isOffline) {
+      this.initSDK();
+    }
+  }
+
+  public static get client(): Client {
+    return global.__TRACEO__;
+  }
+
+  public static get logger(): Logger {
+    return this.client.logger;
+  }
+
+  public static get config(): TraceoOptions {
+    return this.client.options;
+  }
+
+  get isOffline(): boolean {
+    return this.options.offline;
+  }
+
+  get isCollectMetrics(): boolean {
+    return this.options?.metrics?.collect;
+  }
+
+  get isConnected(): boolean {
+    return !isEmpty(global.__TRACEO__);
+  }
+
+  private initSDK(): void {
+    if (this.options.metrics.collect) {
+      metrics.collectMetrics(this.options);
+    }
+
+    loadRuntimeMetrics();
+  }
+
+  private configGlobalClient(): void {
+    global.__TRACEO__ = this;
+  }
+}

lib/node/exceptions/handler.ts

@@ -0,0 +1,70 @@
+import { stacktrace } from "stacktrace-parser-node";
+import { HttpModule } from "../../core/http";
+import { isClientConnected } from "../../core/is";
+import { TraceoError } from "../../transport/base";
+import { Incident } from "../../transport/events";
+import { getOsPlatform } from "../helpers";
+
+type Catch = {
+  shouldBeCatched?: (error: any) => boolean;
+};
+
+/**
+ * For using in middleware and as an function in try/catch
+ *
+ * Base usage:
+ * @example
+ *
+ * ```
+ * } catch (error) {
+ *     catchException(error);
+ * }
+ * ```
+ *
+ * Usage with `shouldBeCatched`:
+ * @example
+ *
+ * ```
+ * catchException(error, {
+ *   shouldBeCatched: () => {
+ *     return true;
+ *   }
+ * });
+ * ```
+ *
+ */
+export const catchException = async (error: any, catchOptions?: Catch) => {
+  if (catchOptions?.shouldBeCatched !== undefined) {
+    if (!catchOptions?.shouldBeCatched(error)) {
+      return;
+    }
+  }
+
+  if (isClientConnected()) {
+    await handleException(error);
+  }
+
+  return;
+};
+
+const handleException = async (error: TraceoError) => {
+  const event: Incident = await prepareException(error);
+  const httpModule = new HttpModule("/api/worker/incident", event);
+  httpModule.request();
+};
+
+const prepareException = async (error: TraceoError): Promise<Incident> => {
+  const { stack } = error;
+  const platform = getOsPlatform();
+
+  const { message, name, traces } = await stacktrace.parse(error);
+  const event: Incident = {
+    type: name,
+    message,
+    traces,
+    stack: String(stack),
+    platform,
+  };
+
+  return event;
+};

lib/node/exceptions/middleware.ts

@@ -0,0 +1,71 @@
+import { isClientConnected, isLocalhost } from "../../core/is";
+import { TraceoError } from "../../transport/base";
+import {
+  TraceoIncomingMessage,
+  TraceoServerResponse,
+} from "../../transport/http";
+import { ErrorMiddlewareOptions } from "../../transport/options";
+import { getProtocol, getIp } from "../helpers";
+import { catchException } from "./handler";
+/**
+ * Base middleware to catch and intercept error across the express app.
+ * This middleware catch errors only from the no-async methods.
+ *
+ * To catch errors from async functions, we suggest to use `catchException` instead.
+ *
+ * The simplest way to use it in Express.js and JavaScript:
+ *
+ * @example
+ * ```
+ *
+ * app.use(Middleware.errorMiddleware());
+ * ```
+ *
+ * Using Express.js with Typescript, middleware must be cast to express.ErrorRequestHandler.
+ *
+ * @example
+ * ```
+ *
+ * app.use(Middleware.errorMiddleware() as express.ErrorRequestHandler);
+ * ```
+ *
+ */
+export const errorMiddleware = (options: ErrorMiddlewareOptions = {}) => {
+  return async function errorMiddleware(
+    error: TraceoError,
+    req: TraceoIncomingMessage,
+    _res: TraceoServerResponse,
+    next: (error: TraceoError) => void
+  ): Promise<void> {
+    if (!isClientConnected()) {
+      next(error);
+      return;
+    }
+
+    if (isToCatch(req, options)) {
+      await catchException(error);
+    }
+
+    next(error);
+  };
+};
+
+const isToCatch = (
+  req: TraceoIncomingMessage,
+  options: ErrorMiddlewareOptions = {}
+): boolean => {
+  if (options.allowHttp !== undefined && !options.allowHttp) {
+    const isSecure = getProtocol(req) === "https" ? true : false;
+    if (!isSecure) {
+      return false;
+    }
+  }
+
+  if (options.allowLocalhost !== undefined && !options.allowLocalhost) {
+    if (isLocalhost(String(getIp(req)))) {
+      return false;
+    }
+  }
+
+  return true;
+};