@p-r-d-i-f-y/monitor 0.1.0

package/README.md

@@ -0,0 +1,67 @@
+# @p-r-d-i-f-y/monitor
+
+Lightweight SDK for PRDify Engineering monitoring: error capture, distributed tracing, and session replay.
+
+## Install
+
+```bash
+npm install @p-r-d-i-f-y/monitor
+```
+
+Copy your project DSN from **Engineering → Monitoring** in PRDify.
+
+## Browser
+
+```ts
+import { initBrowserMonitor } from '@p-r-d-i-f-y/monitor/browser';
+
+initBrowserMonitor({
+  dsn: 'http://localhost:4000/developer/monitoring/ingest#<public-key>@<project-id>',
+  apiUrl: 'http://localhost:4000',
+  environment: 'production',
+  release: '1.0.0',
+});
+```
+
+Browser init automatically records page spans and enables session replay (clicks, inputs with masked values, navigation).
+
+## Node / NestJS
+
+```ts
+import { initNodeMonitor } from '@p-r-d-i-f-y/monitor/node';
+
+initNodeMonitor({
+  dsn: process.env.PRDIFY_MONITOR_DSN!,
+  apiUrl: process.env.PRDIFY_MONITOR_API_URL,
+  environment: process.env.NODE_ENV,
+});
+```
+
+## Manual spans
+
+```ts
+import { createMonitorClient } from '@p-r-d-i-f-y/monitor';
+
+const client = createMonitorClient({ dsn, apiUrl });
+const span = client.startTimedSpan('db.query', '/users');
+await doWork();
+await span.end('ok');
+```
+
+## Ingest endpoints
+
+| Endpoint | Purpose |
+|----------|---------|
+| `POST /developer/monitoring/ingest` | Errors and breadcrumbs |
+| `POST /developer/monitoring/spans` | Trace spans |
+| `POST /developer/monitoring/replay` | Session replay events |
+
+Send `X-PRDify-DSN: <public-key>` on every request.
+
+## Publish
+
+```bash
+cd packages/monitor
+npm run build
+npm publish --access public
+```

package/dist/browser.d.ts

@@ -0,0 +1,77 @@
+import { type MonitorClientOptions } from './core';
+export declare function initBrowserMonitor(options: MonitorClientOptions): {
+    addBreadcrumb: (crumb: import("./core").MonitorBreadcrumb) => void;
+    captureEvent: (payload: import("./core").MonitorEventPayload) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    captureException: (error: unknown, extra?: Partial<import("./core").MonitorEventPayload>) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    recordSpan: (span: import("./core").SpanPayload) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    startTimedSpan: (operation: string, route?: string, parentSpanId?: string) => {
+        spanId: string;
+        traceId: string;
+        end: (status?: string, metadata?: Record<string, unknown>) => Promise<void>;
+    };
+    getTraceId: () => string;
+    getPublicKey: () => string | null;
+    getIngestUrl: () => string;
+} | null;
+export declare function getBrowserMonitor(): {
+    addBreadcrumb: (crumb: import("./core").MonitorBreadcrumb) => void;
+    captureEvent: (payload: import("./core").MonitorEventPayload) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    captureException: (error: unknown, extra?: Partial<import("./core").MonitorEventPayload>) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    recordSpan: (span: import("./core").SpanPayload) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    startTimedSpan: (operation: string, route?: string, parentSpanId?: string) => {
+        spanId: string;
+        traceId: string;
+        end: (status?: string, metadata?: Record<string, unknown>) => Promise<void>;
+    };
+    getTraceId: () => string;
+    getPublicKey: () => string | null;
+    getIngestUrl: () => string;
+} | null;
+export declare function captureBrowserException(error: unknown, route?: string): Promise<{
+    ok: false;
+    status?: undefined;
+} | {
+    ok: boolean;
+    status: number;
+}> | Promise<{
+    ok: false;
+}>;
+export * from './core';
+export * from './replay';
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAKxE,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAoD/D;AAED,wBAAgB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAEhC;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;;;GAMrE;AAED,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}

package/dist/browser.js

@@ -0,0 +1,65 @@
+import { createMonitorClient } from './core';
+import { enableSessionReplay } from './replay';
+var browserClient = null;
+export function initBrowserMonitor(options) {
+    if (typeof window === 'undefined')
+        return null;
+    if (browserClient)
+        return browserClient;
+    var client = createMonitorClient(options);
+    browserClient = client;
+    window.addEventListener('error', function (event) {
+        var _a;
+        client.addBreadcrumb({
+            category: 'ui',
+            message: "Error at ".concat(event.filename || 'unknown', ":").concat(event.lineno || 0),
+            level: 'error',
+        });
+        void client.captureException((_a = event.error) !== null && _a !== void 0 ? _a : event.message, {
+            route: window.location.pathname,
+            severity: 'error',
+            source: 'browser',
+        }).catch(function () { return undefined; });
+    });
+    window.addEventListener('unhandledrejection', function (event) {
+        client.addBreadcrumb({
+            category: 'promise',
+            message: 'Unhandled promise rejection',
+            level: 'error',
+        });
+        void client.captureException(event.reason, {
+            route: window.location.pathname,
+            severity: 'error',
+            source: 'browser',
+        }).catch(function () { return undefined; });
+    });
+    client.addBreadcrumb({
+        category: 'navigation',
+        message: "Loaded ".concat(window.location.pathname),
+        level: 'info',
+    });
+    void client.recordSpan({
+        traceId: client.getTraceId(),
+        spanId: "".concat(Date.now().toString(16), "page"),
+        operation: "PAGE ".concat(window.location.pathname),
+        route: window.location.pathname,
+        status: 'ok',
+        durationMs: 0,
+        startedAt: new Date().toISOString(),
+    }).catch(function () { return undefined; });
+    enableSessionReplay(client, options);
+    return client;
+}
+export function getBrowserMonitor() {
+    return browserClient;
+}
+export function captureBrowserException(error, route) {
+    if (!browserClient)
+        return Promise.resolve({ ok: false });
+    return browserClient.captureException(error, {
+        route: route !== null && route !== void 0 ? route : (typeof window !== 'undefined' ? window.location.pathname : undefined),
+        source: 'browser',
+    });
+}
+export * from './core';
+export * from './replay';

package/dist/core.d.ts

@@ -0,0 +1,74 @@
+export type MonitorBreadcrumb = {
+    category?: string;
+    type?: string;
+    message: string;
+    level?: string;
+    data?: Record<string, unknown>;
+};
+export type MonitorEventPayload = {
+    message: string;
+    stack?: string;
+    source?: string;
+    severity?: 'info' | 'warning' | 'error' | 'critical';
+    environment?: string;
+    traceId?: string;
+    release?: string;
+    route?: string;
+    breadcrumbs?: MonitorBreadcrumb[];
+    metadata?: Record<string, unknown>;
+};
+export type MonitorClientOptions = {
+    dsn: string;
+    apiUrl?: string;
+    environment?: string;
+    release?: string;
+    traceId?: string;
+};
+export declare function parsePublicKeyFromDsn(dsn: string): string | null;
+export declare function resolveIngestUrl(dsn: string, apiUrl?: string): string;
+export declare function resolveSpansIngestUrl(dsn: string, apiUrl?: string): string;
+export type SpanPayload = {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    operation: string;
+    route?: string;
+    status?: string;
+    durationMs: number;
+    startedAt: string;
+    metadata?: Record<string, unknown>;
+};
+export declare function createMonitorClient(options: MonitorClientOptions): {
+    addBreadcrumb: (crumb: MonitorBreadcrumb) => void;
+    captureEvent: (payload: MonitorEventPayload) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    captureException: (error: unknown, extra?: Partial<MonitorEventPayload>) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    recordSpan: (span: SpanPayload) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    startTimedSpan: (operation: string, route?: string, parentSpanId?: string) => {
+        spanId: string;
+        traceId: string;
+        end: (status?: string, metadata?: Record<string, unknown>) => Promise<void>;
+    };
+    getTraceId: () => string;
+    getPublicKey: () => string | null;
+    getIngestUrl: () => string;
+};
+export type MonitorClient = ReturnType<typeof createMonitorClient>;
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;IACrD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQhE;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAOrE;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,CAAC;AAUF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB;2BAOjC,iBAAiB;4BAKV,mBAAmB;;;;;;;8BAyBjB,OAAO,UAAU,OAAO,CAAC,mBAAmB,CAAC;;;;;;;uBAYpD,WAAW;;;;;;;gCAkBR,MAAM,UAAU,MAAM,iBAAiB,MAAM;;;uBAOxD,MAAM,aAAoB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;EA0B1E;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/core.js

@@ -0,0 +1,211 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+export function parsePublicKeyFromDsn(dsn) {
+    var trimmed = dsn.trim();
+    if (!trimmed)
+        return null;
+    var hashIndex = trimmed.indexOf('#');
+    var fragment = hashIndex >= 0 ? trimmed.slice(hashIndex + 1) : trimmed;
+    var atIndex = fragment.indexOf('@');
+    var key = atIndex >= 0 ? fragment.slice(0, atIndex) : fragment;
+    return key.trim() || null;
+}
+export function resolveIngestUrl(dsn, apiUrl) {
+    if (apiUrl === null || apiUrl === void 0 ? void 0 : apiUrl.trim()) {
+        return "".concat(apiUrl.replace(/\/+$/, ''), "/developer/monitoring/ingest");
+    }
+    var beforeHash = dsn.trim().split('#')[0];
+    if (beforeHash.startsWith('http'))
+        return beforeHash.replace(/\/+$/, '');
+    return 'http://localhost:4000/developer/monitoring/ingest';
+}
+export function resolveSpansIngestUrl(dsn, apiUrl) {
+    return resolveIngestUrl(dsn, apiUrl).replace(/\/ingest$/, '/spans');
+}
+function randomSpanId() {
+    return Math.random().toString(16).slice(2, 10);
+}
+function randomTraceId() {
+    return "".concat(Date.now().toString(16)).concat(Math.random().toString(16).slice(2, 10));
+}
+export function createMonitorClient(options) {
+    var _this = this;
+    var _a;
+    var publicKey = parsePublicKeyFromDsn(options.dsn);
+    var ingestUrl = resolveIngestUrl(options.dsn, options.apiUrl);
+    var spansUrl = resolveSpansIngestUrl(options.dsn, options.apiUrl);
+    var breadcrumbs = [];
+    var activeTraceId = (_a = options.traceId) !== null && _a !== void 0 ? _a : randomTraceId();
+    var addBreadcrumb = function (crumb) {
+        breadcrumbs.push(crumb);
+        if (breadcrumbs.length > 50)
+            breadcrumbs.shift();
+    };
+    var captureEvent = function (payload) { return __awaiter(_this, void 0, void 0, function () {
+        var response, _a;
+        var _b, _c, _d, _e, _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    if (!publicKey)
+                        return [2 /*return*/, { ok: false }];
+                    _g.label = 1;
+                case 1:
+                    _g.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fetch(ingestUrl, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'X-PRDify-DSN': publicKey,
+                            },
+                            body: JSON.stringify(__assign(__assign({}, payload), { environment: (_b = payload.environment) !== null && _b !== void 0 ? _b : options.environment, release: (_c = payload.release) !== null && _c !== void 0 ? _c : options.release, traceId: (_e = (_d = payload.traceId) !== null && _d !== void 0 ? _d : options.traceId) !== null && _e !== void 0 ? _e : activeTraceId, breadcrumbs: __spreadArray(__spreadArray([], breadcrumbs, true), ((_f = payload.breadcrumbs) !== null && _f !== void 0 ? _f : []), true), source: payload.source || 'sdk' })),
+                            keepalive: true,
+                        })];
+                case 2:
+                    response = _g.sent();
+                    return [2 /*return*/, { ok: response.ok, status: response.status }];
+                case 3:
+                    _a = _g.sent();
+                    return [2 /*return*/, { ok: false, status: 0 }];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); };
+    var captureException = function (error, extra) { return __awaiter(_this, void 0, void 0, function () {
+        var message, stack;
+        return __generator(this, function (_a) {
+            message = error instanceof Error ? error.message : String(error);
+            stack = error instanceof Error ? error.stack : undefined;
+            return [2 /*return*/, captureEvent(__assign({ message: message, stack: stack, severity: 'error', traceId: activeTraceId }, extra))];
+        });
+    }); };
+    var recordSpan = function (span) { return __awaiter(_this, void 0, void 0, function () {
+        var response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!publicKey)
+                        return [2 /*return*/, { ok: false }];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fetch(spansUrl, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'X-PRDify-DSN': publicKey,
+                            },
+                            body: JSON.stringify({ spans: [span] }),
+                            keepalive: true,
+                        })];
+                case 2:
+                    response = _b.sent();
+                    return [2 /*return*/, { ok: response.ok, status: response.status }];
+                case 3:
+                    _a = _b.sent();
+                    return [2 /*return*/, { ok: false, status: 0 }];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); };
+    var startTimedSpan = function (operation, route, parentSpanId) {
+        var spanId = randomSpanId();
+        var startedAt = new Date().toISOString();
+        var startedMs = Date.now();
+        return {
+            spanId: spanId,
+            traceId: activeTraceId,
+            end: function () {
+                var args_1 = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args_1[_i] = arguments[_i];
+                }
+                return __awaiter(_this, __spreadArray([], args_1, true), void 0, function (status, metadata) {
+                    if (status === void 0) { status = 'ok'; }
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, recordSpan({
+                                    traceId: activeTraceId,
+                                    spanId: spanId,
+                                    parentSpanId: parentSpanId,
+                                    operation: operation,
+                                    route: route,
+                                    status: status,
+                                    durationMs: Date.now() - startedMs,
+                                    startedAt: startedAt,
+                                    metadata: metadata,
+                                })];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            },
+        };
+    };
+    return {
+        addBreadcrumb: addBreadcrumb,
+        captureEvent: captureEvent,
+        captureException: captureException,
+        recordSpan: recordSpan,
+        startTimedSpan: startTimedSpan,
+        getTraceId: function () { return activeTraceId; },
+        getPublicKey: function () { return publicKey; },
+        getIngestUrl: function () { return ingestUrl; },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './core';
+export * from './browser';
+export * from './node';
+export * from './replay';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './browser';
+export * from './node';
+export * from './replay';

package/dist/node.d.ts

@@ -0,0 +1,67 @@
+import { type MonitorClientOptions } from './core';
+export declare function initNodeMonitor(options: MonitorClientOptions): {
+    addBreadcrumb: (crumb: import("./core").MonitorBreadcrumb) => void;
+    captureEvent: (payload: import("./core").MonitorEventPayload) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    captureException: (error: unknown, extra?: Partial<import("./core").MonitorEventPayload>) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    recordSpan: (span: import("./core").SpanPayload) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    startTimedSpan: (operation: string, route?: string, parentSpanId?: string) => {
+        spanId: string;
+        traceId: string;
+        end: (status?: string, metadata?: Record<string, unknown>) => Promise<void>;
+    };
+    getTraceId: () => string;
+    getPublicKey: () => string | null;
+    getIngestUrl: () => string;
+};
+export declare function getNodeMonitor(): {
+    addBreadcrumb: (crumb: import("./core").MonitorBreadcrumb) => void;
+    captureEvent: (payload: import("./core").MonitorEventPayload) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    captureException: (error: unknown, extra?: Partial<import("./core").MonitorEventPayload>) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    recordSpan: (span: import("./core").SpanPayload) => Promise<{
+        ok: false;
+        status?: undefined;
+    } | {
+        ok: boolean;
+        status: number;
+    }>;
+    startTimedSpan: (operation: string, route?: string, parentSpanId?: string) => {
+        spanId: string;
+        traceId: string;
+        end: (status?: string, metadata?: Record<string, unknown>) => Promise<void>;
+    };
+    getTraceId: () => string;
+    getPublicKey: () => string | null;
+    getIngestUrl: () => string;
+} | null;
+export * from './core';
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAIxE,wBAAgB,eAAe,CAAC,OAAO,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoB5D;AAED,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAE7B;AAED,cAAc,QAAQ,CAAC"}

package/dist/node.js

@@ -0,0 +1,25 @@
+import { createMonitorClient } from './core';
+var nodeClient = null;
+export function initNodeMonitor(options) {
+    if (nodeClient)
+        return nodeClient;
+    var client = createMonitorClient(options);
+    nodeClient = client;
+    process.on('uncaughtException', function (error) {
+        void client.captureException(error, {
+            route: 'process:uncaughtException',
+            source: 'node',
+        });
+    });
+    process.on('unhandledRejection', function (reason) {
+        void client.captureException(reason, {
+            route: 'process:unhandledRejection',
+            source: 'node',
+        });
+    });
+    return client;
+}
+export function getNodeMonitor() {
+    return nodeClient;
+}
+export * from './core';

package/dist/replay.d.ts

@@ -0,0 +1,15 @@
+import type { MonitorClient } from './core';
+export type ReplayEvent = {
+    type: 'navigation' | 'click' | 'input' | 'scroll' | 'error' | 'custom';
+    timestamp: string;
+    route?: string;
+    message?: string;
+    data?: Record<string, unknown>;
+};
+export declare function enableSessionReplay(client: MonitorClient, options: {
+    dsn: string;
+    apiUrl?: string;
+    flushIntervalMs?: number;
+    sessionId?: string;
+}): () => void;
+//# sourceMappingURL=replay.d.ts.map

package/dist/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../src/replay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAG5C,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,YAAY,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAeF,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE;IACP,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,cA+GF"}

package/dist/replay.js

@@ -0,0 +1,170 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { parsePublicKeyFromDsn, resolveIngestUrl } from './core';
+function resolveReplayUrl(dsn, apiUrl) {
+    return resolveIngestUrl(dsn, apiUrl).replace(/\/ingest$/, '/replay');
+}
+function randomSessionId() {
+    return "sess_".concat(Date.now().toString(16)).concat(Math.random().toString(16).slice(2, 8));
+}
+function maskValue(value) {
+    if (value.length <= 2)
+        return '**';
+    return "".concat(value.slice(0, 1)).concat('*'.repeat(Math.min(value.length - 1, 8)));
+}
+export function enableSessionReplay(client, options) {
+    var _this = this;
+    var _a, _b;
+    if (typeof window === 'undefined' || typeof document === 'undefined')
+        return function () { return undefined; };
+    var publicKey = parsePublicKeyFromDsn(options.dsn);
+    var replayUrl = resolveReplayUrl(options.dsn, options.apiUrl);
+    var sessionId = (_a = options.sessionId) !== null && _a !== void 0 ? _a : randomSessionId();
+    var events = [];
+    var startedAt = Date.now();
+    var flushing = false;
+    var record = function (event) {
+        events.push(event);
+        if (events.length >= 40) {
+            void flush();
+        }
+    };
+    var flush = function () { return __awaiter(_this, void 0, void 0, function () {
+        var batch, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!publicKey || flushing || !events.length)
+                        return [2 /*return*/];
+                    flushing = true;
+                    batch = events.splice(0, events.length);
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, 4, 5]);
+                    return [4 /*yield*/, fetch(replayUrl, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'X-PRDify-DSN': publicKey,
+                            },
+                            body: JSON.stringify({
+                                sessionId: sessionId,
+                                traceId: client.getTraceId(),
+                                route: window.location.pathname,
+                                userAgent: navigator.userAgent,
+                                durationMs: Date.now() - startedAt,
+                                hasError: batch.some(function (event) { return event.type === 'error'; }),
+                                events: batch,
+                            }),
+                            keepalive: true,
+                        })];
+                case 2:
+                    _b.sent();
+                    return [3 /*break*/, 5];
+                case 3:
+                    _a = _b.sent();
+                    events.unshift.apply(events, batch);
+                    return [3 /*break*/, 5];
+                case 4:
+                    flushing = false;
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); };
+    var onClick = function (event) {
+        var _a, _b, _c;
+        var target = event.target;
+        record({
+            type: 'click',
+            timestamp: new Date().toISOString(),
+            route: window.location.pathname,
+            message: (_b = (_a = target === null || target === void 0 ? void 0 : target.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : 'element',
+            data: {
+                id: (target === null || target === void 0 ? void 0 : target.id) || undefined,
+                className: (target === null || target === void 0 ? void 0 : target.className) || undefined,
+                text: ((_c = target === null || target === void 0 ? void 0 : target.textContent) === null || _c === void 0 ? void 0 : _c.trim().slice(0, 80)) || undefined,
+            },
+        });
+    };
+    var onInput = function (event) {
+        var _a;
+        var target = event.target;
+        if (!target)
+            return;
+        record({
+            type: 'input',
+            timestamp: new Date().toISOString(),
+            route: window.location.pathname,
+            message: target.name || target.id || target.tagName.toLowerCase(),
+            data: {
+                value: maskValue((_a = target.value) !== null && _a !== void 0 ? _a : ''),
+            },
+        });
+    };
+    var onError = function () {
+        record({
+            type: 'error',
+            timestamp: new Date().toISOString(),
+            route: window.location.pathname,
+            message: 'Captured error during session',
+        });
+        void flush();
+    };
+    record({
+        type: 'navigation',
+        timestamp: new Date().toISOString(),
+        route: window.location.pathname,
+        message: "Session started on ".concat(window.location.pathname),
+    });
+    document.addEventListener('click', onClick, true);
+    document.addEventListener('input', onInput, true);
+    window.addEventListener('error', onError);
+    window.addEventListener('beforeunload', function () {
+        void flush();
+    });
+    var interval = window.setInterval(function () {
+        void flush();
+    }, (_b = options.flushIntervalMs) !== null && _b !== void 0 ? _b : 12000);
+    return function () {
+        document.removeEventListener('click', onClick, true);
+        document.removeEventListener('input', onInput, true);
+        window.removeEventListener('error', onError);
+        window.clearInterval(interval);
+        void flush();
+    };
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@p-r-d-i-f-y/monitor",
+  "version": "0.1.0",
+  "description": "PRDify error monitoring, tracing, and session replay SDK",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "monitoring",
+    "errors",
+    "tracing",
+    "session-replay",
+    "prdify"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "typescript": "^5.8.2"
+  }
+}