fixes and improvements, using dsn instead of appId passed into sdk options, renaming to Traceo

Author: piotrek98

README.md

@@ -1,2 +1,2 @@
-# klepper.io-node
-Library for klepper.io written in Typescript
+# traceo-sdk
+Library for Traceo written in Typescript

package.json

@@ -1,6 +1,6 @@
 {
-  "name": "klepper",
-  "version": "0.0.61-alpha",
+  "name": "traceo-sdk",
+  "version": "0.0.72-alpha",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/core/global.ts

@@ -1,8 +1,8 @@
-import { KlepperGlobal } from "../transport/base";
+import { TraceoGlobal } from "../transport/base";
 
-export const getGlobalClientData = (): KlepperGlobal =>
-  global.__KLEPPER__ || {};
+export const getGlobalClientData = (): TraceoGlobal =>
+  global.__TRACEO__ || {};
 
-export const setGlobalClientData = (data: KlepperGlobal): void => {
-  global.__KLEPPER__ = { ...data };
+export const setGlobalClientData = (data: TraceoGlobal): void => {
+  global.__TRACEO__ = { ...data };
 };

src/core/http.ts

@@ -1,37 +1,36 @@
 import * as http from "http";
+import { sanitizeDsn } from "../node/helpers";
 import { RequestStatus } from "../transport/enums";
 import {
   EventResponse,
-  KlepperEvent,
-  KlepperReleaseEvent,
+  TraceoEvent,
+  TraceoReleaseEvent,
 } from "../transport/events";
-import { KlepperIncomingMessage, RequestOptions } from "../transport/http";
+import { TraceoIncomingMessage, RequestOptions } from "../transport/http";
 import { getGlobalClientData } from "./global";
 import { isClientConnected } from "./is";
 
-const KLEPPER_HOST = process.env.KLEPPER_HOST || "localhost";
-const KLEPPER_API = process.env.KLEPPER_API || "/sdk/incident";
-const KLEPPER_PORT = process.env.KLEPPER_PORT || 8080;
-
 const createHttpOptions = ({
   event,
-  api = KLEPPER_API,
+  api,
 }: {
-  event?: KlepperEvent | KlepperReleaseEvent;
+  event?: TraceoEvent | TraceoReleaseEvent;
   api?: string;
 }): http.RequestOptions => {
   const client = getGlobalClientData();
 
-  const { privateKey, appId } = client;
+  const { dsn } = client;
+  const { host, secretKey, appId } = sanitizeDsn(dsn);
+
+  api = api === "release" ? `/release/${appId}` : `/${appId}`;
+
   const baseOptions: RequestOptions = {
-    hostname: KLEPPER_HOST,
-    port: +KLEPPER_PORT,
+    hostname: host,
     method: "POST",
     headers: {
       "Content-Type": "application/json",
       "Content-Length": `${Buffer.byteLength(JSON.stringify(event))}`,
-      "klepper-private-key": String(privateKey),
-      "klepper-app-id": String(appId),
+      "traceo-secret-key": secretKey
     },
   };
 
@@ -44,26 +43,25 @@ const createHttpOptions = ({
 const statusFromCode = (code: number) =>
   code >= 200 && code <= 299 ? RequestStatus.SUCCESS : RequestStatus.ERROR;
 
-export const sendConnection = (connectionData: KlepperReleaseEvent): void => {
+export const sendConnection = (connectionData: TraceoReleaseEvent): void => {
   const httpOptions = createHttpOptions({
     event: connectionData,
-    api: "/sdk/release",
+    api: "release",
   });
 
-  const request = http.request(httpOptions, (res: KlepperIncomingMessage) => {
+  const request = http.request(httpOptions, (res: TraceoIncomingMessage) => {
     res.setEncoding("utf8");
   });
   request.write(JSON.stringify(connectionData));
   request.end();
 };
 
 export const sendEvent = async (
-  event: KlepperEvent
+  event: TraceoEvent
 ): Promise<EventResponse> => {
   const client = getGlobalClientData();
 
   const baseData = {
-    env: client?.environment,
     version: client?.version,
   };
 
@@ -75,19 +73,19 @@ export const sendEvent = async (
       reject({
         statusCode: 400,
         statusMessage:
-          "[Klepper] Error during sending event to Klepper. No HTTP options.",
+          "[Traceo] Error during sending event to Traceo. No HTTP options.",
       });
     }
 
     if (!isClientConnected()) {
       reject({
         statusCode: 400,
         statusMessage:
-          "[Klepper] Error during sending event to Klepper. No client global data in NodeJS scope.",
+          "[Traceo] Error during sending event to Traceo. No client global data in NodeJS scope.",
       });
     }
 
-    const request = http.request(httpOptions, (res: KlepperIncomingMessage) => {
+    const request = http.request(httpOptions, (res: TraceoIncomingMessage) => {
       res.setEncoding("utf8");
 
       const status = statusFromCode(res?.statusCode as number);
@@ -96,12 +94,12 @@ export const sendEvent = async (
       if (!isSuccess) {
         reject({
           statusCode: res?.statusCode as number,
-          statusMessage: "[KLEPPER] Error during sending event to Klepper.",
+          statusMessage: "[Traceo] Error during sending event to Traceo.",
         });
       } else {
         resolve({
           statusCode: res?.statusCode as number,
-          statusMessage: "[KLEPPER] Event successfully sended to Klepper.",
+          statusMessage: "[Traceo] Event successfully sended to Traceo.",
         });
       }
 
@@ -115,7 +113,7 @@ export const sendEvent = async (
       reject({
         statusCode: 400,
         statusMessage:
-          "[Klepper] Error during sending event to Klepper. Connection timeout.",
+          "[Traceo] Error during sending event to Traceo. Connection timeout.",
       });
     });
 

src/core/types/global.d.ts

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

src/index.ts

@@ -1,11 +1,11 @@
 import { Middleware, catchException } from "./node/middlewares";
-import * as Klepper from "./node/sdk";
+import * as Traceo from "./node/sdk";
 import { ExceptionPriority } from "./transport/enums";
 import { CatchExceptionsOptions } from "./transport/options";
 
 export {
   Middleware,
-  Klepper,
+  Traceo,
   catchException,
   CatchExceptionsOptions,
   ExceptionPriority,

src/node/helpers.ts

@@ -1,9 +1,9 @@
 import { BaseObject } from "../transport/base";
 import { Platform } from "../transport/events";
-import { KlepperIncomingMessage, KlepperRequest } from "../transport/http";
+import { TraceoIncomingMessage, TraceoRequest } from "../transport/http";
 import * as os from "os";
 
-export const mapRequestData = (req: BaseObject): KlepperRequest => {
+export const mapRequestData = (req: BaseObject): TraceoRequest => {
   const headersData = req.headers || req.header || {};
 
   const method = req.method;
@@ -16,7 +16,7 @@ export const mapRequestData = (req: BaseObject): KlepperRequest => {
   const origin = headersData["origin"];
   const query = req.query;
   const payload = req.body || {};
-  const ip = getIp(req as KlepperIncomingMessage);
+  const ip = getIp(req as TraceoIncomingMessage);
 
   const connections = {
     absoluteUrl,
@@ -43,20 +43,29 @@ export const mapRequestData = (req: BaseObject): KlepperRequest => {
 };
 
 export const getIp = (
-  req: KlepperIncomingMessage
+  req: TraceoIncomingMessage
 ): string | string[] | undefined => {
   return req.headers["x-forwarded-for"] || req.socket.remoteAddress;
 };
 
-export const getProtocol = (req: KlepperIncomingMessage): string => {
+export const getProtocol = (req: TraceoIncomingMessage): string => {
   return req.protocol === "https" || req.secure ? "https" : "http";
 };
 
 export const getOsPlatform = (): Platform => {
   return {
-      arch: os.arch(),
-      platform: os.platform(),
-      release: os.release(),
-      version: os.version(),
+    arch: os.arch(),
+    platform: os.platform(),
+    release: os.release(),
+    version: os.version(),
+  };
+};
+
+export const sanitizeDsn = (dsn: string) => {
+  const [secretKey, rest] = dsn.replace("https://", "").split(":");
+  const [host, appId] = rest.split("/");
+
+  return {
+    secretKey, host, appId
   }
 }

src/node/index.ts

@@ -1,4 +1,4 @@
 import { Middleware } from "..";
-import * as Klepper from "./sdk";
+import * as Traceo from "./sdk";
 
-export { Middleware, Klepper };
+export { Middleware, Traceo };

src/node/middlewares.ts

@@ -1,10 +1,10 @@
 import { sendEvent } from "../core/http";
 import { isClientConnected, isLocalhost } from "../core/is";
-import { KlepperError } from "../transport/base";
-import { KlepperEvent } from "../transport/events";
+import { TraceoError } from "../transport/base";
+import { TraceoEvent } from "../transport/events";
 import {
-  KlepperIncomingMessage,
-  KlepperServerResponse,
+  TraceoIncomingMessage,
+  TraceoServerResponse,
 } from "../transport/http";
 import {
   CatchExceptionsOptions,
@@ -38,10 +38,10 @@ import { prepareException } from "./parse";
  */
 const errorMiddleware = (options: ErrorMiddlewareOptions = {}) => {
   return async function errorMiddleware(
-    error: KlepperError,
-    req: KlepperIncomingMessage,
-    _res: KlepperServerResponse,
-    next: (error: KlepperError) => void
+    error: TraceoError,
+    req: TraceoIncomingMessage,
+    _res: TraceoServerResponse,
+    next: (error: TraceoError) => void
   ): Promise<void> {
     if (!isClientConnected()) {
       next(error);
@@ -57,7 +57,7 @@ const errorMiddleware = (options: ErrorMiddlewareOptions = {}) => {
 };
 
 const isToCatch = (
-  req: KlepperIncomingMessage,
+  req: TraceoIncomingMessage,
   options: ErrorMiddlewareOptions = {}
 ): boolean => {
   if (options.allowHttp !== undefined && !options.allowHttp) {
@@ -77,7 +77,7 @@ const isToCatch = (
 };
 
 interface Catch {
-  options?: CatchExceptionsOptions;
+  // options?: CatchExceptionsOptions;
   shouldBeCatched?: (error: any) => boolean;
 }
 
@@ -113,19 +113,19 @@ export const catchException = async (error: any, catchOptions?: Catch) => {
   }
 
   if (isClientConnected()) {
-    await handleException(error, undefined, catchOptions?.options);
+    await handleException(error, undefined);
   }
 
   return;
 };
 
 const handleException = async (
-  error: KlepperError,
-  req?: KlepperIncomingMessage,
+  error: TraceoError,
+  req?: TraceoIncomingMessage,
   options?: CatchExceptionsOptions
 ) => {
   try {
-    const event: KlepperEvent = await prepareException(error, options, req);
+    const event: TraceoEvent = await prepareException(error, options, req);
     await sendEvent(event);
   } catch (err) {
     //

src/node/parse.ts

@@ -1,11 +1,10 @@
 import { Trace } from "../transport/trace";
 import { promises, existsSync } from "fs";
-import { KlepperError } from "../transport/base";
+import { TraceoError } from "../transport/base";
 import { CatchExceptionsOptions } from "../transport/options";
-import { KlepperEvent } from "../transport/events";
-import { KlepperIncomingMessage } from "../transport/http";
+import { TraceoEvent } from "../transport/events";
+import { TraceoIncomingMessage } from "../transport/http";
 import { getOsPlatform, mapRequestData } from "./helpers";
-import * as os from "os";
 
 const FULL_MATCH =
   /at (?:async )?(?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/;
@@ -125,22 +124,22 @@ const readFileAsync = async (path: string): Promise<string> => {
 };
 
 export const prepareException = async (
-  error: KlepperError,
+  error: TraceoError,
   options?: CatchExceptionsOptions,
-  req?: KlepperIncomingMessage
-): Promise<KlepperEvent> => {
+  req?: TraceoIncomingMessage
+): Promise<TraceoEvent> => {
   const { message, name } = error;
 
   const platform = getOsPlatform();
 
   const traces = await parseStackTraces(String(error?.stack));
-  const event: KlepperEvent = {
+  const event: TraceoEvent = {
     type: name,
     message,
     traces,
     stack: String(error.stack),
     options,
-    platform
+    platform,
   };
 
   if (req !== undefined) {