@kubit-ai/sentry 0.1.0

package/dist/browser.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Browser entry for `@kubit-ai/sentry`.
+ *
+ * Bundles `@sentry/browser` together with the Kubit tee into a single IIFE so a
+ * site with NO bundler can wire "Sentry + Kubit behavior analytics" from one
+ * `<script>` tag (see `scripts/build-browser.mjs` → `dist/browser/`):
+ *
+ *     <script src="kubit-sentry.global.js"></script>
+ *     <script>
+ *       KubitSentry.init({
+ *         dsn: "https://...@sentry.io/...",          // your Sentry project
+ *         apiKey: "rg.v1...",                         // Kubit ingestion key
+ *         endpoint: "https://otel.kubit.ai/v1/traces",
+ *         serviceName: "my-app",
+ *         environment: "production",
+ *       });
+ *       KubitSentry.trackEvent("Product Added", { productId: 1, price: 49.99 });
+ *     </script>
+ *
+ * `init` runs `Sentry.init` with browser tracing (pageload / navigation /
+ * `http.client` spans — the "page view" and "api call" families) plus the
+ * `kubitSentryIntegration` that tees every event Sentry sends to the Kubit
+ * collector. `trackEvent` emits a named, zero-duration root transaction (the
+ * "clicked / action" family) whose name flows straight through to Kubit.
+ *
+ * This entry is additive: the CommonJS `index.ts` (bundler-based consumers) is
+ * untouched. Only `<script>`-tag consumers use this file.
+ */
+import * as Sentry from "@sentry/browser";
+import type { KubitSentryOptions } from "./config";
+/** Attribute values accepted on a behavior event. */
+type EventAttributeValue = string | number | boolean;
+export interface KubitInitOptions extends KubitSentryOptions {
+    /** Sentry DSN for your error/transaction project. Omit to skip Sentry capture. */
+    dsn?: string;
+    /** `deployment.environment` (e.g. "staging", "production"). */
+    environment?: string;
+    /** Release identifier — also used as `service.version` when set. */
+    release?: string;
+    /**
+     * Fraction of transactions sampled. Behavior analytics wants full capture, so
+     * this defaults to 1.0 — lower it only if Sentry is also your perf tool.
+     */
+    tracesSampleRate?: number;
+}
+/**
+ * Initialize Sentry browser + the Kubit tee in one call. Safe to call once per
+ * page load. Returns the Sentry namespace for advanced use (manual captures).
+ */
+export declare const init: (options?: KubitInitOptions) => typeof Sentry;
+/**
+ * Emit a named behavior event. Creates a zero-duration root transaction
+ * (`forceTransaction`) so the Kubit tee exports it as its own OTLP span named
+ * exactly `name`, carrying `attributes` as span attributes. No-op (warns) when
+ * called before `init()`.
+ */
+export declare const trackEvent: (name: string, attributes?: Record<string, EventAttributeValue>) => void;
+export { Sentry };
+export { kubitSentryIntegration } from "./integration";
+export { createRollingSession, type RollingSessionOptions, type SessionIdProvider, type SessionStorageLike, } from "./session";

package/dist/browser.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Browser entry for `@kubit-ai/sentry`.
+ *
+ * Bundles `@sentry/browser` together with the Kubit tee into a single IIFE so a
+ * site with NO bundler can wire "Sentry + Kubit behavior analytics" from one
+ * `<script>` tag (see `scripts/build-browser.mjs` → `dist/browser/`):
+ *
+ *     <script src="kubit-sentry.global.js"></script>
+ *     <script>
+ *       KubitSentry.init({
+ *         dsn: "https://...@sentry.io/...",          // your Sentry project
+ *         apiKey: "rg.v1...",                         // Kubit ingestion key
+ *         endpoint: "https://otel.kubit.ai/v1/traces",
+ *         serviceName: "my-app",
+ *         environment: "production",
+ *       });
+ *       KubitSentry.trackEvent("Product Added", { productId: 1, price: 49.99 });
+ *     </script>
+ *
+ * `init` runs `Sentry.init` with browser tracing (pageload / navigation /
+ * `http.client` spans — the "page view" and "api call" families) plus the
+ * `kubitSentryIntegration` that tees every event Sentry sends to the Kubit
+ * collector. `trackEvent` emits a named, zero-duration root transaction (the
+ * "clicked / action" family) whose name flows straight through to Kubit.
+ *
+ * This entry is additive: the CommonJS `index.ts` (bundler-based consumers) is
+ * untouched. Only `<script>`-tag consumers use this file.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRollingSession = exports.kubitSentryIntegration = exports.Sentry = exports.trackEvent = exports.init = void 0;
+const Sentry = __importStar(require("@sentry/browser"));
+exports.Sentry = Sentry;
+const integration_1 = require("./integration");
+const session_1 = require("./session");
+let initialized = false;
+/**
+ * Initialize Sentry browser + the Kubit tee in one call. Safe to call once per
+ * page load. Returns the Sentry namespace for advanced use (manual captures).
+ */
+const init = (options = {}) => {
+    const { dsn, environment, release, tracesSampleRate = 1.0, apiKey, endpoint, serviceName, serviceVersion, debug, sessionId, } = options;
+    Sentry.init({
+        dsn,
+        environment,
+        release,
+        tracesSampleRate,
+        integrations: [
+            Sentry.browserTracingIntegration(),
+            (0, integration_1.kubitSentryIntegration)({
+                apiKey,
+                endpoint,
+                serviceName,
+                serviceVersion: serviceVersion ?? release,
+                debug,
+                // Default to a 30-min rolling session so every browser consumer gets a
+                // `session.id` for free. Pass your own `sessionId` (string or function,
+                // e.g. createRollingSession({ initialId: ... })) to override.
+                sessionId: sessionId ?? (0, session_1.createRollingSession)(),
+            }),
+        ],
+    });
+    initialized = true;
+    return Sentry;
+};
+exports.init = init;
+/**
+ * Emit a named behavior event. Creates a zero-duration root transaction
+ * (`forceTransaction`) so the Kubit tee exports it as its own OTLP span named
+ * exactly `name`, carrying `attributes` as span attributes. No-op (warns) when
+ * called before `init()`.
+ */
+const trackEvent = (name, attributes = {}) => {
+    if (!initialized) {
+        console.warn("[kubit-sentry] trackEvent called before init()");
+        return;
+    }
+    Sentry.startSpan({ name, op: "ui.action", forceTransaction: true, attributes }, () => {
+        // Zero-duration: the span starts and ends immediately, producing a
+        // standalone transaction event the tee converts to one OTLP span.
+    });
+};
+exports.trackEvent = trackEvent;
+var integration_2 = require("./integration");
+Object.defineProperty(exports, "kubitSentryIntegration", { enumerable: true, get: function () { return integration_2.kubitSentryIntegration; } });
+var session_2 = require("./session");
+Object.defineProperty(exports, "createRollingSession", { enumerable: true, get: function () { return session_2.createRollingSession; } });
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,wDAA0C;AAyFjC,wBAAM;AAxFf,+CAAuD;AACvD,uCAAiD;AAoBjD,IAAI,WAAW,GAAG,KAAK,CAAC;AAExB;;;GAGG;AACI,MAAM,IAAI,GAAG,CAAC,UAA4B,EAAE,EAAiB,EAAE;IACpE,MAAM,EACJ,GAAG,EACH,WAAW,EACX,OAAO,EACP,gBAAgB,GAAG,GAAG,EACtB,MAAM,EACN,QAAQ,EACR,WAAW,EACX,cAAc,EACd,KAAK,EACL,SAAS,GACV,GAAG,OAAO,CAAC;IAEZ,MAAM,CAAC,IAAI,CAAC;QACV,GAAG;QACH,WAAW;QACX,OAAO;QACP,gBAAgB;QAChB,YAAY,EAAE;YACZ,MAAM,CAAC,yBAAyB,EAAE;YAClC,IAAA,oCAAsB,EAAC;gBACrB,MAAM;gBACN,QAAQ;gBACR,WAAW;gBACX,cAAc,EAAE,cAAc,IAAI,OAAO;gBACzC,KAAK;gBACL,uEAAuE;gBACvE,wEAAwE;gBACxE,8DAA8D;gBAC9D,SAAS,EAAE,SAAS,IAAI,IAAA,8BAAoB,GAAE;aAC/C,CAAC;SACH;KACF,CAAC,CAAC;IACH,WAAW,GAAG,IAAI,CAAC;IACnB,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AApCW,QAAA,IAAI,QAoCf;AAEF;;;;;GAKG;AACI,MAAM,UAAU,GAAG,CACxB,IAAY,EACZ,aAAkD,EAAE,EAC9C,EAAE;IACR,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,CAAC,IAAI,CAAC,gDAAgD,CAAC,CAAC;QAC/D,OAAO;IACT,CAAC;IACD,MAAM,CAAC,SAAS,CACd,EAAE,IAAI,EAAE,EAAE,EAAE,WAAW,EAAE,gBAAgB,EAAE,IAAI,EAAE,UAAU,EAAE,EAC7D,GAAG,EAAE;QACH,mEAAmE;QACnE,kEAAkE;IACpE,CAAC,CACF,CAAC;AACJ,CAAC,CAAC;AAfW,QAAA,UAAU,cAerB;AAGF,6CAAuD;AAA9C,qHAAA,sBAAsB,OAAA;AAC/B,qCAKmB;AAJjB,+GAAA,oBAAoB,OAAA"}

package/dist/config.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Configuration resolution for the Kubit Sentry SDK.
+ *
+ * Precedence: explicit options > environment variables > built-in default.
+ * Env reads are guarded so the SDK also works in browser bundles where
+ * `process` is undefined (bundlers typically inline `process.env.FOO` at
+ * build time, but a runtime guard avoids a ReferenceError when they don't).
+ */
+/** Prod ingestion endpoint — same OTLP/HTTP entrypoint the LLM SDK uses. */
+export declare const DEFAULT_ENDPOINT = "https://otel.kubit.ai/v1/traces";
+/** User-facing options accepted by the integration / hook factories. */
+export interface KubitSentryOptions {
+    /** Workspace ingestion key (`rg.v1.*`). Falls back to `KUBIT_OTEL_API_KEY`. */
+    apiKey?: string;
+    /** OTLP/HTTP traces endpoint. Falls back to `KUBIT_OTEL_ENDPOINT`. */
+    endpoint?: string;
+    /** `service.name` resource attribute. Falls back to `KUBIT_SERVICE_NAME`. */
+    serviceName?: string;
+    /** `service.version` resource attribute. Falls back to the event `release`. */
+    serviceVersion?: string;
+    /** When true, failed exports are logged via `console.warn`. */
+    debug?: boolean;
+    /**
+     * Session id source. A string, or a function called per teed event to read
+     * the current id (e.g. `createRollingSession(...)`). When set, every exported
+     * span carries a `session.id` attribute. The browser `init()` defaults this to
+     * a 30-min rolling session; elsewhere, omit it for no session id.
+     */
+    sessionId?: string | (() => string | undefined);
+}
+/** Fully-resolved config consumed by the transform + exporter. */
+export interface KubitSentryConfig {
+    apiKey: string;
+    endpoint: string;
+    serviceName?: string;
+    serviceVersion?: string;
+    debug: boolean;
+    /** Resolved session-id reader; absent when no session id was configured. */
+    getSessionId?: () => string | undefined;
+}
+export declare const resolveConfig: (options?: KubitSentryOptions) => KubitSentryConfig;

package/dist/config.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Configuration resolution for the Kubit Sentry SDK.
+ *
+ * Precedence: explicit options > environment variables > built-in default.
+ * Env reads are guarded so the SDK also works in browser bundles where
+ * `process` is undefined (bundlers typically inline `process.env.FOO` at
+ * build time, but a runtime guard avoids a ReferenceError when they don't).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = exports.DEFAULT_ENDPOINT = void 0;
+/** Prod ingestion endpoint — same OTLP/HTTP entrypoint the LLM SDK uses. */
+exports.DEFAULT_ENDPOINT = "https://otel.kubit.ai/v1/traces";
+const readEnv = (key) => typeof process !== "undefined" && process.env ? process.env[key] : undefined;
+/** Normalize the `sessionId` option (string | function | undefined) to a reader. */
+const resolveSessionProvider = (sessionId) => {
+    if (sessionId === undefined) {
+        return undefined;
+    }
+    if (typeof sessionId === "function") {
+        return sessionId;
+    }
+    return () => sessionId;
+};
+const resolveConfig = (options = {}) => ({
+    apiKey: options.apiKey ?? readEnv("KUBIT_OTEL_API_KEY") ?? "",
+    endpoint: options.endpoint ?? readEnv("KUBIT_OTEL_ENDPOINT") ?? exports.DEFAULT_ENDPOINT,
+    serviceName: options.serviceName ?? readEnv("KUBIT_SERVICE_NAME"),
+    serviceVersion: options.serviceVersion,
+    debug: options.debug ?? false,
+    getSessionId: resolveSessionProvider(options.sessionId),
+});
+exports.resolveConfig = resolveConfig;
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAEH,4EAA4E;AAC/D,QAAA,gBAAgB,GAAG,iCAAiC,CAAC;AAkClE,MAAM,OAAO,GAAG,CAAC,GAAW,EAAsB,EAAE,CAClD,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAE/E,oFAAoF;AACpF,MAAM,sBAAsB,GAAG,CAC7B,SAA0C,EACF,EAAE;IAC1C,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,OAAO,SAAS,KAAK,UAAU,EAAE,CAAC;QACpC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,GAAG,EAAE,CAAC,SAAS,CAAC;AACzB,CAAC,CAAC;AAEK,MAAM,aAAa,GAAG,CAC3B,UAA8B,EAAE,EACb,EAAE,CAAC,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,oBAAoB,CAAC,IAAI,EAAE;IAC7D,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,qBAAqB,CAAC,IAAI,wBAAgB;IAChF,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,oBAAoB,CAAC;IACjE,cAAc,EAAE,OAAO,CAAC,cAAc;IACtC,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,KAAK;IAC7B,YAAY,EAAE,sBAAsB,CAAC,OAAO,CAAC,SAAS,CAAC;CACxD,CAAC,CAAC;AATU,QAAA,aAAa,iBASvB"}

package/dist/exporter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Hand-rolled OTLP/HTTP+JSON exporter targeting the Kubit collector
+ * (`POST {endpoint}`, `x-api-key` header).
+ *
+ * Collector contract (OTLP/HTTP):
+ *   POST {endpoint}                 — e.g. https://otel.kubit.ai/v1/traces
+ *   Headers:
+ *     x-api-key: {key}              (required, missing -> 401)
+ *     Content-Type: application/json
+ *   Body: standard OTLP `ExportTraceServiceRequest` JSON
+ *
+ *   Response:
+ *     200 + body { partial_success?: { rejected_spans, error_message } }
+ *     401  -> bad / missing key
+ *     415  -> wrong Content-Type
+ *     400  -> malformed body
+ *     413  -> body too large
+ *     503  -> transient (queue full) — has Retry-After
+ */
+import type { KubitSentryConfig } from "./config";
+import type { OtlpExportRequest } from "./types";
+export interface PostResult {
+    ok: boolean;
+    /** HTTP status, or 0 on network failure. */
+    status: number;
+    /** Human-readable explanation, populated on failure or partial success. */
+    message?: string;
+    /** Number of spans rejected by the collector (200 with partial_success). */
+    rejectedSpans?: number;
+}
+/**
+ * Fire-and-forget OTLP POST. Resolves with the result; never throws — callers
+ * (Sentry `afterSendEvent` / `beforeSend`) cannot tolerate exceptions.
+ */
+export declare const postOtlp: (payload: OtlpExportRequest, config: Pick<KubitSentryConfig, "endpoint" | "apiKey">) => Promise<PostResult>;

package/dist/exporter.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Hand-rolled OTLP/HTTP+JSON exporter targeting the Kubit collector
+ * (`POST {endpoint}`, `x-api-key` header).
+ *
+ * Collector contract (OTLP/HTTP):
+ *   POST {endpoint}                 — e.g. https://otel.kubit.ai/v1/traces
+ *   Headers:
+ *     x-api-key: {key}              (required, missing -> 401)
+ *     Content-Type: application/json
+ *   Body: standard OTLP `ExportTraceServiceRequest` JSON
+ *
+ *   Response:
+ *     200 + body { partial_success?: { rejected_spans, error_message } }
+ *     401  -> bad / missing key
+ *     415  -> wrong Content-Type
+ *     400  -> malformed body
+ *     413  -> body too large
+ *     503  -> transient (queue full) — has Retry-After
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postOtlp = void 0;
+const FETCH_TIMEOUT_MS = 10_000;
+/**
+ * Browsers cap the aggregate in-flight `keepalive` body at ~64 KB and reject
+ * larger requests outright, so keepalive is only set for small payloads (and
+ * only in browsers — Node fetch implementations may not support the flag).
+ */
+const KEEPALIVE_MAX_BODY_BYTES = 60_000;
+/**
+ * Fire-and-forget OTLP POST. Resolves with the result; never throws — callers
+ * (Sentry `afterSendEvent` / `beforeSend`) cannot tolerate exceptions.
+ */
+const postOtlp = async (payload, config) => {
+    let response;
+    try {
+        const body = JSON.stringify(payload);
+        const init = {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": config.apiKey,
+            },
+            body,
+        };
+        if (typeof AbortSignal !== "undefined" &&
+            typeof AbortSignal.timeout === "function") {
+            init.signal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
+        }
+        if (typeof document !== "undefined" && body.length < KEEPALIVE_MAX_BODY_BYTES) {
+            // Lets events fired near page unload survive navigation.
+            init.keepalive = true;
+        }
+        response = await fetch(config.endpoint, init);
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : "unknown network error";
+        return { ok: false, status: 0, message };
+    }
+    if (response.ok) {
+        let body = null;
+        try {
+            body = (await response.json());
+        }
+        catch {
+            // empty body or non-JSON — treat as full success
+            return { ok: true, status: response.status };
+        }
+        const rejectedRaw = body?.partial_success?.rejected_spans;
+        const rejected = typeof rejectedRaw === "string" ? Number(rejectedRaw) : rejectedRaw;
+        if (typeof rejected === "number" && rejected > 0) {
+            return {
+                ok: true,
+                status: response.status,
+                rejectedSpans: rejected,
+                message: body?.partial_success?.error_message,
+            };
+        }
+        return { ok: true, status: response.status };
+    }
+    let message = `HTTP ${response.status}`;
+    try {
+        const text = await response.text();
+        if (text.length > 0) {
+            message = text.length > 200 ? `${text.slice(0, 200)}…` : text;
+        }
+    }
+    catch {
+        // ignore — fall back to status-only message
+    }
+    return { ok: false, status: response.status, message };
+};
+exports.postOtlp = postOtlp;
+//# sourceMappingURL=exporter.js.map

package/dist/exporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exporter.js","sourceRoot":"","sources":["../src/exporter.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @kubit-ai/sentry — tee Sentry events (errors + transactions) to Kubit as
+ * OTLP for behavior analytics.
+ *
+ * Usage (idiomatic):
+ *     import * as Sentry from "@sentry/react";
+ *     import { kubitSentryIntegration } from "@kubit-ai/sentry";
+ *
+ *     Sentry.init({
+ *       dsn: "https://...@sentry.io/...",
+ *       integrations: [
+ *         kubitSentryIntegration({ apiKey: "rg.v1...", serviceName: "my-app" }),
+ *       ],
+ *     });
+ *
+ * `apiKey` is the workspace ingestion key you mint in the Kubit app; pass it as
+ * an option (required in the browser) or set `KUBIT_OTEL_API_KEY` in Node. The
+ * endpoint defaults to `https://otel.kubit.ai/v1/traces` (override via `endpoint`
+ * or `KUBIT_OTEL_ENDPOINT` only for a non-prod Kubit env).
+ *
+ * This SDK does NOT replace Sentry — it runs alongside it and ships a copy of
+ * each event to Kubit so the data can be modeled and displayed in the Kubit
+ * product.
+ */
+export { kubitSentryIntegration } from "./integration";
+export { resolveConfig, DEFAULT_ENDPOINT, type KubitSentryOptions, type KubitSentryConfig, } from "./config";
+export { createRollingSession, type RollingSessionOptions, type SessionIdProvider, type SessionStorageLike, } from "./session";
+export { sentryEventToOtlp, sentryTransactionToOtlp, sentryErrorToOtlp, } from "./sentryToOtel";
+export { postOtlp, type PostResult } from "./exporter";
+export type { OtlpExportRequest, OtlpSpan, OtlpSpanEvent, OtlpKeyValue, OtlpAnyValue, } from "./types";

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * @kubit-ai/sentry — tee Sentry events (errors + transactions) to Kubit as
+ * OTLP for behavior analytics.
+ *
+ * Usage (idiomatic):
+ *     import * as Sentry from "@sentry/react";
+ *     import { kubitSentryIntegration } from "@kubit-ai/sentry";
+ *
+ *     Sentry.init({
+ *       dsn: "https://...@sentry.io/...",
+ *       integrations: [
+ *         kubitSentryIntegration({ apiKey: "rg.v1...", serviceName: "my-app" }),
+ *       ],
+ *     });
+ *
+ * `apiKey` is the workspace ingestion key you mint in the Kubit app; pass it as
+ * an option (required in the browser) or set `KUBIT_OTEL_API_KEY` in Node. The
+ * endpoint defaults to `https://otel.kubit.ai/v1/traces` (override via `endpoint`
+ * or `KUBIT_OTEL_ENDPOINT` only for a non-prod Kubit env).
+ *
+ * This SDK does NOT replace Sentry — it runs alongside it and ships a copy of
+ * each event to Kubit so the data can be modeled and displayed in the Kubit
+ * product.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postOtlp = exports.sentryErrorToOtlp = exports.sentryTransactionToOtlp = exports.sentryEventToOtlp = exports.createRollingSession = exports.DEFAULT_ENDPOINT = exports.resolveConfig = exports.kubitSentryIntegration = void 0;
+var integration_1 = require("./integration");
+Object.defineProperty(exports, "kubitSentryIntegration", { enumerable: true, get: function () { return integration_1.kubitSentryIntegration; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "resolveConfig", { enumerable: true, get: function () { return config_1.resolveConfig; } });
+Object.defineProperty(exports, "DEFAULT_ENDPOINT", { enumerable: true, get: function () { return config_1.DEFAULT_ENDPOINT; } });
+var session_1 = require("./session");
+Object.defineProperty(exports, "createRollingSession", { enumerable: true, get: function () { return session_1.createRollingSession; } });
+var sentryToOtel_1 = require("./sentryToOtel");
+Object.defineProperty(exports, "sentryEventToOtlp", { enumerable: true, get: function () { return sentryToOtel_1.sentryEventToOtlp; } });
+Object.defineProperty(exports, "sentryTransactionToOtlp", { enumerable: true, get: function () { return sentryToOtel_1.sentryTransactionToOtlp; } });
+Object.defineProperty(exports, "sentryErrorToOtlp", { enumerable: true, get: function () { return sentryToOtel_1.sentryErrorToOtlp; } });
+var exporter_1 = require("./exporter");
+Object.defineProperty(exports, "postOtlp", { enumerable: true, get: function () { return exporter_1.postOtlp; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;;;AAEH,6CAAuD;AAA9C,qHAAA,sBAAsB,OAAA;AAC/B,mCAKkB;AAJhB,uGAAA,aAAa,OAAA;AACb,0GAAA,gBAAgB,OAAA;AAIlB,qCAKmB;AAJjB,+GAAA,oBAAoB,OAAA;AAKtB,+CAIwB;AAHtB,iHAAA,iBAAiB,OAAA;AACjB,uHAAA,uBAAuB,OAAA;AACvB,iHAAA,iBAAiB,OAAA;AAEnB,uCAAuD;AAA9C,oGAAA,QAAQ,OAAA"}

package/dist/integration.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Public wiring for teeing Sentry events into Kubit.
+ *
+ * `kubitSentryIntegration(options)` — the idiomatic Sentry v8+ functional
+ * integration. Add it to `Sentry.init({ integrations: [...] })`. It registers
+ * on the client's single `afterSendEvent` hook, which covers BOTH error and
+ * transaction events, so Kubit receives a copy of exactly what Sentry sends —
+ * after sampling, event processors, and the app's own `beforeSend` /
+ * `beforeSendTransaction` scrubbing. Events dropped before sending never reach
+ * Kubit. The integration is non-destructive: it never drops or mutates the
+ * event Sentry sends.
+ *
+ * `teeEvent` does the work: translate -> fire-and-forget OTLP POST. Export
+ * errors are swallowed (optionally logged when `debug: true`) so a failing
+ * Kubit endpoint can never break the host app's Sentry pipeline.
+ */
+import type { Integration } from "@sentry/core";
+import { type KubitSentryOptions } from "./config";
+/**
+ * Sentry functional integration. Usage:
+ *
+ *     Sentry.init({
+ *       dsn: "...",
+ *       environment: "production",
+ *       integrations: [
+ *         kubitSentryIntegration({ apiKey: "rg.v1...", serviceName: "my-app" }),
+ *       ],
+ *     });
+ *
+ * `apiKey` is the Kubit workspace ingestion key (required; pass it as an option
+ * — mandatory in the browser — or set `KUBIT_OTEL_API_KEY` in Node). `endpoint`
+ * defaults to the prod collector (override via `endpoint` / `KUBIT_OTEL_ENDPOINT`
+ * only for a non-prod Kubit env). `environment` is a Sentry.init field, not a
+ * Kubit option — the tee copies the event's environment to
+ * `deployment.environment`.
+ *
+ * Tees on `afterSendEvent` (not `processEvent`) so the copy sent to Kubit
+ * reflects sampling, event processors, and the app's `beforeSend` scrubbing —
+ * events Sentry drops are never exported.
+ */
+export declare const kubitSentryIntegration: (options?: KubitSentryOptions) => Integration;

package/dist/integration.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Public wiring for teeing Sentry events into Kubit.
+ *
+ * `kubitSentryIntegration(options)` — the idiomatic Sentry v8+ functional
+ * integration. Add it to `Sentry.init({ integrations: [...] })`. It registers
+ * on the client's single `afterSendEvent` hook, which covers BOTH error and
+ * transaction events, so Kubit receives a copy of exactly what Sentry sends —
+ * after sampling, event processors, and the app's own `beforeSend` /
+ * `beforeSendTransaction` scrubbing. Events dropped before sending never reach
+ * Kubit. The integration is non-destructive: it never drops or mutates the
+ * event Sentry sends.
+ *
+ * `teeEvent` does the work: translate -> fire-and-forget OTLP POST. Export
+ * errors are swallowed (optionally logged when `debug: true`) so a failing
+ * Kubit endpoint can never break the host app's Sentry pipeline.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kubitSentryIntegration = void 0;
+const config_1 = require("./config");
+const exporter_1 = require("./exporter");
+const sentryToOtel_1 = require("./sentryToOtel");
+const INTEGRATION_NAME = "KubitSentry";
+const teeEvent = (event, config) => {
+    if (!config.apiKey) {
+        return;
+    }
+    // Only tee error and transaction events; ignore replay/profile/feedback/etc.
+    if (event.type !== undefined && event.type !== "transaction") {
+        return;
+    }
+    // Resolved here, at the impure boundary, so the transform stays pure: a
+    // rolling session reads the clock / storage on each tee.
+    const sessionId = config.getSessionId?.();
+    let payload;
+    try {
+        payload = (0, sentryToOtel_1.sentryEventToOtlp)(event, config, sessionId);
+    }
+    catch {
+        return;
+    }
+    if ((payload.resourceSpans[0]?.scopeSpans[0]?.spans.length ?? 0) === 0) {
+        return;
+    }
+    void (0, exporter_1.postOtlp)(payload, config)
+        .then((result) => {
+        if (!config.debug) {
+            return;
+        }
+        const spans = payload.resourceSpans[0]?.scopeSpans[0]?.spans ?? [];
+        const names = spans.map((s) => s.name);
+        if (result.ok) {
+            console.info(`[kubit-sentry] sent ${spans.length} span(s) → ${config.endpoint} [${result.status}]`, names);
+        }
+        else {
+            console.warn(`[kubit-sentry] export failed: ${result.status} ${result.message ?? ""}`, names);
+        }
+    })
+        .catch(() => {
+        // postOtlp never throws; defend against it anyway.
+    });
+};
+/**
+ * Sentry functional integration. Usage:
+ *
+ *     Sentry.init({
+ *       dsn: "...",
+ *       environment: "production",
+ *       integrations: [
+ *         kubitSentryIntegration({ apiKey: "rg.v1...", serviceName: "my-app" }),
+ *       ],
+ *     });
+ *
+ * `apiKey` is the Kubit workspace ingestion key (required; pass it as an option
+ * — mandatory in the browser — or set `KUBIT_OTEL_API_KEY` in Node). `endpoint`
+ * defaults to the prod collector (override via `endpoint` / `KUBIT_OTEL_ENDPOINT`
+ * only for a non-prod Kubit env). `environment` is a Sentry.init field, not a
+ * Kubit option — the tee copies the event's environment to
+ * `deployment.environment`.
+ *
+ * Tees on `afterSendEvent` (not `processEvent`) so the copy sent to Kubit
+ * reflects sampling, event processors, and the app's `beforeSend` scrubbing —
+ * events Sentry drops are never exported.
+ */
+const kubitSentryIntegration = (options = {}) => {
+    const config = (0, config_1.resolveConfig)(options);
+    return {
+        name: INTEGRATION_NAME,
+        setup(client) {
+            client.on("afterSendEvent", (event) => {
+                teeEvent(event, config);
+            });
+        },
+    };
+};
+exports.kubitSentryIntegration = kubitSentryIntegration;
+//# sourceMappingURL=integration.js.map

package/dist/integration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.js","sourceRoot":"","sources":["../src/integration.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAGH,qCAIkB;AAClB,yCAAsC;AACtC,iDAAmD;AAEnD,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAEvC,MAAM,QAAQ,GAAG,CAAC,KAAY,EAAE,MAAyB,EAAQ,EAAE;IACjE,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACnB,OAAO;IACT,CAAC;IACD,6EAA6E;IAC7E,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;QAC7D,OAAO;IACT,CAAC;IAED,wEAAwE;IACxE,yDAAyD;IACzD,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,EAAE,EAAE,CAAC;IAE1C,IAAI,OAAO,CAAC;IACZ,IAAI,CAAC;QACH,OAAO,GAAG,IAAA,gCAAiB,EAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO;IACT,CAAC;IACD,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;QACvE,OAAO;IACT,CAAC;IAED,KAAK,IAAA,mBAAQ,EAAC,OAAO,EAAE,MAAM,CAAC;SAC3B,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;QACf,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QACD,MAAM,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC;QACnE,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,EAAE,EAAE,CAAC;YACd,OAAO,CAAC,IAAI,CACV,uBAAuB,KAAK,CAAC,MAAM,cAAc,MAAM,CAAC,QAAQ,KAAK,MAAM,CAAC,MAAM,GAAG,EACrF,KAAK,CACN,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,IAAI,CACV,iCAAiC,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO,IAAI,EAAE,EAAE,EACxE,KAAK,CACN,CAAC;QACJ,CAAC;IACH,CAAC,CAAC;SACD,KAAK,CAAC,GAAG,EAAE;QACV,mDAAmD;IACrD,CAAC,CAAC,CAAC;AACP,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACI,MAAM,sBAAsB,GAAG,CACpC,UAA8B,EAAE,EACnB,EAAE;IACf,MAAM,MAAM,GAAG,IAAA,sBAAa,EAAC,OAAO,CAAC,CAAC;IACtC,OAAO;QACL,IAAI,EAAE,gBAAgB;QACtB,KAAK,CAAC,MAAM;YACV,MAAM,CAAC,EAAE,CAAC,gBAAgB,EAAE,CAAC,KAAK,EAAE,EAAE;gBACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YAC1B,CAAC,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAZW,QAAA,sBAAsB,0BAYjC"}

package/dist/sentryToOtel.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Sentry `Event` -> OTLP/HTTP+JSON (`ExportTraceServiceRequest`).
+ *
+ * Two entry points behind one dispatcher (`sentryEventToOtlp`):
+ *   - transactions (`event.type === 'transaction'`) -> spans (root from
+ *     `contexts.trace`, one child per `event.spans[]`).
+ *   - errors (everything else) -> a single span carrying an `exception` span
+ *     event per `exception.values[]`, with `status.code = ERROR`.
+ *
+ * Pure functions — no Sentry SDK calls, no I/O, no randomness. Error events
+ * without a trace context are anchored on the Sentry `event_id` (a 32-hex
+ * string, valid as an OTLP trace id) so the transform stays deterministic.
+ */
+import type { Event, TransactionEvent } from "@sentry/core";
+import type { OtlpExportRequest } from "./types";
+import type { KubitSentryConfig } from "./config";
+export declare const sentryTransactionToOtlp: (event: TransactionEvent, config: KubitSentryConfig, sessionId?: string) => OtlpExportRequest;
+export declare const sentryErrorToOtlp: (event: Event, config: KubitSentryConfig, sessionId?: string) => OtlpExportRequest;
+/**
+ * Dispatcher: route a Sentry event to the right transform by `event.type`.
+ * Transactions carry `type: 'transaction'`; error events leave it undefined.
+ */
+export declare const sentryEventToOtlp: (event: Event, config: KubitSentryConfig, sessionId?: string) => OtlpExportRequest;