@orbitai/orbitrace 1.1.0

package/README.md

@@ -0,0 +1,202 @@
+# @orbitai/orbitrace
+
+Error tracking and monitoring for Node.js and browser applications.
+
+## Installation
+
+```bash
+npm install @orbitai/orbitrace
+```
+
+## Backend Setup
+
+### 1. Initialize Orbitrace
+
+```javascript
+// orbitrace.js
+const Orbitrace = require("@orbitai/orbitrace");
+
+function getOrbitraceInstance({ service }) {
+	console.log("Initializing Orbitrace for service:", service);
+
+	Orbitrace.getInstance({
+		apiKey: process.env.ORBITRACE_API_KEY,
+		orgId: process.env.ORBITRACE_ORG_ID,
+		projectId: process.env.ORBITRACE_PROJECT_ID,
+		endpoint: process.env.ORBITRACE_ENDPOINT,
+		environment: process.env.APP_ENV,
+		service,
+		version: process.env.APP_VERSION,
+	});
+
+	return Orbitrace;
+}
+
+module.exports = {
+	getOrbitraceInstance,
+};
+```
+
+### 2. Usage
+
+```javascript
+const { getOrbitraceInstance } = require("/path/to/orbitrace");
+const orbitrace = getOrbitraceInstance({ service: "api" });
+
+// Capture exceptions
+try {
+	// Your code here
+} catch (error) {
+	await orbitrace.captureException(error, {
+		endpoint: "/users",
+	});
+}
+
+// Capture messages
+await orbitrace.captureMessage("User registered", {
+	userId: "123",
+	email: "user@example.com",
+});
+```
+
+## Frontend Setup (Vue 3 + Pinia)
+
+### 1. Initialize Orbitrace
+
+```javascript
+// orbitrace.js
+import { provide, inject } from "vue";
+import Orbitrace from "@orbitai/orbitrace";
+
+export const ORBITRACE_KEY = Symbol("orbitrace");
+
+export function getOrbitraceInstance({ service }) {
+	Orbitrace.getInstance({
+		apiKey: import.meta.env.VITE_ORBITRACE_API_KEY,
+		orgId: import.meta.env.VITE_ORBITRACE_ORG_ID,
+		projectId: import.meta.env.VITE_ORBITRACE_PROJECT_ID,
+		endpoint: import.meta.env.VITE_ORBITRACE_ENDPOINT,
+		environment: import.meta.env.VITE_APP_ENV,
+		service,
+		version: import.meta.env.VITE_APP_VERSION,
+	});
+
+	return orbitrace;
+}
+
+export function useOrbitrace() {
+	const orbitrace = inject(ORBITRACE_KEY);
+	if (!orbitrace) {
+		throw new Error("Orbitrace not properly initialized");
+	}
+	return orbitrace;
+}
+```
+
+### 2. Setup in Main App
+
+```javascript
+// main.js
+import { createApp } from "vue";
+import { createPinia } from "pinia";
+import App from "./App.vue";
+import { getOrbitraceInstance, ORBITRACE_KEY } from "/path/to/orbitrace";
+
+const app = createApp(App);
+const pinia = createPinia();
+
+// Initialize Orbitrace
+const orbitrace = getOrbitraceInstance({ service: "webapp" });
+
+// Make Orbitrace available everywhere
+app.provide(ORBITRACE_KEY, orbitrace);
+
+// Add Orbitrace to Pinia
+pinia.use(({ store }) => {
+	store.orbitrace = orbitrace;
+});
+
+app.use(pinia);
+app.mount("#app");
+```
+
+### 3. Usage in Vue Components
+
+```vue
+<script setup>
+import { useOrbitrace } from "/path/to/orbitrace";
+
+const orbitrace = useOrbitrace();
+
+async function handleUserAction() {
+	try {
+		// Your code here
+	} catch (error) {
+		await orbitrace.captureException(error, {
+			component: "UserProfile",
+			action: "updateProfile",
+		});
+	}
+}
+
+// Log custom events
+async function trackEvent() {
+	await orbitrace.captureMessage("User completed onboarding", {
+		userId: "user123",
+		completedSteps: ["profile", "preferences"],
+	});
+}
+</script>
+```
+
+### 4. Usage in Pinia Stores
+
+```javascript
+// stores/userStore.js
+import { defineStore } from "pinia";
+
+export const useUserStore = defineStore("user", {
+	state: () => ({
+		user: null,
+	}),
+	actions: {
+		async fetchUser() {
+			try {
+				// Fetch user logic
+			} catch (error) {
+				await this.orbitrace.captureException(error, {
+					store: "userStore",
+					action: "fetchUser",
+				});
+				throw error;
+			}
+		},
+	},
+});
+```
+
+### Environment Variables
+
+For Vite:
+
+```env
+VITE_ORBITRACE_API_KEY=your-api-key
+VITE_ORBITRACE_ORG_ID=your-org-id
+VITE_ORBITRACE_PROJECT_ID=your-project-id
+VITE_ORBITRACE_ENDPOINT=your-endpoint
+VITE_APP_ENV=your-environment
+VITE_APP_VERSION=your-version
+```
+
+For Node.js:
+
+```env
+ORBITRACE_API_KEY=your-api-key
+ORBITRACE_ORG_ID=your-org-id
+ORBITRACE_PROJECT_ID=your-project-id
+ORBITRACE_ENDPOINT=your-endpoint
+APP_ENV=your-environment
+APP_VERSION=your-version
+```
+
+

package/dist/index.js

@@ -0,0 +1,117 @@
+class Orbitrace {
+	static #config = null;
+
+	static getInstance(config) {
+		this.validateConfig(config);
+
+		this.#config = {
+			apiKey: config.apiKey,
+			orgId: config.orgId,
+			projectId: config.projectId,
+			endpoint: config.endpoint,
+			environment: config.environment || "production",
+			version: config.version || "1.0.0",
+			service: config.service || "not-specified",
+			disabled: config.disabled || false,
+		};
+	}
+
+	static validateConfig(config) {
+		const requiredFields = ["apiKey", "orgId", "projectId", "endpoint"];
+		const missingFields = requiredFields.filter((field) => !config[field]);
+
+		if (missingFields.length > 0) {
+			throw new Error(
+				`Missing required configuration fields: ${missingFields.join(", ")}`
+			);
+		}
+	}
+
+	static checkInitialized() {
+		if (!this.#config) {
+			throw new Error(
+				"Orbitrace must be initialized with Orbitrace.getInstance() before use"
+			);
+		}
+	}
+
+	static async captureException(error, metadata = {}) {
+		this.checkInitialized();
+
+		if (this.#config.disabled) {
+			console.log("Orbitrace: Logging is disabled");
+			return;
+		}
+
+		try {
+			const payload = {
+				message: error.message,
+				stack: error.stack,
+				metadata: {
+					...metadata,
+					env: this.#config.environment,
+					version: this.#config.version,
+					service: this.#config.service,
+				},
+			};
+
+			return this.sendToApi("capture_exception", payload);
+		} catch (err) {
+			console.error("Orbitrace: Error capturing exception", err);
+		}
+	}
+
+	static async captureMessage(message, metadata = {}) {
+		this.checkInitialized();
+
+		if (this.#config.disabled) {
+			console.log("Orbitrace: Logging is disabled");
+			return;
+		}
+
+		try {
+			const payload = {
+				message,
+				metadata: {
+					...metadata,
+					env: this.#config.environment,
+					version: this.#config.version,
+					service: this.#config.service,
+				},
+			};
+
+			return this.sendToApi("capture_message", payload);
+		} catch (err) {
+			console.error("Orbitrace: Error capturing message", err);
+		}
+	}
+
+	static async sendToApi(event, payload) {
+		try {
+			const response = await fetch(this.#config.endpoint, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"x-orbitrace-api-key": this.#config.apiKey,
+					"x-orbitrace-org-id": this.#config.orgId,
+					"x-orbitrace-project-id": this.#config.projectId,
+				},
+				body: JSON.stringify({
+					event,
+					payload,
+				}),
+			});
+
+			if (!response.ok) {
+				throw new Error(`HTTP error! status: ${response.status}`);
+			}
+
+			return await response.json();
+		} catch (error) {
+			console.error("Orbitrace: Error sending data to API", error);
+			throw error;
+		}
+	}
+}
+
+module.exports = Orbitrace;

package/dist/index.mjs

@@ -0,0 +1,131 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// src/index.js
+var require_src = __commonJS({
+  "src/index.js"(exports, module) {
+    var _config;
+    var Orbitrace = class {
+      static init(config) {
+        this.validateConfig(config);
+        __privateSet(this, _config, {
+          apiKey: config.apiKey,
+          orgId: config.orgId,
+          projectId: config.projectId,
+          endpoint: config.endpoint,
+          environment: config.environment || "production",
+          version: config.version || "1.0.0",
+          service: config.service || "not-specified",
+          disabled: config.disabled || false
+        });
+      }
+      static validateConfig(config) {
+        const requiredFields = ["apiKey", "orgId", "projectId", "endpoint"];
+        const missingFields = requiredFields.filter((field) => !config[field]);
+        if (missingFields.length > 0) {
+          throw new Error(
+            `Missing required configuration fields: ${missingFields.join(", ")}`
+          );
+        }
+      }
+      static checkInitialized() {
+        if (!__privateGet(this, _config)) {
+          throw new Error(
+            "Orbitrace must be initialized with Orbitrace.init() before use"
+          );
+        }
+      }
+      static async captureException(error, metadata = {}) {
+        this.checkInitialized();
+        if (__privateGet(this, _config).disabled) {
+          console.log("Orbitrace: Logging is disabled");
+          return;
+        }
+        try {
+          const payload = {
+            message: error.message,
+            stack: error.stack,
+            metadata: {
+              ...metadata,
+              env: __privateGet(this, _config).environment,
+              version: __privateGet(this, _config).version,
+              service: __privateGet(this, _config).service
+            }
+          };
+          return this.sendToApi("capture_exception", payload);
+        } catch (err) {
+          console.error("Orbitrace: Error capturing exception", err);
+        }
+      }
+      static async captureMessage(message, metadata = {}) {
+        this.checkInitialized();
+        if (__privateGet(this, _config).disabled) {
+          console.log("Orbitrace: Logging is disabled");
+          return;
+        }
+        try {
+          const payload = {
+            message,
+            metadata: {
+              ...metadata,
+              env: __privateGet(this, _config).environment,
+              version: __privateGet(this, _config).version,
+              service: __privateGet(this, _config).service
+            }
+          };
+          return this.sendToApi("capture_message", payload);
+        } catch (err) {
+          console.error("Orbitrace: Error capturing message", err);
+        }
+      }
+      static async sendToApi(event, payload) {
+        try {
+          const response = await fetch(__privateGet(this, _config).endpoint, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "x-orbitrace-api-key": __privateGet(this, _config).apiKey,
+              "x-orbitrace-org-id": __privateGet(this, _config).orgId,
+              "x-orbitrace-project-id": __privateGet(this, _config).projectId
+            },
+            body: JSON.stringify({
+              event,
+              payload
+            })
+          });
+          if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+          }
+          return await response.json();
+        } catch (error) {
+          console.error("Orbitrace: Error sending data to API", error);
+          throw error;
+        }
+      }
+    };
+    _config = new WeakMap();
+    __privateAdd(Orbitrace, _config, null);
+    module.exports = Orbitrace;
+  }
+});
+export default require_src();

package/package.json

@@ -0,0 +1,18 @@
+{
+	"name": "@orbitai/orbitrace",
+	"version": "1.1.0",
+	"description": "Error tracking and monitoring for Node.js and browser applications",
+	"main": "dist/index.js",
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "mkdir -p dist && cp src/index.js dist/index.js",
+		"deploy": "npm run build && npm version patch && npm publish --access public"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"author": "Orbitai",
+	"license": "MIT"
+}