@syswatch/core 1.0.0

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./client"), exports);

package/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/*.spec.ts'],
+};

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@syswatch/core",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/src/client.spec.ts

@@ -0,0 +1,164 @@
+import { SysWatch } from "./client";
+import { LogLevel } from "./types";
+import { Logs } from "./logs";
+
+// Mock global fetch
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+
+describe("SysWatch", () => {
+  const apiKey = "test-api-key";
+  const defaultBaseUrl = "http://localhost:8080/v1";
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ success: true }),
+    });
+  });
+
+  describe("Constructor", () => {
+    it("should initialize with default base URL", () => {
+      const client = new SysWatch({ apiKey });
+      expect(client["baseUrl"]).toBe(defaultBaseUrl);
+      expect(client.log).toBeInstanceOf(Logs);
+    });
+
+    it("should store default meta and tags", () => {
+      const defaultMeta = { app: "test" };
+      const defaultTags = ["test-env"];
+      const client = new SysWatch({
+        apiKey,
+        defaultMeta,
+        defaultTags,
+        environment: "staging",
+      });
+
+      expect(client["defaultMeta"]).toEqual(defaultMeta);
+      expect(client["defaultTags"]).toEqual(defaultTags);
+    });
+  });
+
+  describe("sendLog (via log property)", () => {
+    let client: SysWatch;
+
+    beforeEach(() => {
+      client = new SysWatch({ apiKey });
+    });
+
+    it("should send info log", async () => {
+      await client.log.info("Info message", { meta: { foo: "bar" } });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        `${defaultBaseUrl}/logs`,
+        expect.objectContaining({
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+          },
+          body: expect.stringContaining('"level":"INFO"'),
+        })
+      );
+
+      const call = mockFetch.mock.calls[0];
+      const body = JSON.parse(call[1].body);
+      expect(body.type).toBe("info");
+      expect(body.message).toBe("Info message");
+      expect(body.meta).toEqual({ foo: "bar" });
+    });
+
+    it("should send error log from Error object", async () => {
+      const error = new Error("Something went wrong");
+      error.stack = "Error stack trace";
+
+      await client.log.error("Failure", error);
+
+      const call = mockFetch.mock.calls[0];
+      const body = JSON.parse(call[1].body);
+      expect(body.level).toBe("ERROR");
+      expect(body.meta.error).toEqual({
+        name: "Error",
+        message: "Something went wrong",
+        stack: "Error stack trace",
+      });
+    });
+
+    it("should send error log from options object", async () => {
+      await client.log.error("Failure", { meta: { code: 500 } });
+
+      const call = mockFetch.mock.calls[0];
+      const body = JSON.parse(call[1].body);
+      expect(body.meta.code).toBe(500);
+      expect(body.level).toBe("ERROR");
+    });
+  });
+
+  describe("trackMetric", () => {
+    let client: SysWatch;
+
+    beforeEach(() => {
+      client = new SysWatch({ apiKey });
+    });
+
+    it("should send metric request correctly", async () => {
+      await client.trackMetric("cpu_usage", 80, "%");
+
+      expect(mockFetch).toHaveBeenCalledWith(`${defaultBaseUrl}/metrics`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+        },
+        body: expect.any(String),
+      });
+
+      const call = mockFetch.mock.calls[0];
+      const body = JSON.parse(call[1].body);
+      expect(body).toEqual({
+        type: "cpu_usage",
+        value: 80,
+        unit: "%",
+        meta: {},
+        tags: [],
+      });
+    });
+
+    it("should merge default meta and tags for metrics", async () => {
+      client = new SysWatch({
+        apiKey,
+        defaultMeta: { host: "server-1" },
+        defaultTags: ["prod"],
+      });
+
+      await client.trackMetric("memory", 1024, "MB", { tags: ["worker"] });
+
+      const call = mockFetch.mock.calls[0];
+      const body = JSON.parse(call[1].body);
+      expect(body.meta).toEqual({ host: "server-1" });
+      expect(body.tags).toEqual(["prod", "worker"]);
+    });
+  });
+
+  describe("Error Handling", () => {
+    let client: SysWatch;
+
+    beforeEach(() => {
+      client = new SysWatch({ apiKey });
+    });
+
+    it("should throw error when API returns non-200", async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 401,
+        statusText: "Unauthorized",
+        text: async () => "Invalid API Key",
+      });
+
+      await expect(client.log.info("test")).rejects.toThrow(
+        "SysWatch API Error: 401 Unauthorized - Invalid API Key"
+      );
+    });
+  });
+});

package/src/client.ts

@@ -0,0 +1,94 @@
+import { Logs } from "./logs";
+import { CreateLogDto, CreateMetricDto } from "./types";
+
+export interface SysWatchConfig {
+  apiKey: string;
+  defaultMeta?: Record<string, any>;
+  defaultTags?: string[];
+  environment?: string;
+}
+
+export class SysWatch {
+  private apiKey: string;
+  private baseUrl: string;
+  private defaultMeta: Record<string, any>;
+  private defaultTags: string[];
+
+  public log: Logs;
+
+  constructor(config: SysWatchConfig) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = "https://syswatchapp.discloud.app/v1";
+    this.defaultMeta = config.defaultMeta || {};
+    this.defaultTags = config.defaultTags || [];
+
+    if (this.baseUrl.endsWith("/")) {
+      this.baseUrl = this.baseUrl.slice(0, -1);
+    }
+
+    this.log = new Logs(this.sendLog.bind(this));
+  }
+
+  private async request(path: string, body: any) {
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey,
+          "user-agent": "NodeJS SysWatch SDK ",
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `SysWatch API Error: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+
+      return await response.json();
+    } catch (error) {
+      // Re-throw the error to let the caller handle it
+      throw error;
+    }
+  }
+
+  /**
+   * Send a log entry to SysWatch
+   * @param data Log data
+   */
+  async sendLog(data: CreateLogDto) {
+    const payload: CreateLogDto = {
+      ...data,
+      meta: { ...this.defaultMeta, ...data.meta },
+      tags: [...this.defaultTags, ...(data.tags || [])],
+    };
+    return this.request("/logs", payload);
+  }
+
+  /**
+   * Track a metric value
+   * @param type Metric type key
+   * @param value Metric value
+   * @param unit Unit of measurement (optional)
+   * @param options Additional options
+   */
+  async trackMetric(
+    type: string,
+    value: number,
+    unit?: string,
+    options?: Omit<CreateMetricDto, "type" | "value" | "unit">
+  ) {
+    const payload: CreateMetricDto = {
+      type,
+      value,
+      unit,
+      ...options,
+      meta: { ...this.defaultMeta, ...options?.meta },
+      tags: [...this.defaultTags, ...(options?.tags || [])],
+    };
+    return this.request("/metrics", payload);
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './client';

package/src/logs.ts

@@ -0,0 +1,127 @@
+import { CreateLogDto, LogLevel } from "./types";
+
+type LogOptions = Omit<CreateLogDto, "level" | "message" | "type"> & {
+  type?: string;
+};
+
+export class Logs {
+  constructor(private sendLog: (log: CreateLogDto) => Promise<void>) {}
+
+  /**
+   * Send a DEBUG log
+   * @param message Log message
+   * @param options Additional options (meta, tags, etc.)
+   */
+  async debug(message: string, options?: LogOptions) {
+    return this.sendLog({
+      type: "debug",
+      level: LogLevel.DEBUG,
+      message,
+      ...options,
+    });
+  }
+
+  /**
+   * Send an INFO log
+   * @param message Log message
+   * @param options Additional options (meta, tags, etc.)
+   */
+  async info(message: string, options?: LogOptions) {
+    return this.sendLog({
+      type: "info",
+      level: LogLevel.INFO,
+      message,
+      ...options,
+    });
+  }
+
+  /**
+   * Send a SUCCESS log
+   * @param message Log message
+   * @param options Additional options (meta, tags, etc.)
+   */
+  async success(message: string, options?: LogOptions) {
+    return this.sendLog({
+      type: "success",
+      level: LogLevel.SUCCESS,
+      message,
+      ...options,
+    });
+  }
+  /**
+   * Send a FAILURE log
+   * @param message Log message
+   * @param options Additional options (meta, tags, etc.)
+   */
+  async failure(message: string, options?: LogOptions) {
+    return this.sendLog({
+      type: "failure",
+      level: LogLevel.FAILURE,
+      message,
+      ...options,
+    });
+  }
+
+  /**
+   * Send a WARN log
+   * @param message Log message
+   * @param options Additional options (meta, tags, etc.)
+   */
+  async warn(message: string, options?: LogOptions) {
+    return this.sendLog({
+      type: "warn",
+      level: LogLevel.WARN,
+      message,
+      ...options,
+    });
+  }
+
+  /**
+   * Send an ERROR log with smart error handling
+   * @param message Log message
+   * @param errorOrOptions Error object or options object
+   */
+  async error(
+    message: string,
+    errorOrOptions?:
+      | Error
+      | (Omit<CreateLogDto, "level" | "message" | "type"> & { type?: string })
+  ) {
+    let meta = {};
+    let options: Partial<CreateLogDto> = {};
+
+    if (errorOrOptions instanceof Error) {
+      meta = {
+        error: {
+          name: errorOrOptions.name,
+          message: errorOrOptions.message,
+          stack: errorOrOptions.stack,
+        },
+      };
+    } else if (errorOrOptions) {
+      options = errorOrOptions;
+    }
+
+    return this.sendLog({
+      type: "error",
+      level: LogLevel.ERROR,
+      message,
+      ...options,
+      meta: { ...meta, ...(options.meta || {}) },
+    });
+  }
+
+  /**
+   * Send a CRITICAL log
+   * @param message Log message
+   * @param options Additional options (meta, tags, etc.)
+   */
+  async critical(message: string, options?: LogOptions) {
+    return this.sendLog({
+      type: "critical",
+      level: LogLevel.CRITICAL,
+      message,
+      ...options,
+    });
+  }
+}

package/src/types.ts

@@ -0,0 +1,31 @@
+export enum LogLevel {
+  DEBUG = 'DEBUG',
+  INFO = 'INFO',
+  SUCCESS = 'SUCCESS',
+  FAILURE = 'FAILURE',
+  WARN = 'WARN',
+  ERROR = 'ERROR',
+  CRITICAL = 'CRITICAL',
+}
+
+export interface CreateLogDto {
+  type: string;
+  level: LogLevel;
+  message?: string;
+  meta?: Record<string, any>;
+  environment?: string;
+  userId?: string;
+  ip?: string;
+  timestamp?: Date | string;
+  tags?: string[];
+}
+
+export interface CreateMetricDto {
+  type: string;
+  value: number;
+  meta?: Record<string, any>;
+  environment?: string;
+  timestamp?: Date | string;
+  tags?: string[];
+  unit?: string;
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}