@logmint/sdk 1.1.1

package/README.md

@@ -0,0 +1,87 @@
+# Hey there!
+## Welcome to LogMint SDK
+
+This SDK will help you log events directly on our cloud or in your local database just with the help of a few lines of code.
+
+### Local Setup
+- Install package using
+  `npm install @logmint/audit`
+
+- For local setup, just initailize and connect to your database:
+ ```js
+const { init, log } = require("@logmint/audit");
+const { Pool } = require("pg");
+
+await init({
+  db: {
+    client: new Pool({
+      host: "localhost",
+      user: "postgres",
+      password: "admin",
+      port: 5432,
+      database: "todo",
+    }),
+  },
+  mode: "local",
+});
+```
+
+The SDK will automatically create an **events** table if it does not exist in your database. If you want to manually create it, use the query:
+```sql
+CREATE TABLE IF NOT EXISTS events (
+  id SERIAL PRIMARY KEY,
+  event_type TEXT NOT NULL,
+  actor_id TEXT NOT NULL,
+  actor_name TEXT NOT NULL,
+  resource_id TEXT NOT NULL,
+  resource_type TEXT NOT NULL,
+  ip_address TEXT,
+  user_agent TEXT,
+  metadata JSONB,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+### Log events
+```js
+await log({
+  event_type: "user.paid.first.order",
+  actor_name: "shreya",
+  actor_id: "1",
+  resource_id: "#1",
+  resource_type: "mobile app",
+  metadata: { old_column: "old", new_column: "new" },
+});
+```
+### Cloud Setup
+- Install package using
+  `npm install @logmint/audit`
+```js
+const { init, log, flush } = require("@logmint/audit");
+
+await init({
+  mode: "cloud",
+  apiKey: "YOUR_API_KEY",
+  secretKey: "YOUR_SECRET_KEY",
+});
+```
+
+### Log events
+In place of URL, use `https://api.getlogmint.com`
+```js
+await log({
+  event_type: "user.paid.first.order",
+  actor_name: "shreya",
+  actor_id: "1",
+  resource_id: "#1",
+  resource_type: "mobile app",
+  metadata: { old_column: "old", new_column: "new" },
+}, `<URL>`);
+```
+If events fail to get logged, it will automatically get pushed to redis. You'll have to flush it out.(Recommended once a week).
+In place of URL, use `https://api.getlogmint.com`
+```js
+const { flush } = require("@logmint/audit");
+
+await flush(`<URL>`);
+```
+#### Contact us: support@getlogmint.com

package/cloud/addLogs.js

@@ -0,0 +1,108 @@
+const axios = require("axios");
+const { getConfig } = require("../core/config");
+let originalConsole = {};
+let buffer = { logs: [] };
+
+setInterval(() => {
+  if (buffer.logs.length > 0) {
+    const batch = [...buffer.logs];
+    buffer.logs = [];
+    addLogs({ logs: batch });
+  }
+}, 1000 * 60 * 10); // every 10 minutes
+
+
+const addLogs = async (logs) => {
+    
+    const config = getConfig();
+    const url = config.url;
+  
+  
+  try {
+    // verify api key and secret key
+    const result = await axios.post(
+      `${url}/api/sdk/verify`,
+      {
+        secret_key: config.secretKey,
+        api_key: config.apiKey,
+      },
+      {
+        headers: {
+          "Content-Type": "application/json",
+        },
+        validateStatus: () => true,
+      }
+    );
+
+    if (result.status != 200) {
+      console.log("Could not add log: ", result.data.msg);
+      return;
+    }
+    await axios.post(`${url}/api/logs/bulk`, logs, {
+      headers: {
+        "x-api-key": `${config.apiKey}`,
+        authorization: `Bearer ${config.secretKey}`,
+        "Content-Type": "application/json",
+      },
+      validateStatus: () => true,
+    });
+    console.log("logs added successfully! -", logs);
+  } catch (err) {
+    console.log(err);
+  }
+};
+
+function getStackInfo() {
+  const obj = {};
+  Error.captureStackTrace(obj, getStackInfo);
+  const stack = obj.stack.split("\n")[2];
+  const match = stack.match(/\((.*):(\d+):(\d+)\)$/);
+  if (!match) return {};
+  return { file: match[1], line: match[2], column: match[3] };
+}
+
+
+module.exports.overrideConsoleMethods = () => {
+  if (originalConsole.log) return;
+
+  originalConsole = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+  };
+
+  const capture = (level, args) => {
+    const message = args
+      .map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a)))
+      .join(" ");
+
+    const stack = getStackInfo();
+
+    buffer.logs.push({
+      level,
+      message,
+      metadata: {
+        timestamp: new Date().toISOString(),
+        ...stack,
+        hostname: require("os").hostname(),
+        pid: process.pid,
+      },
+    });
+  };
+
+  console.log = (...args) => {
+    originalConsole.log(...args);
+    capture("info", args);
+  };
+
+  console.warn = (...args) => {
+    originalConsole.warn(...args);
+    capture("warn", args);
+  };
+
+  console.error = (...args) => {
+    originalConsole.error(...args);
+    capture("error", args);
+  };
+};
+

package/cloud/addMetrics.js

@@ -0,0 +1,39 @@
+const axios = require("axios");
+const { getConfig } = require("../core/config");
+
+module.exports.addMetrics = async (metric) => {
+  const config = getConfig();
+  const url = config.url;
+  try {
+    // verify api key and secret key
+    const result = await axios.post(
+      `${url}/api/sdk/verify`,
+      {
+        secret_key: config.secretKey,
+        api_key: config.apiKey,
+      },
+      {
+        headers: {
+          "Content-Type": "application/json",
+        },
+        validateStatus: () => true,
+      }
+    );
+
+    if (result.status != 200) {
+      console.log("Could not add log: ", result.data.msg);
+      return;
+    }
+    await axios.post(`${url}/api/metrics`, metric, {
+      headers: {
+        "x-api-key": `${config.apiKey}`,
+        authorization: `Bearer ${config.secretKey}`,
+        "Content-Type": "application/json",
+      },
+      validateStatus: () => true,
+    });
+    console.log("metric added successfully! -", metric);
+  } catch (err) {
+    console.log(err);
+  }
+};

package/cloud/retryQueue.js

@@ -0,0 +1,43 @@
+// retryQueue.js
+const axios = require("axios");
+
+async function add(log, config) {
+  try {
+    const url = config.url;
+    await axios.post(
+      `${url}/api/redis/queue`,
+      { log, api_key: config.apiKey },
+      {
+        headers: {
+          "x-api-key": `${config.apiKey}`,
+          authorization: `Bearer ${config.secretKey}`,
+          "Content-Type": "application/json",
+        },
+        validateStatus: () => true,
+      }
+    );
+  } catch (error) {
+    console.log("Failed to add log to retry queue:", error);
+  }
+}
+
+async function flush(config) {
+  try {
+    const url = config.url;
+    const result = await axios.post(
+      `${url}/api/redis/flush`,
+      { api_key: config.apiKey, secret_key: config.secretKey },
+      {
+        headers: {
+          "Content-Type": "application/json",
+        },
+        validateStatus: () => true,
+      }
+    );
+    return result;
+  } catch (error) {
+    return { error: "Failed to flush queue:" + error};
+  }
+}
+
+module.exports = { add, flush };

package/cloud/sendToCloud.js

@@ -0,0 +1,48 @@
+const axios = require("axios");
+const { getConfig } = require("../core/config");
+const queue = require("./retryQueue");
+
+module.exports.sendToCloud = async (log, isFlush) => {
+  const config = getConfig();
+  const url = config.url;
+  try {
+    // verify api key and secret key
+    const result = await axios.post(
+      `${url}/api/sdk/verify`,
+      {
+        secret_key: config.secretKey,
+        api_key: config.apiKey,
+      },
+      {
+        headers: {
+          "Content-Type": "application/json",
+        },
+        validateStatus: () => true,
+      }
+    );
+    
+    if(result.status != 200) {
+      console.log("Could not add log: ", result.data.msg);
+      return;
+    }
+    await axios.post(`${url}/api/events`, log, {
+      headers: {
+        "x-api-key": `${config.apiKey}`,
+        authorization: `Bearer ${config.secretKey}`,
+        "Content-Type": "application/json",
+      },
+      validateStatus: () => true,
+    });
+    console.log("log added successfully! -", log);
+    
+  } catch (err) {
+    console.log(err);
+    
+    if(!isFlush) {
+      queue.add(log, config, url); // fallback to retry queue
+      console.log("added to retry queue");
+      
+    }
+    return new Error("Cloud send failed → queued");
+  }
+};

package/core/config.js

@@ -0,0 +1,62 @@
+let config = Object.freeze({
+  mode: "cloud",
+  apiKey: null,
+  db: null,
+  secretKey: null,
+  url: null
+});
+
+const VALID_MODES = ["local", "cloud"];
+
+/**
+ * Set SDK configuration.
+ * Only valid keys (`mode`, `db`, `apiKey`) are accepted.
+ * @param {Object} opts
+ * @param {"local"|"cloud"} [opts.mode]
+ * @param {string|Object} [opts.db]
+ * @param {string} [opts.apiKey]
+ * @param {string} [opts.secretKey]
+ * @param {string} [opts.url]
+ */
+module.exports.setConfig = (opts) => {
+  const newConfig = { ...config }; // start with existing config
+
+  // Only allow known keys
+  if ("mode" in opts) {
+    if (!VALID_MODES.includes(opts.mode)) {
+      throw new Error(
+        `Invalid mode "${opts.mode}". Must be "local" or "cloud".`
+      );
+    }
+    newConfig.mode = opts.mode;
+  }
+  if (opts.mode == VALID_MODES[0] && !opts.db) {
+    throw new Error("database connection string not provided for local mode");
+  } else {
+    newConfig.db = opts.db;
+  }
+  if (opts.mode == VALID_MODES[1]) {
+    if (!opts.apiKey) {
+      throw new Error("API key not provided for cloud mode");
+    } else {
+      newConfig.apiKey = opts.apiKey;
+      if (!opts.secretKey) {
+        throw new Error("Secret Key not provided for cloud mode");
+      }
+      newConfig.secretKey = opts.secretKey;
+      if (!opts.url) {
+        throw new Error("URL not provided");
+      }
+      // ensure it starts with http/https
+      if (!/^https?:\/\//i.test(opts.url) || typeof opts.url !== "string" || opts.url.trim().length === 0) {
+        throw new Error("Invalid URL");
+      }
+      newConfig.url = opts.url;
+    }
+  }
+
+  // Freeze to prevent accidental mutation
+  config = Object.freeze(newConfig);
+};
+
+module.exports.getConfig = () => config;

package/core/validator.js

@@ -0,0 +1,7 @@
+module.exports.validateLog = (log) => {
+  if (!log.event_type) throw new Error("event_type required");
+  if (!log.actor_id) throw new Error("actor_id required");
+  if (!log.actor_name) throw new Error("actor_name required");
+  if (!log.resource_id) throw new Error("resource_id required");
+  if (!log.resource_type) throw new Error("resource_type required");
+};

package/index.js

@@ -0,0 +1,136 @@
+const { setConfig, getConfig } = require("./core/config");
+const { validateLog } = require("./core/validator");
+
+const { initLocal } = require("./local/initLocal");
+const { writeLocal } = require("./local/writeLocal");
+
+const { sendToCloud } = require("./cloud/sendToCloud");
+const retryQueue = require("./cloud/retryQueue");
+const { addMetrics } = require("./cloud/addMetrics");
+const { overrideConsoleMethods } = require("./cloud/addLogs");
+
+let pool = null;
+/**
+ * Initializes the Audit SDK.
+ *
+ * @typedef {Object} Config - Initialization options.
+ * @property {"local"|"cloud"} mode - Current mode.
+ * @property {string | Object} [db] - Database URL string or a database config object.
+ * @property {Object} db.client - A database client/pool instance (e.g., new Pool()).
+ * @property {string} [apiKey] - API key for cloud mode.
+ * @property {string} [secretKey] - Secret key for cloud mode.
+ * @property {string} [url] - URL for cloud mode
+ *
+ */
+
+/**
+ * Initializes the Audit SDK.
+ *
+ * @param {Config} options - Initialization options.
+ * @example
+ * // Local mode
+ * init({
+ *   mode: "local",
+ *   db: { client: new Pool({ connectionString: "postgres://..." }) }
+ * });
+ *
+ * @example
+ * // Cloud mode
+ * init({
+ *   mode: "cloud",
+ *   apiKey: "my-project-api-key"
+ * });
+ */
+module.exports.init = async (options) => {
+  try {
+    setConfig(options);
+
+    const config = getConfig();
+
+    if (config.mode === "local") {
+      pool = await initLocal(config);
+    }
+    else{
+      overrideConsoleMethods();
+    }
+
+    console.log(`Audit log SDK initialized in ${config.mode} mode`);
+  } catch (error) {
+    throw new Error(error);
+  }
+};
+
+/**
+ * @typedef {Object} AuditLog
+ * @property {string} project_id - Project ID (needed if config.mode is 'local')
+ * @property {string} event_type - Event type.
+ * @property {string} actor_id - Actor ID.
+ * @property {string} actor_name - Actor name.
+ * @property {string} resource_id - Resource ID.
+ * @property {string} resource_type - Resource type.
+ * @property {string} [user_agent] - User agent.
+ * @property {string} [ip_address] - IP address.
+ * @property {Object} metdata - Metadata.
+ */
+/**
+ * @param {AuditLog} log
+ */
+module.exports.log = async (log) => {
+  try {
+    validateLog(log);
+
+    const config = getConfig();
+
+    if (config.mode === "local") {
+      await writeLocal(pool, log);
+    }
+
+    if (config.mode === "cloud") {
+      await sendToCloud(log, false);
+    }
+  } catch (error) {
+    throw new Error(error);
+  }
+};
+
+/**
+ * Flushes pending logs.
+ * Processes any logs stored in the retry queue and attempts
+ * to send them again (only in cloud mode).
+ * @returns {Object} summary - If mode is "cloud", it returns a summary of
+ * logs sent, requeued and dead
+ */
+module.exports.flush = async () => {
+  try {
+    const config = getConfig();
+
+    if (config.mode === "cloud") {
+      const summary = await retryQueue.flush(config);
+      return summary;
+    }
+  } catch (error) {
+    throw new Error("Could not execute flush");
+  }
+};
+
+/**
+ * @typedef {Object} Metric
+ * @property {string} name - metric name.
+ * @property {string} value - value.
+ * @property {string} type - ["gauge", "counter", "histogram"].
+ * @property {Object} tags - tags.
+ */
+/**
+ * @param {Metric} metric
+ */
+module.exports.addMetric = async (metric) => {
+  try {
+    const config = getConfig();
+
+    if (config.mode === "cloud") {
+      await addMetrics(metric);
+    }
+  } catch (error) {
+    throw new Error("Could not add metric");
+  }
+};

package/local/initLocal.js

@@ -0,0 +1,12 @@
+const fs = require("fs");
+
+module.exports.initLocal = async (config) => {
+  const pool = config.db.client;
+  const migration = fs.readFileSync(__dirname + "/migration.sql", "utf8");
+  try {
+    await pool.query(migration);
+    return pool;
+  } catch (error) {
+    throw new Error("Error in initializing Audit SDK. Could not connect to database.");
+  }
+};

package/local/migration.sql

@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS events (
+id SERIAL PRIMARY KEY,
+event_type TEXT NOT NULL,
+actor_id TEXT NOT NULL,
+actor_name TEXT NOT NULL,             
+resource_id TEXT NOT NULL,
+resource_type TEXT NOT NULL,
+ip_address TEXT,
+user_agent TEXT,
+metadata JSONB, 
+created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);

package/local/writeLocal.js

@@ -0,0 +1,30 @@
+module.exports.writeLocal = async (pool, log) => {
+  const client = await pool.connect();
+
+  try {
+    await client.query("BEGIN");
+
+    await client.query(
+      `INSERT INTO events (event_type, actor_id, actor_name, resource_id, resource_type, ip_address, user_agent, metadata)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+      [
+        log.event_type,
+        log.actor_id,
+        log.actor_name,
+        log.resource_id,
+        log.resource_type,
+        log.ip_address || null,
+        log.user_agent || null,
+        log.metadata || {}
+      ]
+    );
+
+    await client.query("COMMIT");
+    console.log("logged successfully! -", log)
+  } catch (err) {
+    await client.query("ROLLBACK");
+    throw err;
+  } finally {
+    client.release();
+  }
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@logmint/sdk",
+  "version": "1.1.1",
+  "description": "LogMint SDK for sending audit logs, metrics, application logs",
+  "main": "index.js",
+  "type": "commonjs",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "logmint",
+    "audit",
+    "logs",
+    "sdk", 
+    "monitor", 
+    "metrics"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/this-is-shreya/logmint-audit-sdk.git"
+  },
+  "author": "Shreya Srivastava",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.13.2"
+  },
+  "files": [
+    "index.js",
+    "core",
+    "cloud",
+    "local"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}