runtime feature

Author: piotrek98

lib/core/global.ts

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

lib/core/http.ts

@@ -1,6 +1,6 @@
 import * as http from "http";
 import { sanitizeDsn } from "../node/helpers";
-import { EventResponse, TraceoEvent } from "../transport/events";
+import { EventResponse, Incident } from "../transport/events";
 import { TraceoIncomingMessage, RequestOptions } from "../transport/http";
 import { getGlobalClientData } from "./global";
 import { isClientConnected } from "./is";
@@ -11,51 +11,71 @@ enum RequestStatus {
   ERROR = "error",
 }
 
-const createHttpOptions = ({
-  event,
-}: {
-  event?: TraceoEvent;
-}): http.RequestOptions => {
+const createHttpOptions = (path: string): http.RequestOptions => {
   const client = getGlobalClientData();
 
   const { dsn } = client;
-  const { host, secretKey, appId } = sanitizeDsn(dsn);
+  const { host, secretKey } = sanitizeDsn(dsn);
 
   const baseOptions: RequestOptions = {
     hostname: host,
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      "Content-Length": `${Buffer.byteLength(JSON.stringify(event))}`,
       "Traceo-Secret-Key": secretKey,
     },
   };
 
   return {
-    path: `/${appId}`,
+    path,
     ...baseOptions,
   };
 };
 
 const statusFromCode = (code: number) =>
   code >= 200 && code <= 299 ? RequestStatus.SUCCESS : RequestStatus.ERROR;
 
-export const sendEvent = async (
-  event: TraceoEvent
-): Promise<EventResponse | void> => {
-  const { environment, dsn } = getGlobalClientData();
+export const sendRuntimeMetrics = async (data: {}) => {
+  const { appId, environment } = getGlobalClientData();
 
-  if (!environment || !dsn) {
+  if (!appId) {
+    return;
+  }
+
+  const httpOptions = createHttpOptions(
+    `/${appId}/${environment}/metrics/runtime`
+  );
+  await sendEvent(data, httpOptions);
+};
+
+export const sendIncidentEvent = async (incident: Incident) => {
+  const { environment, appId } = getGlobalClientData();
+
+  if (!environment || !appId) {
     return;
   }
 
   const version = TRACEO_SDK_VERSION;
   const baseData = { version, env: environment };
 
-  const payload = Object.assign(event, baseData);
+  const payload = Object.assign(incident, baseData);
+
+  const httpOptions = createHttpOptions(`/${appId}`);
+  await sendEvent(payload, httpOptions);
+};
+
+export const sendEvent = async (
+  payload: any,
+  httpOptions: http.RequestOptions
+): Promise<EventResponse | void> => {
+  const { environment, dsn } = getGlobalClientData();
+
+  if (!environment || !dsn) {
+    return;
+  }
 
   return new Promise<EventResponse>((resolve, reject) => {
-    const httpOptions = createHttpOptions({ event });
+    // const httpOptions = createHttpOptions({ payload });
     if (!httpOptions) {
       reject({
         statusCode: 400,

lib/node/metrics.ts

@@ -0,0 +1,105 @@
+import * as os from "os";
+import * as v8 from "v8";
+import { sendRuntimeMetrics } from "../core/http";
+
+const sanitizePackageName = (pkg: string, pkgType: string) => {
+  let targetKey = pkg.replace(pkgType, "").replace("__", "@");
+  if (targetKey.includes("@")) {
+    const [lib, pkg] = targetKey.split("_");
+    targetKey = `${lib}/${pkg}`;
+  }
+
+  targetKey = targetKey.replace("_", "").replace("_", "-");
+
+  return targetKey;
+};
+
+const collectMetricsDataOnRuntime = () => {
+  const traceoVersion =
+    process.env["npm_package_dependencies_traceo"] ||
+    process.env["npm_package_devDependencies_traceo"];
+
+  const packageEngineNode = process.env["npm_package_engines_node"];
+  const packageName = process.env["npm_package_name"];
+  const packageDescription = process.env["npm_package_description"];
+  const packageVersion = process.env["npm_package_version"];
+
+  const dependencies = {};
+  const devDependencies = {};
+  const scripts = {};
+
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key?.startsWith("npm_package_dependencies_")) {
+      const targetKey = sanitizePackageName(key, "npm_package_dependencies");
+      dependencies[targetKey] = value;
+    }
+
+    if (key?.startsWith("npm_package_devDependencies_")) {
+      const targetKey = sanitizePackageName(key, "npm_package_devDependencies");
+      devDependencies[targetKey] = value;
+    }
+
+    if (key?.startsWith("npm_package_scripts_")) {
+      const targetKey = key.replace("npm_package_scripts_", "");
+      scripts[targetKey] = value;
+    }
+  }
+
+  const osDataToScrap = [
+    "arch",
+    "platform",
+    "release",
+    "version",
+    "homedir",
+    "tmpdir",
+    "type",
+    "hostname",
+  ];
+  const osData = {};
+  for (const [key, _] of Object.entries(os)) {
+    if (osDataToScrap.includes(key)) {
+      osData[key] = os[key]();
+    }
+  }
+
+  const heap = {};
+  for (const [key, value] of Object.entries(v8.getHeapCodeStatistics())) {
+    heap[key] = value;
+  }
+
+  const heapStats = v8.getHeapStatistics();
+  const heapStatistics = {
+    heap_size_limit: heapStats.heap_size_limit,
+    total_heap_size_executable: heapStats.total_heap_size_executable,
+    total_physical_size: heapStats.total_physical_size,
+  };
+
+  const nodeVersion = process.versions;
+
+  const data = {
+    node: {
+      ...heap,
+      ...heapStatistics,
+      ...nodeVersion,
+    },
+    os: osData,
+    scripts,
+    dependencies,
+    devDependencies,
+    npm: {
+      packageEngineNode,
+      packageName,
+      packageDescription,
+      packageVersion,
+    },
+    traceo: {
+      version: traceoVersion,
+    },
+  };
+
+  sendRuntimeMetrics(data);
+};
+
+export const metrics = {
+  collectMetricsDataOnRuntime,
+};

lib/node/middlewares.ts

@@ -1,8 +1,8 @@
 import { stacktrace } from "stacktrace-parser-node";
-import { sendEvent } from "../core/http";
+import { sendEvent, sendIncidentEvent } from "../core/http";
 import { isClientConnected, isLocalhost } from "../core/is";
 import { TraceoError } from "../transport/base";
-import { TraceoEvent } from "../transport/events";
+import { Incident } from "../transport/events";
 import { TraceoIncomingMessage, TraceoServerResponse } from "../transport/http";
 import { ErrorMiddlewareOptions } from "../transport/options";
 import { getIp, getOsPlatform, getProtocol } from "./helpers";
@@ -113,19 +113,19 @@ export const catchException = async (error: any, catchOptions?: Catch) => {
 
 const handleException = async (error: TraceoError) => {
   try {
-    const event: TraceoEvent = await prepareException(error);
-    await sendEvent(event);
+    const event: Incident = await prepareException(error);
+    await sendIncidentEvent(event);
   } catch (err) {
     //
   }
 };
 
-const prepareException = async (error: TraceoError): Promise<TraceoEvent> => {
+const prepareException = async (error: TraceoError): Promise<Incident> => {
   const { stack } = error;
   const platform = getOsPlatform();
 
   const { message, name, traces } = await stacktrace.parse(error);
-  const event: TraceoEvent = {
+  const event: Incident = {
     type: name,
     message,
     traces,

lib/node/process.ts

@@ -0,0 +1,31 @@
+// const getCpuUsage = () => process.cpuUsage();
+
+// const getMemoryUsage = () => process.memoryUsage();
+
+// // The process.platform property returns a string identifying
+// // the operating system platform for which the Node.js binary was compiled
+// const osPlatform = process.platform;
+// const resourceUsage = process.resourceUsage();
+// const internalNodeVersions = process.versions;
+
+// interface Envs {
+//     traceo: string;
+// }
+
+// interface Version {
+//     node: string,
+//     v8: string,
+//     uv: string,
+//     zlib: string,
+//     brotli: string,
+//     ares: string,
+//     modules: string,
+//     nghttp2: string,
+//     napi: string,
+//     llhttp: string,
+//     openssl: string,
+//     cldr: string,
+//     icu: string,
+//     tz: string,
+//     unicode: string
+// }

lib/node/sdk.ts

@@ -1,6 +1,7 @@
 import { setGlobalClientData } from "../core/global";
 import { isClientConnected } from "../core/is";
 import { TraceoOptions } from "../transport/options";
+import { metrics } from "./metrics";
 
 /**
  *
@@ -27,4 +28,8 @@ export const init = (options: TraceoOptions): void => {
       ...options,
     });
   }
+
+  metrics.collectMetricsDataOnRuntime();
 };
+
+export const collectMetricsData = () => {};

lib/node/v8.ts

@@ -0,0 +1,21 @@
+import * as v8 from "v8";
+
+/**
+ * https://www.geeksforgeeks.org/node-js-v8-getheapstatistics-method/
+ *
+ */
+const getHeapStatistics = () => v8.getHeapStatistics();
+
+const getUsedHeapSize = () => getHeapStatistics().used_heap_size;
+
+const getNumberOfNativeContexts = () =>
+  getHeapStatistics().number_of_native_contexts;
+
+const getNumberOfDetachedContexts = () =>
+  getHeapStatistics().number_of_detached_contexts;
+
+export const v8Metrics = {
+  usedHeapSize: getUsedHeapSize(),
+  numberOfNativeContexts: getNumberOfNativeContexts(),
+  numberOfDetachedContexts: getNumberOfDetachedContexts(),
+};

lib/transport/base.ts

@@ -1,9 +1,9 @@
 import { Environment } from "./types";
 
 export interface TraceoGlobal {
-  dsn: string;
-  appId?: string;
-  environment: Environment;
+  dsn?: string;
+  appId?: number;
+  environment?: Environment;
 }
 
 export interface TraceoError extends Error {}

lib/transport/events.ts

@@ -7,7 +7,7 @@ export interface EventResponse {
   body?: string;
 }
 
-export interface TraceoEvent {
+export interface Incident {
   type: string;
   message: string;
   stack: string;

lib/transport/options.ts

@@ -4,6 +4,7 @@ export interface TraceoOptions {
   offline?: boolean;
   environment: Environment;
   dsn: string;
+  appId: number;
 }
 
 export interface ErrorMiddlewareOptions {