usetraceforge 0.1.4

package/README.md

@@ -0,0 +1,67 @@
+# traceforge
+
+TraceForge JavaScript SDK for sending errors to your TraceForge backend.
+
+## Install
+
+```bash
+npm install traceforge
+```
+
+## Local pack test
+
+```bash
+cd packages/sdk
+npm pack
+```
+
+Then in any local app:
+
+```bash
+npm install /path/to/traceforge-0.1.0.tgz
+```
+
+## Usage
+```ts
+import TraceForge from "traceforge";
+
+TraceForge.init({
+  apiKey: "YOUR_PROJECT_API_KEY",
+  endpoint: "http://localhost:3001/ingest",
+  autoCapture: true,
+  environment: "development",
+  release: "web@1.0.0"
+});
+
+try {
+  throw new Error("Something broke");
+} catch (error) {
+  TraceForge.captureException(error, {
+    payload: { route: "/signup" }
+  });
+}
+```
+
+## Options
+- `autoCapture`: Listen to `window.onerror` and `window.onunhandledrejection`.
+- `ignoreErrors`: Array of strings or regex to skip noisy errors.
+- `beforeSend`: Hook to modify/drop events before sending.
+- `release`: Stable release tag like `web@1.0.0` or `api@2.3.1`.
+
+## Publish
+
+```bash
+cd packages/sdk
+npm login
+npm run build
+npm version patch
+npm publish --access public
+```
+
+After publish, consumers can install it with:
+
+```bash
+npm install traceforge
+```
+
+If the unscoped npm name is unavailable, publish under a scoped package name and update the install line to match.

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+type TraceForgeConfig = {
+    apiKey: string;
+    endpoint?: string;
+    autoCapture?: boolean;
+    environment?: string;
+    release?: string;
+    tags?: Record<string, string>;
+    ignoreErrors?: Array<string | RegExp>;
+    beforeSend?: (event: TraceForgeEvent) => TraceForgeEvent | null;
+};
+type CapturePayload = {
+    environment?: string;
+    release?: string;
+    payload?: Record<string, unknown>;
+    tags?: Record<string, string>;
+};
+type TraceForgeEvent = {
+    message: string;
+    stackTrace: string;
+    environment?: string;
+    release?: string;
+    payload?: Record<string, unknown>;
+    tags?: Record<string, string>;
+};
+declare const TraceForge: {
+    init: (options: TraceForgeConfig) => void;
+    captureException: (error: unknown, extras?: CapturePayload) => Promise<void>;
+};
+declare const init: (options: TraceForgeConfig) => void;
+declare const captureException: (error: unknown, extras?: CapturePayload) => Promise<void>;
+export default TraceForge;
+export { init, captureException };
+export type { TraceForgeConfig, CapturePayload, TraceForgeEvent };

package/dist/index.js

@@ -0,0 +1,111 @@
+let config = null;
+let autoCaptureInitialized = false;
+const defaultEndpoint = "http://localhost:3001/ingest";
+const ensureConfig = () => {
+    if (!config) {
+        throw new Error("TraceForge not initialized. Call TraceForge.init({ apiKey }) first.");
+    }
+};
+const normalizeError = (error) => {
+    if (error instanceof Error) {
+        return {
+            message: error.message,
+            stackTrace: error.stack || ""
+        };
+    }
+    if (typeof error === "string") {
+        return {
+            message: error,
+            stackTrace: ""
+        };
+    }
+    return {
+        message: "Unknown error",
+        stackTrace: JSON.stringify(error)
+    };
+};
+const shouldIgnore = (message) => {
+    const ignoreList = config?.ignoreErrors || [];
+    return ignoreList.some((entry) => {
+        if (typeof entry === "string") {
+            return message.includes(entry);
+        }
+        return entry.test(message);
+    });
+};
+const buildEvent = (error, extras) => {
+    const { message, stackTrace } = normalizeError(error);
+    return {
+        message,
+        stackTrace,
+        environment: extras?.environment || config?.environment,
+        release: extras?.release || config?.release,
+        payload: extras?.payload,
+        tags: { ...config?.tags, ...extras?.tags }
+    };
+};
+const sendEvent = async (event) => {
+    if (shouldIgnore(event.message)) {
+        return;
+    }
+    const processed = config?.beforeSend ? config.beforeSend(event) : event;
+    if (!processed) {
+        return;
+    }
+    await fetch(config.endpoint || defaultEndpoint, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-Traceforge-Key": config.apiKey
+        },
+        body: JSON.stringify(processed)
+    });
+};
+const capture = async (error, extras) => {
+    ensureConfig();
+    const event = buildEvent(error, extras);
+    await sendEvent(event);
+};
+const setupAutoCapture = () => {
+    if (autoCaptureInitialized)
+        return;
+    if (typeof window === "undefined")
+        return;
+    window.addEventListener("error", (event) => {
+        if (event.error) {
+            capture(event.error, { environment: "browser" }).catch(() => undefined);
+        }
+        else if (event.message) {
+            capture(new Error(event.message), { environment: "browser" }).catch(() => undefined);
+        }
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+        capture(event.reason ?? new Error("Unhandled promise rejection"), {
+            environment: "browser"
+        }).catch(() => undefined);
+    });
+    autoCaptureInitialized = true;
+};
+const TraceForge = {
+    init: (options) => {
+        config = {
+            endpoint: defaultEndpoint,
+            autoCapture: false,
+            ...options
+        };
+        if (config.autoCapture) {
+            setupAutoCapture();
+        }
+    },
+    captureException: async (error, extras) => {
+        await capture(error, extras);
+    }
+};
+const init = (options) => {
+    TraceForge.init(options);
+};
+const captureException = async (error, extras) => {
+    await TraceForge.captureException(error, extras);
+};
+export default TraceForge;
+export { init, captureException };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "usetraceforge",
+  "version": "0.1.4",
+  "private": false,
+  "description": "TraceForge JavaScript SDK for sending errors to a TraceForge ingest endpoint.",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/khushalp2004/TraceForge.git",
+    "directory": "packages/sdk"
+  },
+  "homepage": "https://usetraceforge.com/docs",
+  "bugs": {
+    "url": "https://github.com/khushalp2004/TraceForge/issues"
+  },
+  "keywords": [
+    "traceforge",
+    "monitoring",
+    "error-tracking",
+    "observability",
+    "javascript",
+    "sdk"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npx tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "prepack": "npm run build",
+    "publish:public": "npm publish --access public"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.5.4",
+    "tsx": "^4.16.2"
+  }
+}