feat/readme for node package

Author: piotrek98

packages/node/README.md

@@ -1 +1,139 @@
-<!-- Traceo NODE JS SDK -->
+# Traceo SDK for Node.js
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Library for integration with the [Traceo Platform](https://github.com/traceo-dev/traceo).
+
+### Installation
+To install this SDK add this package to your package.json like below:
+```
+yarn add @traceo-sdk/node
+```
+or
+```
+npm install @traceo-sdk/node
+```
+
+### Usage
+First what you need is to initialize `TraceoClient` in your application.
+```ts
+import { TraceoClient } from "@traceo-sdk/node";
+
+new TraceoClient({
+    appId: <your_application_id>,
+    url: <you_traceo_instance_url>
+});
+```
+
+`TraceoClient` options require two parameters. `appId` is a unique identifier of an application created on the Traceo platform. Information about application ID you can get from the Traceo Platform in `Settings|Details` tab.  `url` parameter specifies the address where your Traceo Platform instance is located. Address should be passed in the format `<protocol>://<domain>:<port>`, eq. `http://localhost:3000`.
+
+### Incidents handling
+Incidents are all the exceptions and other problems that occur in your application. After each exception occurs, the Traceo SDK catches the exception and sends it to the Traceo Platform. This package provide the two main ways to catch exceptions in your application - `Handlers` and `Middlewares`.
+
+##### Handlers
+The easiest way is to use `ExceptionsHandlers.catchException()` in `try-catch` clause like below:
+```ts
+import { ExceptionHandlers } from "@traceo-sdk/node";
+
+try {
+    //your code
+} catch (error) {
+    ExceptionHandlers.catchException(error);
+}
+```
+
+If you use [NestJS](https://nestjs.com/) framework then you can also create [Interceptor](https://docs.nestjs.com/interceptors) to catch exceptions like below:
+
+traceo.interceptor.ts
+```ts
+import { ExceptionHandlers } from "@traceo-sdk/node";
+//other imports
+
+@Injectable()
+export class TraceoInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    return next.handle().pipe(
+      tap(null, (exception) => {
+        ExceptionHandlers.catchException(exception);
+      }),
+    );
+  }
+}
+```
+
+main.ts
+```ts
+  app.useGlobalInterceptors(new TraceoInterceptor());
+```
+
+##### Middleware
+Another approach is to use `ExceptionMiddlewares.errorMiddleware()`. If you use the [Express.js](https://expressjs.com/) framework, you can use our middleware like below:
+
+Javascript:
+```js
+import { ExceptionMiddlewares } from "@traceo-sdk/node";
+
+app.use(ExceptionMiddlewares.errorMiddleware());
+```
+
+Typescript:
+```ts
+const { ExceptionMiddlewares } from "@traceo-sdk/node";
+
+app.use(ExceptionMiddlewares.errorMiddleware() as express.ErrorRequestHandler);
+```
+
+Remember that `ExceptionMiddlwares.errorMiddleware()` should be before any other error middlewares and after all routes/controllers.
+
+##### Middleware options
+
+
+| Parameter        | Description                                                                                                                                         | Default |
+| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
+| `allowLocalhost` | If false then middleware doesn't catch exceptions from requests coming from `localhost`                                                             | true    |
+| `allowHttp`      | If false then middleware doesn't catch exceptions received from requests where `req.protocol = http` and catch only exception received with `https` | true    |
+
+### Logger
+The Traceo SDK can be used also as a logger. Each log is saved on the Traceo Platform, thanks to which it is possible to later easily access the recorded information. Logs are sent to Traceo in every 60 seconds. To change this behavior, set a custom value (measured in seconds) in the `scrapLogsInterval` field inside traceo client properties like below:
+```ts
+import { TraceoClient } from "@traceo-sdk/node";
+
+new TraceoClient({
+    scrapLogsInterval: 120 //in seconds
+});
+```
+
+Example of using logger:
+```ts
+import { Logger } from "@traceo-sdk/node";
+
+const traceo = new TraceoClient({...});
+
+traceo.logger.log("Traceo");
+```
+
+The `logger` can use 5 different types of log: `log`, `info`, `debug`, `warn`, `error`. Each function responsible for logging the appropriate log type accepts a list of arguments in the parameter.
+```ts
+traceo.logger.log("Traceo", "Example", "Log");
+// [TraceoLogger][LOG] - 31.10.2022, 13:55:45 - Traceo Example Log
+
+traceo.logger.debug("Traceo", {
+    hello: "World"
+});
+// [TraceoLogger][DEBUG] - 31.10.2022, 13:58:00 - Traceo { hello: 'World' }
+```
+### Metrics
+To activate the collection of metrics from your application, set the parameter `collectMetrics` in your `TraceoClient` to true:
+
+```ts
+new TraceoClient({ collectMetrics: true });
+```
+Metrics are collected from the application every 30 seconds. If you want to collect metrics at a different time interval then you can use the `scrapMetricsInterval` parameter.
+
+```ts
+new TraceoClient({ scrapMetricsInterval: <interval_in_seconds> });
+```
+
+Remember that provided `scrapMetricsInterval` can't be less than `15` seconds.
+
+## Support
+Feel free to create Issues, Pull Request and Discussion. If you want to contact with the developer working on this package click [here](mailto:piotr.szewczyk.software@gmail.com).

packages/node/package.json

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

packages/node/src/client.ts

@@ -2,7 +2,6 @@ import { Logger } from "./logger";
 import { Metrics } from "./metrics";
 import { Scrapper } from "./scrapper";
 import { TraceoOptions } from "./types";
-import { IClientMetrics } from "./types/interfaces/IMetrics";
 import { TRACEO_SDK_VERSION } from "./version";
 
 export class Client {
@@ -24,7 +23,7 @@ export class Client {
       "x-sdk-key": this.options.apiKey,
     };
 
-    this.logger = new Logger(options?.scrapLogsInterval);
+    this.logger = new Logger();
     this.scrappedData = new Scrapper();
 
     this._metrics = new Metrics();
@@ -58,9 +57,9 @@ export class Client {
     }
   }
 
-  public metrics(): IClientMetrics {
-    return this._metrics;
-  }
+  // private metrics(): IClientMetrics {
+  //   return this._metrics;
+  // }
 
   private configGlobalClient(): void {
     global["__TRACEO__"] = this;

packages/node/src/index.ts

@@ -1,5 +1,4 @@
 export { Client as TraceoClient } from "./client";
-export { Logger } from "./logger";
 
 export * as ExceptionHandlers from "./exceptions/handler";
 export * as ExceptionMiddlewares from "./exceptions/middleware";

packages/node/src/logger.ts

@@ -1,23 +1,27 @@
 import { format } from "util";
 import { HttpModule } from "./core/http";
 import { LogLevel } from "./types";
-import * as http from "http";
+import { Client } from "./client";
 
 export class Logger {
   private readonly http: HttpModule;
-  private DEFAULT_INTERVAL = 60; //60s
   private logsQueue = [];
+  private INTERVAL = 60;
 
-  constructor(scrapInterval?: number) {
+  constructor() {
     this.http = HttpModule.getInstance();
     this.logsQueue = [];
 
-    let interval = this.DEFAULT_INTERVAL;
-    if (scrapInterval && scrapInterval >= 15) {
-      interval = scrapInterval;
+    const scrapLogsInterval = Client.config?.scrapLogsInterval;
+    if (scrapLogsInterval && scrapLogsInterval >= 15) {
+      this.INTERVAL = scrapLogsInterval;
     }
 
-    setInterval(() => this.sendLogs(), interval * 1000);
+    this.register();
+  }
+
+  private register() {
+    setInterval(() => this.sendLogs(), this.INTERVAL * 1000);
   }
 
   public log(...args: any[]): void {