@statoss/sdk 0.0.0-stage → 0.1.0

package/dist/esm/runtime.js

@@ -0,0 +1,181 @@
+import { safely } from "./utils.js";
+function g() {
+    return globalThis;
+}
+export function getProcess() {
+    const p = safely(() => g().process);
+    return p && typeof p === "object" ? p : undefined;
+}
+/** A Node built-in without a static import, so bundlers for the browser never see one. */
+export function getBuiltin(id) {
+    return safely(() => {
+        const p = getProcess();
+        return p && typeof p.getBuiltinModule === "function"
+            ? p.getBuiltinModule(id)
+            : undefined;
+    });
+}
+export function detectRuntime() {
+    return (safely(() => {
+        const global = g();
+        const deno = global.Deno;
+        if (deno &&
+            typeof deno === "object" &&
+            typeof deno.version?.deno === "string")
+            return "deno";
+        const proc = getProcess();
+        if ((global.Bun && typeof global.Bun === "object") || proc?.versions?.bun)
+            return "bun";
+        const nav = global.navigator;
+        if (nav && nav.userAgent === "Cloudflare-Workers")
+            return "cloudflare";
+        if (typeof global.EdgeRuntime === "string")
+            return "vercel-edge";
+        if (global.window &&
+            typeof global.window === "object" &&
+            global.document &&
+            typeof global.document === "object") {
+            return "browser";
+        }
+        if (typeof global.WorkerGlobalScope === "function" &&
+            typeof global.importScripts === "function") {
+            return "worker";
+        }
+        if (proc?.versions?.node)
+            return "node";
+        return "unknown";
+    }) ?? "unknown");
+}
+const OS_NAMES = {
+    darwin: "macOS",
+    win32: "Windows",
+    windows: "Windows",
+    linux: "Linux",
+    freebsd: "FreeBSD",
+    openbsd: "OpenBSD",
+    android: "Android",
+};
+function compact(obj) {
+    const out = {};
+    for (const [k, v] of Object.entries(obj))
+        if (v !== undefined && v !== "")
+            out[k] = v;
+    return out;
+}
+/** Browser and OS from a user agent, for the common browsers only. */
+export function parseUserAgent(ua) {
+    const out = {};
+    const browsers = [
+        [/Edg(?:e|A|iOS)?\/([\d.]+)/, "Edge"],
+        [/OPR\/([\d.]+)/, "Opera"],
+        [/SamsungBrowser\/([\d.]+)/, "Samsung Internet"],
+        [/(?:Firefox|FxiOS)\/([\d.]+)/, "Firefox"],
+        [/(?:Chrome|CriOS|HeadlessChrome)\/([\d.]+)/, "Chrome"],
+        [/Version\/([\d.]+).*Safari\//, "Safari"],
+    ];
+    for (const [re, name] of browsers) {
+        const m = re.exec(ua);
+        if (m) {
+            out.browser = { name, version: m[1] };
+            break;
+        }
+    }
+    let m;
+    if ((m = /Windows NT ([\d.]+)/.exec(ua)))
+        out.os = { name: "Windows", version: m[1] };
+    else if ((m = /(?:iPhone|iPad|iPod).*? OS ([\d_]+)/.exec(ua)))
+        out.os = { name: "iOS", version: m[1].replace(/_/g, ".") };
+    else if ((m = /Mac OS X ([\d_.]+)/.exec(ua)))
+        out.os = { name: "macOS", version: m[1].replace(/_/g, ".") };
+    else if ((m = /Android ([\d.]+)/.exec(ua)))
+        out.os = { name: "Android", version: m[1] };
+    else if (/CrOS/.test(ua))
+        out.os = { name: "Chrome OS" };
+    else if (/Linux/.test(ua))
+        out.os = { name: "Linux" };
+    return out;
+}
+function nodeLike(name) {
+    const proc = getProcess();
+    const os = getBuiltin("node:os");
+    const bun = g().Bun;
+    const runtime = compact({
+        name,
+        version: name === "bun" ? (bun?.version ?? proc?.versions?.bun) : proc?.version,
+    });
+    const osContext = compact({
+        name: OS_NAMES[proc?.platform ?? ""] ?? proc?.platform,
+        kernel_version: safely(() => os?.release?.()),
+    });
+    const device = compact({
+        arch: proc?.arch,
+        memory_size: safely(() => os?.totalmem?.()),
+        processor_count: safely(() => os?.availableParallelism?.() ?? os?.cpus?.().length),
+    });
+    return {
+        contexts: { runtime, os: osContext, device },
+        serverName: safely(() => os?.hostname?.()),
+    };
+}
+function deno() {
+    const d = g().Deno;
+    // Only when already allowed: asking for sys access would prompt the user.
+    const serverName = safely(() => d.permissions?.querySync?.({ name: "sys", kind: "hostname" }).state ===
+        "granted"
+        ? d.hostname?.()
+        : undefined);
+    return {
+        contexts: {
+            runtime: compact({ name: "deno", version: d.version?.deno }),
+            os: compact({ name: OS_NAMES[d.build?.os ?? ""] ?? d.build?.os }),
+            device: compact({ arch: d.build?.arch }),
+        },
+        serverName,
+    };
+}
+function browser(name) {
+    const global = g();
+    const ua = safely(() => global.navigator?.userAgent) ?? "";
+    const parsed = typeof ua === "string" ? parseUserAgent(ua) : {};
+    const contexts = {};
+    if (parsed.browser)
+        contexts.browser = parsed.browser;
+    if (parsed.os)
+        contexts.os = compact(parsed.os);
+    if (name === "browser") {
+        const screen = global.screen;
+        const device = compact({
+            screen_width_pixels: screen?.width,
+            screen_height_pixels: screen?.height,
+            screen_density: global.devicePixelRatio,
+        });
+        if (Object.keys(device).length)
+            contexts.device = device;
+    }
+    return { contexts };
+}
+export function describeRuntime(name = detectRuntime()) {
+    const base = {
+        name,
+        platform: name === "node" ? "node" : "javascript",
+        browserLike: name === "browser" || name === "worker",
+    };
+    const details = safely(() => {
+        switch (name) {
+            case "node":
+            case "bun":
+                return nodeLike(name);
+            case "deno":
+                return deno();
+            case "browser":
+            case "worker":
+                return browser(name);
+            case "cloudflare":
+            case "vercel-edge":
+                return { contexts: { runtime: { name } } };
+            default:
+                return { contexts: {} };
+        }
+    }) ?? { contexts: {} };
+    return { ...base, ...details };
+}

package/dist/esm/scope.d.ts

@@ -0,0 +1,30 @@
+import type { Breadcrumb, CaptureContext, Event, Level, Primitive, User } from "./types.js";
+export declare const MAX_BREADCRUMBS = 100;
+/**
+ * What is attached to the events captured while it is current: user, tags,
+ * extra, contexts, level, fingerprint and breadcrumbs.
+ */
+export declare class Scope {
+    clone(): Scope;
+    /** Like captureException, with this scope whatever is current. Returns the event id. */
+    captureException(error: unknown, context?: CaptureContext): string;
+    /** Like captureMessage, with this scope whatever is current. Returns the event id. */
+    captureMessage(message: string, levelOrContext?: Level | CaptureContext): string;
+    /** Like captureEvent, with this scope whatever is current. Returns the event id. */
+    captureEvent(event: Event, context?: CaptureContext): string;
+    /** Pass null to forget the user. */
+    setUser(user: User | null): this;
+    setTag(key: string, value: Primitive): this;
+    setTags(tags: Record<string, Primitive>): this;
+    setExtra(key: string, value: unknown): this;
+    setExtras(extras: Record<string, unknown>): this;
+    /** Pass null to remove the context. */
+    setContext(name: string, context: Record<string, unknown> | null): this;
+    /** A Sentry level or one of your own names; overrides the level of events captured with this scope. */
+    setLevel(level: Level | undefined): this;
+    setFingerprint(fingerprint: string[] | undefined): this;
+    /** Adds a breadcrumb to this scope only, without `beforeBreadcrumb`, as Sentry's scope does. */
+    addBreadcrumb(breadcrumb: Breadcrumb): this;
+    clearBreadcrumbs(): this;
+    clear(): this;
+}

package/dist/esm/scope.js

@@ -0,0 +1,123 @@
+// hub imports this module too; the calls into it happen only at capture time.
+import { captureWith, messageContext } from "./hub.js";
+import { now } from "./utils.js";
+export const MAX_BREADCRUMBS = 100;
+/**
+ * What is attached to the events captured while it is current: user, tags,
+ * extra, contexts, level, fingerprint and breadcrumbs.
+ */
+export class Scope {
+    constructor() {
+        /** @internal */ this._tags = {};
+        /** @internal */ this._extra = {};
+        /** @internal */ this._contexts = {};
+        /** @internal */ this._breadcrumbs = [];
+        /** @internal */ this._maxBreadcrumbs = MAX_BREADCRUMBS;
+    }
+    clone() {
+        const scope = new Scope();
+        scope._user = this._user ? { ...this._user } : undefined;
+        scope._tags = { ...this._tags };
+        scope._extra = { ...this._extra };
+        scope._contexts = { ...this._contexts };
+        scope._level = this._level;
+        scope._fingerprint = this._fingerprint ? [...this._fingerprint] : undefined;
+        scope._breadcrumbs = [...this._breadcrumbs];
+        scope._maxBreadcrumbs = this._maxBreadcrumbs;
+        return scope;
+    }
+    /** Like captureException, with this scope whatever is current. Returns the event id. */
+    captureException(error, context) {
+        return captureWith(this, (client, scope) => client.captureException(error, context, scope));
+    }
+    /** Like captureMessage, with this scope whatever is current. Returns the event id. */
+    captureMessage(message, levelOrContext) {
+        return captureWith(this, (client, scope) => client.captureMessage(message, messageContext(levelOrContext), scope));
+    }
+    /** Like captureEvent, with this scope whatever is current. Returns the event id. */
+    captureEvent(event, context) {
+        return captureWith(this, (client, scope) => client.captureEvent(event, context, scope));
+    }
+    /** Pass null to forget the user. */
+    setUser(user) {
+        this._user = user ? { ...user } : undefined;
+        return this;
+    }
+    setTag(key, value) {
+        this._tags[key] = value;
+        return this;
+    }
+    setTags(tags) {
+        Object.assign(this._tags, tags);
+        return this;
+    }
+    setExtra(key, value) {
+        this._extra[key] = value;
+        return this;
+    }
+    setExtras(extras) {
+        Object.assign(this._extra, extras);
+        return this;
+    }
+    /** Pass null to remove the context. */
+    setContext(name, context) {
+        if (context === null || typeof context !== "object")
+            delete this._contexts[name];
+        else
+            this._contexts[name] = context;
+        return this;
+    }
+    /** A Sentry level or one of your own names; overrides the level of events captured with this scope. */
+    setLevel(level) {
+        this._level = level;
+        return this;
+    }
+    setFingerprint(fingerprint) {
+        this._fingerprint = fingerprint ? [...fingerprint] : undefined;
+        return this;
+    }
+    /** Adds a breadcrumb to this scope only, without `beforeBreadcrumb`, as Sentry's scope does. */
+    addBreadcrumb(breadcrumb) {
+        const crumb = { ...breadcrumb, timestamp: breadcrumb.timestamp ?? now() };
+        this._breadcrumbs.push(crumb);
+        if (this._breadcrumbs.length > this._maxBreadcrumbs) {
+            this._breadcrumbs.splice(0, this._breadcrumbs.length - this._maxBreadcrumbs);
+        }
+        return this;
+    }
+    clearBreadcrumbs() {
+        this._breadcrumbs = [];
+        return this;
+    }
+    clear() {
+        this._user = undefined;
+        this._tags = {};
+        this._extra = {};
+        this._contexts = {};
+        this._level = undefined;
+        this._fingerprint = undefined;
+        this._breadcrumbs = [];
+        return this;
+    }
+    /** @internal */
+    _apply(data) {
+        if (!data || typeof data !== "object")
+            return this;
+        if (data.user)
+            this.setUser(data.user);
+        if (data.tags)
+            this.setTags(data.tags);
+        if (data.extra)
+            this.setExtras(data.extra);
+        if (data.contexts) {
+            for (const [name, context] of Object.entries(data.contexts)) {
+                this.setContext(name, context);
+            }
+        }
+        if (data.level !== undefined)
+            this.setLevel(data.level);
+        if (data.fingerprint)
+            this.setFingerprint(data.fingerprint);
+        return this;
+    }
+}

package/dist/esm/stack.d.ts

@@ -0,0 +1,9 @@
+import type { StackFrame } from "./types.js";
+/**
+ * Parses a stack string from V8 (Chrome, Edge, Node, Deno, Bun, workers),
+ * SpiderMonkey (Firefox) or JavaScriptCore (Safari) into Sentry frames,
+ * oldest first, keeping the 50 closest to the throw.
+ */
+export declare function parseStack(stack: unknown): StackFrame[];
+/** A frame for a bare location, such as a browser error event's file and line. */
+export declare function frameAt(location: string, line?: number, column?: number): StackFrame | undefined;

package/dist/esm/stack.js

@@ -0,0 +1,125 @@
+const MAX_FRAMES = 50;
+const MAX_LINE = 1024;
+const UNKNOWN_FUNCTION = "?";
+const V8_LINE = /^\s*at /;
+// Frames from dependencies, runtimes, browser extensions and this SDK.
+const NOT_IN_APP = new RegExp([
+    String.raw `(?:^|[/\\])node_modules[/\\]`,
+    String.raw `^(?:node|ext|internal|native|chrome|resource|bun):`,
+    String.raw `^internal[/\\]`,
+    String.raw `^(?:native|unknown|<anonymous>|\[native code\])$`,
+    String.raw `^(?:chrome|moz|safari|safari-web|ms-browser)-extension:`,
+    String.raw `^webkit-masked-url:`,
+    String.raw `[/\\]@statoss[/\\]sdk(?:[/\\@]|$)`,
+    String.raw `[/\\]registry\.npmjs\.org[/\\]`,
+    String.raw `^https?:\/\/(?:jsr\.io|deno\.land|esm\.sh|unpkg\.com|cdn\.jsdelivr\.net|cdn\.skypack\.dev)\/`,
+].join("|"), "i");
+/**
+ * Parses a stack string from V8 (Chrome, Edge, Node, Deno, Bun, workers),
+ * SpiderMonkey (Firefox) or JavaScriptCore (Safari) into Sentry frames,
+ * oldest first, keeping the 50 closest to the throw.
+ */
+export function parseStack(stack) {
+    if (typeof stack !== "string" || stack === "")
+        return [];
+    const lines = stack.split("\n");
+    const v8 = lines.some((line) => V8_LINE.test(line));
+    const frames = [];
+    for (const line of lines) {
+        if (frames.length >= MAX_FRAMES)
+            break;
+        if (line.length > MAX_LINE)
+            continue;
+        const frame = v8 ? parseV8Line(line) : parseGeckoLine(line);
+        if (frame)
+            frames.push(frame);
+    }
+    return frames.reverse();
+}
+// "    at fn (location)", "    at location", "    at async fn (location)"
+function parseV8Line(line) {
+    const m = /^\s*at (?:async )?(.*)$/.exec(line);
+    if (!m)
+        return undefined;
+    const rest = m[1].trim();
+    let fn;
+    let location = rest;
+    if (rest.endsWith(")")) {
+        const open = rest.indexOf(" (");
+        if (open > 0) {
+            fn = rest.slice(0, open);
+            location = rest.slice(open + 2, -1);
+        }
+    }
+    if (location.startsWith("eval at ")) {
+        // The frame ran in eval'd code: point at the call site that made it.
+        const origin = /\((\S+?):(\d+):(\d+)\)/.exec(location);
+        if (origin)
+            return makeFrame(fn, origin[1], origin[2], origin[3]);
+    }
+    const at = /^(.*?):(\d+)(?::(\d+))?$/.exec(location);
+    return at ? makeFrame(fn, at[1], at[2], at[3]) : makeFrame(fn, location);
+}
+// "fn@location" (Firefox, Safari); "async*fn@...", "async fn@...", "@location"
+function parseGeckoLine(line) {
+    const at = line.indexOf("@");
+    if (at < 0)
+        return undefined;
+    let fn = line.slice(0, at).trim();
+    const location = line.slice(at + 1).trim();
+    if (!location)
+        return undefined;
+    const star = fn.lastIndexOf("*");
+    if (star >= 0)
+        fn = fn.slice(star + 1);
+    if (fn.startsWith("async "))
+        fn = fn.slice(6);
+    if (location === "[native code]")
+        return makeFrame(fn, location);
+    // "url line 28 > eval:1:29": code run by eval or new Function, at line 28 of url.
+    const evalled = /^(\S+) line (\d+) > /.exec(location);
+    if (evalled)
+        return makeFrame(fn || "eval", evalled[1], evalled[2]);
+    const m = /^(.*?):(\d+)(?::(\d+))?$/.exec(location);
+    return m ? makeFrame(fn, m[1], m[2], m[3]) : undefined;
+}
+/** A frame for a bare location, such as a browser error event's file and line. */
+export function frameAt(location, line, column) {
+    return makeFrame(undefined, location, line?.toString(), column?.toString());
+}
+function makeFrame(fn, location, line, column) {
+    if (!location)
+        return undefined;
+    let filename = location;
+    let absPath = location;
+    if (/^https?:\/\//i.test(location)) {
+        filename =
+            location.replace(/^https?:\/\/[^/]*/i, "").replace(/[?#].*$/, "") || "/";
+    }
+    else if (location.startsWith("file://")) {
+        const path = location.replace(/^file:\/\//, "");
+        filename = safeDecode(path);
+        absPath = filename;
+    }
+    const lineno = line ? parseInt(line, 10) || undefined : undefined;
+    const colno = column ? parseInt(column, 10) || undefined : undefined;
+    const frame = {
+        filename,
+        abs_path: absPath,
+        function: !fn || fn === "<anonymous>" ? UNKNOWN_FUNCTION : fn,
+    };
+    if (lineno !== undefined)
+        frame.lineno = lineno;
+    if (colno !== undefined)
+        frame.colno = colno;
+    frame.in_app = lineno !== undefined && !NOT_IN_APP.test(absPath);
+    return frame;
+}
+function safeDecode(path) {
+    try {
+        return decodeURI(path);
+    }
+    catch {
+        return path;
+    }
+}

package/dist/esm/transport.d.ts

@@ -0,0 +1,40 @@
+import { type Envelope } from "./envelope.js";
+import type { Logger } from "./logger.js";
+import type { Transport } from "./types.js";
+export declare const QUEUE_LIMIT = 30;
+export declare const CONCURRENCY = 5;
+/** The default transport: fetch, called on globalThis (Workers refuse any other this). */
+export declare function fetchTransport(browserLike: boolean): Transport;
+export type RecordLoss = (reason: string, category: string, quantity?: number) => void;
+export interface SenderOptions {
+    url: string;
+    headers: Record<string, string>;
+    browserLike: boolean;
+    transport: Transport;
+    recordLoss: RecordLoss;
+    logger: Logger;
+}
+/**
+ * Sends envelopes in order of arrival, a few at a time, keeping at most 30
+ * waiting or in flight. Whatever cannot be sent is counted for client reports.
+ */
+export declare class Sender {
+    private readonly options;
+    private readonly queue;
+    private active;
+    private limits;
+    private waiters;
+    private keepaliveBytes;
+    private keepaliveCount;
+    constructor(options: SenderOptions);
+    send(envelope: Envelope): void;
+    /** Resolves true once nothing waits or is in flight, false if timeoutMs passes first. */
+    flush(timeoutMs: number): Promise<boolean>;
+    private idle;
+    private notify;
+    /** Drops the items whose category is rate limited; undefined when none is left. */
+    private withoutLimited;
+    private pump;
+    private deliver;
+    private lose;
+}