@owlmetry/node 0.1.0

package/dist/src/configuration.d.ts

@@ -0,0 +1,13 @@
+import type { OwlConfiguration } from "./types.js";
+export interface ValidatedConfig {
+    endpoint: string;
+    apiKey: string;
+    serviceName: string;
+    appVersion?: string;
+    debug: boolean;
+    isDev: boolean;
+    flushIntervalMs: number;
+    flushThreshold: number;
+    maxBufferSize: number;
+}
+export declare function validateConfiguration(config: OwlConfiguration): ValidatedConfig;

package/dist/src/configuration.js

@@ -0,0 +1,34 @@
+const CLIENT_KEY_PREFIX = "owl_client_";
+export function validateConfiguration(config) {
+    if (!config.endpoint || typeof config.endpoint !== "string") {
+        throw new Error("OwlMetry: endpoint is required");
+    }
+    let endpoint = config.endpoint;
+    // Strip trailing slash
+    if (endpoint.endsWith("/")) {
+        endpoint = endpoint.slice(0, -1);
+    }
+    try {
+        new URL(endpoint);
+    }
+    catch {
+        throw new Error(`OwlMetry: invalid endpoint URL: ${endpoint}`);
+    }
+    if (!config.apiKey || typeof config.apiKey !== "string") {
+        throw new Error("OwlMetry: apiKey is required");
+    }
+    if (!config.apiKey.startsWith(CLIENT_KEY_PREFIX)) {
+        throw new Error(`OwlMetry: apiKey must start with "${CLIENT_KEY_PREFIX}"`);
+    }
+    return {
+        endpoint,
+        apiKey: config.apiKey,
+        serviceName: config.serviceName || "unknown",
+        appVersion: config.appVersion,
+        debug: config.debug ?? false,
+        isDev: config.isDev ?? (process.env.NODE_ENV !== "production"),
+        flushIntervalMs: config.flushIntervalMs ?? 5000,
+        flushThreshold: config.flushThreshold ?? 20,
+        maxBufferSize: config.maxBufferSize ?? 10000,
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,90 @@
+import type { OwlConfiguration } from "./types.js";
+import { Operation } from "./operation.js";
+export type { OwlConfiguration, LogLevel, LogEvent } from "./types.js";
+export { Operation } from "./operation.js";
+/**
+ * A scoped logger instance that automatically sets a user ID on all events.
+ */
+export declare class ScopedOwl {
+    private userId;
+    constructor(userId: string);
+    info(message: string, attrs?: Record<string, unknown>): void;
+    debug(message: string, attrs?: Record<string, unknown>): void;
+    warn(message: string, attrs?: Record<string, unknown>): void;
+    error(message: string, attrs?: Record<string, unknown>): void;
+    /**
+     * Track a named step (e.g. funnel step, user action). Sends an info-level event
+     * with message `track:<stepName>`.
+     */
+    track(stepName: string, attributes?: Record<string, string>): void;
+    /**
+     * Start a tracked operation. The `metric` slug should contain only lowercase letters,
+     * numbers, and hyphens (e.g. "photo-conversion", "api-request"). Invalid characters
+     * are auto-corrected with a warning logged in debug mode.
+     */
+    startOperation(metric: string, attrs?: Record<string, unknown>): Operation;
+    /**
+     * Record a single-shot metric. The `metric` slug should contain only lowercase letters,
+     * numbers, and hyphens (e.g. "onboarding", "checkout"). Invalid characters are
+     * auto-corrected with a warning logged in debug mode.
+     */
+    recordMetric(metric: string, attrs?: Record<string, unknown>): void;
+}
+/**
+ * OwlMetry Node.js Server SDK.
+ *
+ * Usage:
+ * ```
+ * import { Owl } from '@owlmetry/node';
+ *
+ * Owl.configure({ endpoint: 'https://...', apiKey: 'owl_client_...' });
+ * Owl.info('Server started');
+ *
+ * const owl = Owl.withUser('user_123');
+ * owl.info('User logged in');
+ *
+ * await Owl.shutdown();
+ * ```
+ */
+export declare const Owl: {
+    configure(options: OwlConfiguration): void;
+    info(message: string, attrs?: Record<string, unknown>): void;
+    debug(message: string, attrs?: Record<string, unknown>): void;
+    warn(message: string, attrs?: Record<string, unknown>): void;
+    error(message: string, attrs?: Record<string, unknown>): void;
+    /**
+     * Track a named step (e.g. funnel step, user action). Sends an info-level event
+     * with message `track:<stepName>`.
+     */
+    track(stepName: string, attributes?: Record<string, string>): void;
+    /**
+     * Get the assigned variant for an experiment. On first call, picks a random variant
+     * from `options` and persists the assignment. Future calls return the stored variant
+     * (the `options` parameter is ignored after the first assignment).
+     */
+    getVariant(name: string, options: string[]): string;
+    /**
+     * Force a specific variant for an experiment. Persists immediately.
+     */
+    setExperiment(name: string, variant: string): void;
+    /**
+     * Reset all experiment assignments. Persists immediately.
+     */
+    clearExperiments(): void;
+    /**
+     * Start a tracked operation. The `metric` slug should contain only lowercase letters,
+     * numbers, and hyphens (e.g. "photo-conversion", "api-request"). Invalid characters
+     * are auto-corrected with a warning logged in debug mode.
+     */
+    startOperation(metric: string, attrs?: Record<string, unknown>): Operation;
+    /**
+     * Record a single-shot metric. The `metric` slug should contain only lowercase letters,
+     * numbers, and hyphens (e.g. "onboarding", "checkout"). Invalid characters are
+     * auto-corrected with a warning logged in debug mode.
+     */
+    recordMetric(metric: string, attrs?: Record<string, unknown>): void;
+    withUser(userId: string): ScopedOwl;
+    flush(): Promise<void>;
+    wrapHandler<TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+    shutdown(): Promise<void>;
+};

package/dist/src/index.js

@@ -0,0 +1,299 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { validateConfiguration } from "./configuration.js";
+import { Transport } from "./transport.js";
+import { Operation } from "./operation.js";
+export { Operation } from "./operation.js";
+const MAX_ATTRIBUTE_VALUE_LENGTH = 200;
+const SLUG_REGEX = /^[a-z0-9-]+$/;
+const TRACK_MESSAGE_PREFIX = "track:";
+const EXPERIMENTS_DIR = join(homedir(), ".owlmetry");
+const EXPERIMENTS_FILE = join(EXPERIMENTS_DIR, "experiments.json");
+let experiments = {};
+function loadExperiments() {
+    try {
+        const data = readFileSync(EXPERIMENTS_FILE, "utf-8");
+        const parsed = JSON.parse(data);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            experiments = parsed;
+        }
+    }
+    catch {
+        // File doesn't exist or is invalid — start with empty experiments
+        experiments = {};
+    }
+}
+function saveExperiments() {
+    try {
+        mkdirSync(EXPERIMENTS_DIR, { recursive: true });
+        writeFileSync(EXPERIMENTS_FILE, JSON.stringify(experiments, null, 2), "utf-8");
+    }
+    catch (err) {
+        if (config?.debug) {
+            console.error("OwlMetry: failed to save experiments:", err);
+        }
+    }
+}
+/**
+ * Normalize a metric slug to contain only lowercase letters, numbers, and hyphens.
+ * Logs a warning if the slug was modified. Returns the normalized slug.
+ */
+function normalizeSlug(slug) {
+    if (SLUG_REGEX.test(slug))
+        return slug;
+    const normalized = slug
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/-{2,}/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (config?.debug) {
+        console.error(`OwlMetry: metric slug "${slug}" was auto-corrected to "${normalized}". Slugs should contain only lowercase letters, numbers, and hyphens.`);
+    }
+    return normalized;
+}
+function getSourceModule() {
+    const err = new Error();
+    const stack = err.stack;
+    if (!stack)
+        return undefined;
+    const lines = stack.split("\n");
+    // Skip: Error, at Object.<method> (index.ts), at Owl.<method> / ScopedOwl.<method>
+    // Find the first frame outside this file
+    for (let i = 3; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.includes("node:") || line.includes("node_modules"))
+            continue;
+        // Extract file:line from "at <something> (file:line:col)" or "at file:line:col"
+        const parenMatch = line.match(/\((.+):(\d+):\d+\)$/);
+        if (parenMatch)
+            return `${parenMatch[1]}:${parenMatch[2]}`;
+        const directMatch = line.match(/at (.+):(\d+):\d+$/);
+        if (directMatch)
+            return `${directMatch[1]}:${directMatch[2]}`;
+    }
+    return undefined;
+}
+function normalizeAttributes(attrs) {
+    if (!attrs || Object.keys(attrs).length === 0)
+        return undefined;
+    const result = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        let str = String(value);
+        if (str.length > MAX_ATTRIBUTE_VALUE_LENGTH) {
+            str = str.slice(0, MAX_ATTRIBUTE_VALUE_LENGTH);
+        }
+        result[key] = str;
+    }
+    return result;
+}
+let config = null;
+let transport = null;
+let sessionId = null;
+let beforeExitRegistered = false;
+function ensureConfigured() {
+    if (!config || !transport || !sessionId) {
+        throw new Error("OwlMetry: not configured. Call Owl.configure() first.");
+    }
+    return { config, transport, sessionId };
+}
+function createEvent(ctx, level, message, attrs, userId) {
+    return {
+        client_event_id: randomUUID(),
+        session_id: ctx.sessionId,
+        ...(userId ? { user_id: userId } : {}),
+        level,
+        source_module: getSourceModule(),
+        message,
+        custom_attributes: normalizeAttributes(attrs),
+        ...(Object.keys(experiments).length > 0 ? { experiments: { ...experiments } } : {}),
+        environment: "backend",
+        ...(ctx.config.appVersion ? { app_version: ctx.config.appVersion } : {}),
+        is_dev: ctx.config.isDev,
+        timestamp: new Date().toISOString(),
+    };
+}
+function log(level, message, attrs, userId) {
+    try {
+        const ctx = ensureConfigured();
+        const event = createEvent(ctx, level, message, attrs, userId);
+        ctx.transport.enqueue(event);
+    }
+    catch (err) {
+        if (config?.debug) {
+            console.error("OwlMetry:", err);
+        }
+    }
+}
+/**
+ * A scoped logger instance that automatically sets a user ID on all events.
+ */
+export class ScopedOwl {
+    userId;
+    constructor(userId) {
+        this.userId = userId;
+    }
+    info(message, attrs) {
+        log("info", message, attrs, this.userId);
+    }
+    debug(message, attrs) {
+        log("debug", message, attrs, this.userId);
+    }
+    warn(message, attrs) {
+        log("warn", message, attrs, this.userId);
+    }
+    error(message, attrs) {
+        log("error", message, attrs, this.userId);
+    }
+    /**
+     * Track a named step (e.g. funnel step, user action). Sends an info-level event
+     * with message `track:<stepName>`.
+     */
+    track(stepName, attributes) {
+        log("info", `${TRACK_MESSAGE_PREFIX}${stepName}`, attributes, this.userId);
+    }
+    /**
+     * Start a tracked operation. The `metric` slug should contain only lowercase letters,
+     * numbers, and hyphens (e.g. "photo-conversion", "api-request"). Invalid characters
+     * are auto-corrected with a warning logged in debug mode.
+     */
+    startOperation(metric, attrs) {
+        return new Operation(log, normalizeSlug(metric), attrs, this.userId);
+    }
+    /**
+     * Record a single-shot metric. The `metric` slug should contain only lowercase letters,
+     * numbers, and hyphens (e.g. "onboarding", "checkout"). Invalid characters are
+     * auto-corrected with a warning logged in debug mode.
+     */
+    recordMetric(metric, attrs) {
+        log("info", `metric:${normalizeSlug(metric)}:record`, attrs, this.userId);
+    }
+}
+/**
+ * OwlMetry Node.js Server SDK.
+ *
+ * Usage:
+ * ```
+ * import { Owl } from '@owlmetry/node';
+ *
+ * Owl.configure({ endpoint: 'https://...', apiKey: 'owl_client_...' });
+ * Owl.info('Server started');
+ *
+ * const owl = Owl.withUser('user_123');
+ * owl.info('User logged in');
+ *
+ * await Owl.shutdown();
+ * ```
+ */
+export const Owl = {
+    configure(options) {
+        // Clean up previous transport if reconfiguring
+        if (transport) {
+            transport.shutdown().catch(() => { });
+        }
+        config = validateConfiguration(options);
+        transport = new Transport(config);
+        sessionId = randomUUID();
+        loadExperiments();
+        if (!beforeExitRegistered) {
+            beforeExitRegistered = true;
+            process.on("beforeExit", async () => {
+                if (transport && transport.bufferSize > 0) {
+                    await transport.flush();
+                }
+            });
+        }
+    },
+    info(message, attrs) {
+        log("info", message, attrs);
+    },
+    debug(message, attrs) {
+        log("debug", message, attrs);
+    },
+    warn(message, attrs) {
+        log("warn", message, attrs);
+    },
+    error(message, attrs) {
+        log("error", message, attrs);
+    },
+    /**
+     * Track a named step (e.g. funnel step, user action). Sends an info-level event
+     * with message `track:<stepName>`.
+     */
+    track(stepName, attributes) {
+        log("info", `${TRACK_MESSAGE_PREFIX}${stepName}`, attributes);
+    },
+    /**
+     * Get the assigned variant for an experiment. On first call, picks a random variant
+     * from `options` and persists the assignment. Future calls return the stored variant
+     * (the `options` parameter is ignored after the first assignment).
+     */
+    getVariant(name, options) {
+        if (experiments[name]) {
+            return experiments[name];
+        }
+        if (options.length === 0) {
+            throw new Error(`OwlMetry: getVariant("${name}") called with empty options array.`);
+        }
+        const variant = options[Math.floor(Math.random() * options.length)];
+        experiments[name] = variant;
+        saveExperiments();
+        return variant;
+    },
+    /**
+     * Force a specific variant for an experiment. Persists immediately.
+     */
+    setExperiment(name, variant) {
+        experiments[name] = variant;
+        saveExperiments();
+    },
+    /**
+     * Reset all experiment assignments. Persists immediately.
+     */
+    clearExperiments() {
+        experiments = {};
+        saveExperiments();
+    },
+    /**
+     * Start a tracked operation. The `metric` slug should contain only lowercase letters,
+     * numbers, and hyphens (e.g. "photo-conversion", "api-request"). Invalid characters
+     * are auto-corrected with a warning logged in debug mode.
+     */
+    startOperation(metric, attrs) {
+        return new Operation(log, normalizeSlug(metric), attrs);
+    },
+    /**
+     * Record a single-shot metric. The `metric` slug should contain only lowercase letters,
+     * numbers, and hyphens (e.g. "onboarding", "checkout"). Invalid characters are
+     * auto-corrected with a warning logged in debug mode.
+     */
+    recordMetric(metric, attrs) {
+        log("info", `metric:${normalizeSlug(metric)}:record`, attrs);
+    },
+    withUser(userId) {
+        return new ScopedOwl(userId);
+    },
+    async flush() {
+        if (transport)
+            await transport.flush();
+    },
+    wrapHandler(handler) {
+        return async (...args) => {
+            try {
+                return await handler(...args);
+            }
+            finally {
+                await Owl.flush();
+            }
+        };
+    },
+    async shutdown() {
+        if (transport) {
+            await transport.shutdown();
+            transport = null;
+        }
+        config = null;
+        sessionId = null;
+    },
+};

package/dist/src/operation.d.ts

@@ -0,0 +1,19 @@
+export type LogFn = (level: "info" | "error", message: string, attrs?: Record<string, unknown>, userId?: string) => void;
+/**
+ * Tracks a metric operation lifecycle (start → complete/fail/cancel).
+ * Created by `Owl.startOperation()` or `ScopedOwl.startOperation()`.
+ */
+export declare class Operation {
+    readonly trackingId: string;
+    private metric;
+    private startTime;
+    private userId?;
+    private log;
+    constructor(log: LogFn, metric: string, attrs?: Record<string, unknown>, userId?: string);
+    /** Complete the operation successfully. Auto-adds duration_ms. */
+    complete(attrs?: Record<string, unknown>): void;
+    /** Record a failed operation. Auto-adds duration_ms + error. */
+    fail(error: string, attrs?: Record<string, unknown>): void;
+    /** Cancel the operation. Auto-adds duration_ms. */
+    cancel(attrs?: Record<string, unknown>): void;
+}

package/dist/src/operation.js

@@ -0,0 +1,49 @@
+import { randomUUID } from "node:crypto";
+/**
+ * Tracks a metric operation lifecycle (start → complete/fail/cancel).
+ * Created by `Owl.startOperation()` or `ScopedOwl.startOperation()`.
+ */
+export class Operation {
+    trackingId;
+    metric;
+    startTime;
+    userId;
+    log;
+    constructor(log, metric, attrs, userId) {
+        this.trackingId = randomUUID();
+        this.metric = metric;
+        this.startTime = Date.now();
+        this.userId = userId;
+        this.log = log;
+        const startAttrs = { ...attrs, tracking_id: this.trackingId };
+        this.log("info", `metric:${metric}:start`, startAttrs, userId);
+    }
+    /** Complete the operation successfully. Auto-adds duration_ms. */
+    complete(attrs) {
+        const combined = {
+            ...attrs,
+            tracking_id: this.trackingId,
+            duration_ms: String(Date.now() - this.startTime),
+        };
+        this.log("info", `metric:${this.metric}:complete`, combined, this.userId);
+    }
+    /** Record a failed operation. Auto-adds duration_ms + error. */
+    fail(error, attrs) {
+        const combined = {
+            ...attrs,
+            tracking_id: this.trackingId,
+            duration_ms: String(Date.now() - this.startTime),
+            error,
+        };
+        this.log("error", `metric:${this.metric}:fail`, combined, this.userId);
+    }
+    /** Cancel the operation. Auto-adds duration_ms. */
+    cancel(attrs) {
+        const combined = {
+            ...attrs,
+            tracking_id: this.trackingId,
+            duration_ms: String(Date.now() - this.startTime),
+        };
+        this.log("info", `metric:${this.metric}:cancel`, combined, this.userId);
+    }
+}

package/dist/src/transport.d.ts

@@ -0,0 +1,14 @@
+import type { ValidatedConfig } from "./configuration.js";
+import type { LogEvent } from "./types.js";
+export declare class Transport {
+    private buffer;
+    private timer;
+    private config;
+    private flushing;
+    constructor(config: ValidatedConfig);
+    enqueue(event: LogEvent): void;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    get bufferSize(): number;
+    private sendBatch;
+}

package/dist/src/transport.js

@@ -0,0 +1,111 @@
+import { gzipSync } from "node:zlib";
+const GZIP_THRESHOLD = 512;
+const MAX_BATCH_SIZE = 20;
+const MAX_RETRIES = 5;
+const MAX_BACKOFF_MS = 30000;
+const REQUEST_TIMEOUT_MS = 10000;
+export class Transport {
+    buffer = [];
+    timer = null;
+    config;
+    flushing = false;
+    constructor(config) {
+        this.config = config;
+        this.timer = setInterval(() => this.flush(), config.flushIntervalMs);
+        // Prevent timer from keeping the process alive
+        if (this.timer.unref) {
+            this.timer.unref();
+        }
+    }
+    enqueue(event) {
+        if (this.buffer.length >= this.config.maxBufferSize) {
+            // Drop oldest events
+            this.buffer.shift();
+        }
+        this.buffer.push(event);
+        if (this.buffer.length >= this.config.flushThreshold) {
+            this.flush();
+        }
+    }
+    async flush() {
+        if (this.buffer.length === 0 || this.flushing)
+            return;
+        this.flushing = true;
+        try {
+            while (this.buffer.length > 0) {
+                const batch = this.buffer.splice(0, MAX_BATCH_SIZE);
+                await this.sendBatch(batch);
+            }
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    async shutdown() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        await this.flush();
+    }
+    get bufferSize() {
+        return this.buffer.length;
+    }
+    async sendBatch(events) {
+        const body = { events };
+        const json = JSON.stringify(body);
+        let payload;
+        let contentEncoding;
+        if (json.length > GZIP_THRESHOLD) {
+            payload = new Uint8Array(gzipSync(json));
+            contentEncoding = "gzip";
+        }
+        else {
+            payload = json;
+        }
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const headers = {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${this.config.apiKey}`,
+                };
+                if (contentEncoding) {
+                    headers["Content-Encoding"] = contentEncoding;
+                }
+                const res = await fetch(`${this.config.endpoint}/v1/ingest`, {
+                    method: "POST",
+                    headers,
+                    body: payload,
+                    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+                });
+                if (res.ok)
+                    return;
+                // Don't retry client errors (except 429)
+                if (res.status >= 400 && res.status < 500 && res.status !== 429) {
+                    if (this.config.debug) {
+                        const text = await res.text().catch(() => "");
+                        console.error(`OwlMetry: ingest failed with ${res.status}: ${text}`);
+                    }
+                    return;
+                }
+                // Server error or 429 — retry with backoff
+                if (attempt < MAX_RETRIES) {
+                    const backoff = Math.min(Math.pow(2, attempt) * 1000, MAX_BACKOFF_MS);
+                    await new Promise((r) => setTimeout(r, backoff));
+                }
+            }
+            catch (err) {
+                if (this.config.debug) {
+                    console.error("OwlMetry: network error during ingest", err);
+                }
+                if (attempt < MAX_RETRIES) {
+                    const backoff = Math.min(Math.pow(2, attempt) * 1000, MAX_BACKOFF_MS);
+                    await new Promise((r) => setTimeout(r, backoff));
+                }
+            }
+        }
+        if (this.config.debug) {
+            console.error(`OwlMetry: failed to send batch after ${MAX_RETRIES + 1} attempts, dropping ${events.length} events`);
+        }
+    }
+}

package/dist/src/types.d.ts

@@ -0,0 +1,46 @@
+export type LogLevel = "info" | "debug" | "warn" | "error";
+export interface OwlConfiguration {
+    /** OwlMetry server endpoint URL */
+    endpoint: string;
+    /** Client API key for a server-platform app (must start with owl_client_) */
+    apiKey: string;
+    /** Service name for logging/debugging (not sent as bundle_id) */
+    serviceName?: string;
+    /** Application version */
+    appVersion?: string;
+    /** Enable debug logging to console.error */
+    debug?: boolean;
+    /** Flush interval in milliseconds (default: 5000) */
+    flushIntervalMs?: number;
+    /** Max events to buffer before auto-flush (default: 20) */
+    flushThreshold?: number;
+    /** Max events in buffer before dropping oldest (default: 10000) */
+    maxBufferSize?: number;
+    /** Mark events as development builds. Defaults to `process.env.NODE_ENV !== "production"` */
+    isDev?: boolean;
+}
+export interface LogEvent {
+    client_event_id: string;
+    session_id: string;
+    user_id?: string;
+    level: LogLevel;
+    source_module?: string;
+    message: string;
+    custom_attributes?: Record<string, string>;
+    experiments?: Record<string, string>;
+    environment: "backend";
+    app_version?: string;
+    is_dev?: boolean;
+    timestamp: string;
+}
+export interface IngestRequest {
+    events: LogEvent[];
+}
+export interface IngestResponse {
+    accepted: number;
+    rejected: number;
+    errors?: Array<{
+        index: number;
+        message: string;
+    }>;
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@owlmetry/node",
+  "version": "0.1.0",
+  "description": "OwlMetry Node.js Server SDK",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test tests/unit/*.test.js",
+    "test:integration": "node --test tests/integration/*.test.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Jasonvdb/owlmetry.git",
+    "directory": "sdks/node"
+  },
+  "homepage": "https://owlmetry.com",
+  "bugs": "https://github.com/Jasonvdb/owlmetry/issues",
+  "keywords": [
+    "owlmetry",
+    "analytics",
+    "metrics",
+    "funnels",
+    "logging",
+    "observability",
+    "node",
+    "sdk"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.9.3"
+  }
+}