@doow/track 0.1.0

package/dist/sidecar.cjs

@@ -0,0 +1,1285 @@
+#!/usr/bin/env node
+'use strict';
+
+var crypto = require('crypto');
+var zlib = require('zlib');
+var http = require('http');
+var fs = require('fs');
+var net = require('net');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var http__namespace = /*#__PURE__*/_interopNamespaceDefault(http);
+var net__namespace = /*#__PURE__*/_interopNamespaceDefault(net);
+
+/**
+ * UUID v4 generation — stdlib only, no dependencies.
+ */
+function generateUUID() {
+    return crypto.randomUUID();
+}
+
+function createDebugLogger(enabled) {
+    if (!enabled) {
+        return { log: () => undefined, warn: () => undefined };
+    }
+    return {
+        log: (msg, ...args) => {
+            // eslint-disable-next-line no-console
+            console.warn(`[doow/track] ${msg}`, ...args);
+        },
+        warn: (msg, ...args) => {
+            console.warn(`[doow/track:warn] ${msg}`, ...args);
+        },
+    };
+}
+
+/**
+ * S78: Exporter — HTTP transport + compression + retry
+ *
+ * Handles the *how* of delivery:
+ * - POST to {endpoint}/telemetry/events with gzip
+ * - Exponential backoff with ±20% jitter, max retryCount retries
+ * - 429 respects Retry-After header
+ * - 413 adaptive batch halving
+ * - Serialized flushes (one in-flight at a time)
+ * - Custom transport for testing/mTLS
+ * - onError callback — SDK never throws
+ */
+async function gzipBuffer(data) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const gz = zlib.createGzip();
+        gz.on('data', (chunk) => chunks.push(chunk));
+        gz.on('end', () => resolve(Buffer.concat(chunks)));
+        gz.on('error', reject);
+        gz.end(data);
+    });
+}
+const SDK_VERSION = "0.1.0";
+function toWireEvent(event) {
+    var _a;
+    const sourceSystem = ((_a = event.source_system) === null || _a === void 0 ? void 0 : _a.trim()) ? event.source_system : 'sdk';
+    const metricTupleHint = event.metric_tuple_hint;
+    return {
+        ...event,
+        occurred_at: event.timestamp,
+        source_system: sourceSystem,
+        ...(metricTupleHint ? { metric_tuple_hint: metricTupleHint } : {}),
+        measurements: [
+            {
+                metric_name: event.metric,
+                quantity: event.quantity,
+                ...(metricTupleHint ? { metric_tuple_hint: metricTupleHint } : {}),
+            },
+        ],
+    };
+}
+function toBatchPayload(batchId, events) {
+    return {
+        batch_id: batchId,
+        sdk_version: SDK_VERSION,
+        events: events.map(toWireEvent),
+    };
+}
+class Exporter {
+    constructor(config) {
+        this._pendingFlush = null;
+        this._adaptiveBatchSize = null;
+        this._stopped = false;
+        this._concurrentCount = 0;
+        this._concurrentQueue = [];
+        /** S79: Per-category rate limit state. Key = category name, value = expiry timestamp in ms */
+        this._rateLimits = new Map();
+        this.config = config;
+    }
+    /** Serialized flush: one HTTP request in-flight at a time */
+    async flush(events) {
+        var _a;
+        this._evictExpiredLimits();
+        // S79: If any rate limit is currently active, hold events (don't drop)
+        if (this._isRateLimited()) {
+            this.config.debug.log('Rate limited — holding events, skipping flush');
+            return;
+        }
+        // Chain onto any pending flush
+        const chain = (_a = this._pendingFlush) !== null && _a !== void 0 ? _a : Promise.resolve();
+        let resolve;
+        const next = new Promise((r) => {
+            resolve = r;
+        });
+        this._pendingFlush = next;
+        await chain;
+        try {
+            // S80: Drain offline store FIFO before new events
+            await this._drainOfflineStore();
+            await this._doFlush(events);
+        }
+        finally {
+            resolve();
+            if (this._pendingFlush === next) {
+                this._pendingFlush = null;
+            }
+        }
+    }
+    /** Mark stopped — 401 auth failure */
+    stop() {
+        this._stopped = true;
+    }
+    get stopped() {
+        return this._stopped;
+    }
+    /** S79: True if any active rate limit has not yet expired */
+    get rateLimited() {
+        return this._isRateLimited();
+    }
+    /** Wait for any in-flight flush to complete */
+    async drain() {
+        if (this._pendingFlush) {
+            await this._pendingFlush;
+        }
+    }
+    // ─── S79: Rate limit helpers ──────────────────────────────────────────────
+    _isRateLimited() {
+        const now = Date.now();
+        for (const [, entry] of this._rateLimits) {
+            if (now < entry.expiresAt)
+                return true;
+        }
+        return false;
+    }
+    _evictExpiredLimits() {
+        const now = Date.now();
+        for (const [category, entry] of this._rateLimits) {
+            if (now >= entry.expiresAt) {
+                this._rateLimits.delete(category);
+            }
+        }
+    }
+    /** Parse and apply X-Doow-Rate-Limits header from a 429 response */
+    _applyRateLimitHeader(headers) {
+        var _a;
+        const raw = (_a = headers['x-doow-rate-limits']) !== null && _a !== void 0 ? _a : headers['X-Doow-Rate-Limits'];
+        if (!raw)
+            return;
+        try {
+            const parsed = JSON.parse(raw);
+            const now = Date.now();
+            for (const [category, entry] of Object.entries(parsed)) {
+                if (typeof entry === 'object' &&
+                    entry !== null &&
+                    typeof entry.retry_after === 'number' &&
+                    entry.retry_after > 0) {
+                    const expiresAt = now + entry.retry_after * 1000;
+                    this._rateLimits.set(category, { expiresAt });
+                    this.config.debug.log(`Rate limit set: ${category} expires in ${entry.retry_after}s`);
+                }
+            }
+        }
+        catch {
+            // Malformed header — ignore gracefully
+            this.config.debug.warn('Malformed X-Doow-Rate-Limits header — ignored');
+        }
+    }
+    // ─── S80: Offline store helpers ───────────────────────────────────────────
+    /** Drain the offline store FIFO before sending new events */
+    async _drainOfflineStore() {
+        const store = this.config.offlineStore;
+        if (!store)
+            return;
+        try {
+            const len = await store.length();
+            if (len === 0)
+                return;
+            this.config.debug.log(`Draining ${len} batches from offline store`);
+        }
+        catch {
+            return;
+        }
+        // Drain FIFO — shift one batch at a time
+        let batch;
+        while ((batch = await store.shift()) !== undefined) {
+            try {
+                const payload = JSON.parse(batch.payload);
+                if (payload.events && payload.events.length > 0) {
+                    await this._sendWithRetry(payload.events, this.config.retryCount, payload.batch_id);
+                }
+            }
+            catch {
+                this.config.debug.warn(`Failed to replay offline batch ${batch.batch_id}`);
+            }
+        }
+    }
+    async _doFlush(events) {
+        var _a;
+        if (this._stopped || events.length === 0)
+            return;
+        const maxBatch = (_a = this._adaptiveBatchSize) !== null && _a !== void 0 ? _a : 500;
+        // Split into ≤500 event chunks
+        const chunks = [];
+        for (let i = 0; i < events.length; i += maxBatch) {
+            chunks.push(events.slice(i, i + maxBatch));
+        }
+        for (const chunk of chunks) {
+            await this._sendWithRetry(chunk, this.config.retryCount);
+        }
+    }
+    async _sendWithRetry(events, retriesLeft, batchId) {
+        var _a, _b;
+        if (this._stopped)
+            return;
+        const resolvedBatchId = batchId !== null && batchId !== void 0 ? batchId : generateUUID();
+        try {
+            await this._withConcurrencyLimit(() => this._sendOnce(events, resolvedBatchId));
+        }
+        catch (err) {
+            const sdkErr = err;
+            if (sdkErr.statusCode === 401) {
+                // Auth failure — stop permanently
+                this._stopped = true;
+                this.config.onError({
+                    kind: 'AUTH_FAILURE',
+                    message: 'API key rejected (401). Stopping SDK.',
+                    statusCode: 401,
+                });
+                return;
+            }
+            if (sdkErr.statusCode === 413) {
+                // Adaptive recovery — halve batch
+                const half = Math.max(1, Math.floor(events.length / 2));
+                this._adaptiveBatchSize = half;
+                this.config.debug.warn(`413 received — adaptive batch size reduced to ${half}`);
+                const first = events.slice(0, half);
+                const second = events.slice(half);
+                // Retry each half with full retry budget
+                await this._sendWithRetry(first, this.config.retryCount, resolvedBatchId);
+                if (second.length > 0) {
+                    await this._sendWithRetry(second, this.config.retryCount);
+                }
+                return;
+            }
+            if (sdkErr.statusCode === 429) {
+                // S79: Apply rate limit header from the response if present
+                if (sdkErr.rateLimitHeaders) {
+                    this._applyRateLimitHeader(sdkErr.rateLimitHeaders);
+                }
+                const retryAfterMs = (_a = sdkErr.retryAfterMs) !== null && _a !== void 0 ? _a : this._backoff(this.config.retryCount - retriesLeft);
+                this.config.debug.log(`429 rate limited — waiting ${retryAfterMs}ms`);
+                this.config.onError({
+                    kind: 'RATE_LIMITED',
+                    message: `Rate limited (429). Retry after ${retryAfterMs}ms.`,
+                    statusCode: 429,
+                    retryAfterMs,
+                });
+                if (retriesLeft <= 0)
+                    return;
+                await this._sleep(retryAfterMs);
+                return await this._sendWithRetry(events, retriesLeft - 1, resolvedBatchId);
+            }
+            if (retriesLeft <= 0) {
+                const errPayload = {
+                    kind: (_b = sdkErr.kind) !== null && _b !== void 0 ? _b : 'NETWORK_ERROR',
+                    message: sdkErr.message,
+                    rejectedEventIds: events.map((e) => e.event_id),
+                };
+                if (sdkErr.statusCode !== undefined)
+                    errPayload.statusCode = sdkErr.statusCode;
+                if (sdkErr.cause instanceof Error)
+                    errPayload.error = sdkErr.cause;
+                this.config.onError(errPayload);
+                // S80: Persist to offline store if configured
+                await this._persistToOfflineStore(resolvedBatchId, events);
+                return;
+            }
+            // Exponential backoff for non-429 retryable errors
+            const delay = this._backoff(this.config.retryCount - retriesLeft);
+            this.config.debug.log(`Retry in ${delay}ms, ${retriesLeft - 1} retries left`);
+            await this._sleep(delay);
+            await this._sendWithRetry(events, retriesLeft - 1, resolvedBatchId);
+        }
+    }
+    /** S80: Persist a failed batch to the offline store */
+    async _persistToOfflineStore(batchId, events) {
+        const store = this.config.offlineStore;
+        if (!store)
+            return;
+        try {
+            const payload = toBatchPayload(batchId, events);
+            const serialized = {
+                batch_id: batchId,
+                payload: JSON.stringify(payload),
+                timestamp: new Date().toISOString(),
+            };
+            await store.push(serialized);
+            this.config.debug.log(`Persisted failed batch ${batchId} to offline store`);
+        }
+        catch {
+            this.config.debug.warn(`Failed to persist batch ${batchId} to offline store`);
+        }
+    }
+    async _sendOnce(events, batchId) {
+        var _a, _b, _c;
+        const payload = toBatchPayload(batchId, events);
+        const jsonBuffer = Buffer.from(JSON.stringify(payload));
+        let body;
+        const headers = {
+            Authorization: `Bearer ${this.config.apiKey}`,
+            'Content-Type': 'application/json',
+            'X-Doow-SDK-Version': SDK_VERSION,
+        };
+        if (this.config.disableCompression) {
+            body = jsonBuffer;
+        }
+        else {
+            body = await gzipBuffer(jsonBuffer);
+            headers['Content-Encoding'] = 'gzip';
+        }
+        headers['Content-Length'] = String(body.length);
+        const url = `${this.config.endpoint}/telemetry/events`;
+        const transportPayload = { body, headers, url };
+        this.config.debug.log(`POST ${url} batch_id=${batchId} events=${events.length} bytes=${body.length}`);
+        let response;
+        try {
+            if (this.config.transport) {
+                response = await this._withTimeout(this.config.transport.send(transportPayload), this.config.timeout);
+            }
+            else {
+                response = await this._withTimeout(this._defaultTransport(transportPayload), this.config.timeout);
+            }
+        }
+        catch (err) {
+            const e = err;
+            if (e.name === 'AbortError' || ((_a = e.message) === null || _a === void 0 ? void 0 : _a.includes('timeout'))) {
+                throw new SdkHttpError('TIMEOUT', `Request timed out after ${this.config.timeout}ms`, undefined, undefined, e);
+            }
+            throw new SdkHttpError('NETWORK_ERROR', `Network error: ${e.message}`, undefined, undefined, e);
+        }
+        this.config.debug.log(`Response ${response.status} batch_id=${batchId}`);
+        if (response.status === 202) {
+            // Success — reset adaptive batch size
+            this._adaptiveBatchSize = null;
+            return;
+        }
+        if (response.status === 207) {
+            // Partial accept
+            try {
+                const parsed = JSON.parse(response.body);
+                if (((_b = parsed.rejected) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                    this.config.onError({
+                        kind: 'PARTIAL_ACCEPT',
+                        message: `Batch partially accepted — ${parsed.rejected.length} events rejected`,
+                        statusCode: 207,
+                        rejectedEventIds: parsed.rejected.map((r) => r.event_id),
+                    });
+                }
+            }
+            catch {
+                // Non-JSON 207 — treat as success
+            }
+            this._adaptiveBatchSize = null;
+            return;
+        }
+        if (response.status === 401) {
+            throw new SdkHttpError('AUTH_FAILURE', 'Unauthorized (401)', 401);
+        }
+        if (response.status === 413) {
+            throw new SdkHttpError('TRANSPORT_ERROR', 'Payload too large (413)', 413);
+        }
+        if (response.status === 429) {
+            const retryAfterMs = this._parseRetryAfter((_c = response.headers['retry-after']) !== null && _c !== void 0 ? _c : response.headers['Retry-After']);
+            throw new SdkHttpError('RATE_LIMITED', `Rate limited (429)`, 429, retryAfterMs, undefined, response.headers);
+        }
+        if (response.status >= 500) {
+            throw new SdkHttpError('TRANSPORT_ERROR', `Server error ${response.status}`, response.status);
+        }
+        // Other 4xx — don't retry
+        throw new SdkHttpError('TRANSPORT_ERROR', `HTTP ${response.status}`, response.status);
+    }
+    async _defaultTransport(payload) {
+        const { default: https } = await import('https');
+        const { default: http } = await import('http');
+        return new Promise((resolve, reject) => {
+            const url = new URL(payload.url);
+            const isHttps = url.protocol === 'https:';
+            const client = isHttps ? https : http;
+            const req = client.request({
+                hostname: url.hostname,
+                port: url.port || (isHttps ? 443 : 80),
+                path: url.pathname + url.search,
+                method: 'POST',
+                headers: payload.headers,
+            }, (res) => {
+                const chunks = [];
+                let totalBytes = 0;
+                const maxBodyBytes = 1024 * 1024; // 1 MB cap
+                res.on('data', (chunk) => {
+                    totalBytes += chunk.length;
+                    if (totalBytes <= maxBodyBytes)
+                        chunks.push(chunk);
+                });
+                res.on('end', () => {
+                    var _a, _b;
+                    const body = Buffer.concat(chunks).toString('utf8');
+                    const headers = {};
+                    for (const [k, v] of Object.entries(res.headers)) {
+                        if (typeof v === 'string')
+                            headers[k] = v;
+                        else if (Array.isArray(v))
+                            headers[k] = (_a = v[0]) !== null && _a !== void 0 ? _a : '';
+                    }
+                    resolve({ status: (_b = res.statusCode) !== null && _b !== void 0 ? _b : 0, headers, body });
+                });
+                res.on('error', reject);
+            });
+            req.on('error', reject);
+            req.write(payload.body);
+            req.end();
+        });
+    }
+    async _withTimeout(promise, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                const err = new Error(`Timeout after ${timeoutMs}ms`);
+                err.name = 'AbortError';
+                reject(err);
+            }, timeoutMs);
+            promise.then((v) => {
+                clearTimeout(timer);
+                resolve(v);
+            }, (e) => {
+                clearTimeout(timer);
+                reject(e);
+            });
+        });
+    }
+    async _withConcurrencyLimit(fn) {
+        const max = this.config.maxConcurrentFlushes;
+        if (this._concurrentCount >= max) {
+            // Queue and wait
+            await new Promise((resolve) => this._concurrentQueue.push(resolve));
+        }
+        this._concurrentCount++;
+        try {
+            return await fn();
+        }
+        finally {
+            this._concurrentCount--;
+            const next = this._concurrentQueue.shift();
+            if (next)
+                next();
+        }
+    }
+    /** Exponential backoff with ±20% jitter */
+    _backoff(attempt) {
+        const base = Math.min(1000 * Math.pow(2, attempt), 16000);
+        const jitter = base * 0.2 * (Math.random() * 2 - 1);
+        return Math.round(base + jitter);
+    }
+    _parseRetryAfter(header) {
+        if (!header)
+            return undefined;
+        const seconds = parseFloat(header);
+        if (!isNaN(seconds))
+            return Math.round(seconds * 1000);
+        const date = new Date(header).getTime();
+        if (!isNaN(date))
+            return Math.max(0, date - Date.now());
+        return undefined;
+    }
+    _sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+class SdkHttpError extends Error {
+    constructor(kind, message, statusCode, retryAfterMs, cause, 
+    /** S79: Response headers from the 429 response — used to parse X-Doow-Rate-Limits */
+    rateLimitHeaders) {
+        super(message);
+        this.kind = kind;
+        this.statusCode = statusCode;
+        this.retryAfterMs = retryAfterMs;
+        this.cause = cause;
+        this.rateLimitHeaders = rateLimitHeaders;
+        this.name = 'SdkHttpError';
+    }
+}
+
+class EventProcessor {
+    constructor(config, exporter) {
+        this._queue = [];
+        this._timer = null;
+        this._hasFlushed = false;
+        this._currentBytes = 0;
+        /** Track pending async enqueue promises so shutdown can wait for them */
+        this._pendingEnqueues = new Set();
+        this._config = config;
+        this._exporter = exporter;
+    }
+    /** Enqueue an event. Applies beforeSend hook, ring buffer eviction, flush triggers. */
+    enqueue(event) {
+        const p = this._enqueueAsync(event);
+        this._pendingEnqueues.add(p);
+        void p.finally(() => this._pendingEnqueues.delete(p));
+        return p;
+    }
+    async _enqueueAsync(event) {
+        // Apply beforeSend hook
+        const processed = await this._applyBeforeSend(event);
+        if (processed === null) {
+            this._config.debug.log(`beforeSend dropped event ${event.event_id}`);
+            return;
+        }
+        // Ring buffer: evict oldest if at capacity
+        if (this._queue.length >= this._config.maxQueueSize) {
+            const evicted = this._queue.shift();
+            if (evicted) {
+                this._currentBytes -= this._eventBytes(evicted);
+                this._config.debug.warn(`Ring buffer full — evicted oldest event ${evicted.event_id}`);
+            }
+        }
+        this._queue.push(processed);
+        this._currentBytes += this._eventBytes(processed);
+        // First-event fast path
+        if (!this._hasFlushed) {
+            this._config.debug.log(`First event — immediate flush`);
+            await this._triggerFlush();
+            return;
+        }
+        // Count threshold
+        if (this._queue.length >= this._config.flushAt) {
+            this._config.debug.log(`Count threshold (${this._config.flushAt}) reached — flushing`);
+            await this._triggerFlush();
+            return;
+        }
+        // Byte threshold
+        if (this._currentBytes >= this._config.maxPayloadBytes) {
+            this._config.debug.log(`Byte threshold (${this._config.maxPayloadBytes}) reached — flushing`);
+            await this._triggerFlush();
+            return;
+        }
+        // Ensure timer is running
+        this._ensureTimer();
+    }
+    /** Manual flush — waits for pending enqueues, then flushes buffer */
+    async flush() {
+        if (this._pendingEnqueues.size > 0) {
+            await Promise.all([...this._pendingEnqueues]);
+        }
+        await this._triggerFlush();
+    }
+    /** Flush and stop timer */
+    async shutdown() {
+        this._stopTimer();
+        if (this._pendingEnqueues.size > 0) {
+            await Promise.all([...this._pendingEnqueues]);
+        }
+        await this._triggerFlush();
+        await this._exporter.drain();
+    }
+    /** Stop the interval timer */
+    _stopTimer() {
+        if (this._timer !== null) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+    }
+    _ensureTimer() {
+        if (this._timer !== null)
+            return;
+        this._timer = setTimeout(() => {
+            this._timer = null;
+            this._config.debug.log(`Timer flush after ${this._config.flushInterval}ms`);
+            void this._triggerFlush();
+        }, this._config.flushInterval);
+    }
+    async _triggerFlush() {
+        this._stopTimer();
+        if (this._queue.length === 0)
+            return;
+        // Drain the queue
+        const batch = this._queue.splice(0, this._queue.length);
+        this._currentBytes = 0;
+        this._hasFlushed = true;
+        // Apply beforeFlush hook
+        const finalBatch = await this._applyBeforeFlush(batch);
+        if (finalBatch === null || finalBatch.length === 0) {
+            this._config.debug.log(`beforeFlush dropped batch of ${batch.length} events`);
+            return;
+        }
+        await this._exporter.flush(finalBatch);
+    }
+    async _applyBeforeSend(event) {
+        if (!this._config.beforeSend)
+            return event;
+        try {
+            return await this._config.beforeSend(event);
+        }
+        catch (err) {
+            this._config.debug.warn(`beforeSend threw: ${String(err)}`);
+            return event; // fail-open
+        }
+    }
+    async _applyBeforeFlush(batch) {
+        if (!this._config.beforeFlush)
+            return batch;
+        try {
+            return await this._config.beforeFlush(batch);
+        }
+        catch (err) {
+            this._config.debug.warn(`beforeFlush threw: ${String(err)}`);
+            return batch; // fail-open
+        }
+    }
+    _eventBytes(event) {
+        return Buffer.byteLength(JSON.stringify(event), 'utf8');
+    }
+    /** Expose queue length for testing */
+    get queueLength() {
+        return this._queue.length;
+    }
+    /** Expose hasFlushed for testing */
+    get hasFlushed() {
+        return this._hasFlushed;
+    }
+    /** Override flushAt threshold (used by serverless wrappers to force flushAt=1) */
+    setFlushAt(n) {
+        this._config.flushAt = n;
+    }
+}
+
+/**
+ * S76: DoowTracker — public API surface
+ *
+ * The customer-facing class. Four lines to start emitting:
+ *
+ *   import { DoowTracker } from '@doow/track';
+ *   const meter = new DoowTracker('dk_...');
+ *   meter.track({ metric: 'api_calls', quantity: 1, license_id: '...' });
+ *   await meter.shutdown();
+ */
+// ─── Defaults ──────────────────────────────────────────────────────────────
+const DEFAULTS = {
+    endpoint: 'https://api.doow.co',
+    enabled: true,
+    debug: false,
+    flushAt: 20,
+    flushInterval: 10000,
+    maxPayloadBytes: 450 * 1024,
+    maxQueueSize: 10000,
+    timeout: 10000,
+    retryCount: 3,
+    disableCompression: false,
+    maxConcurrentFlushes: 30,
+    shutdownTimeout: 5000,
+};
+// ─── Env var parsing ───────────────────────────────────────────────────────
+function resolveEnvOverrides(opts) {
+    const env = typeof process !== 'undefined' ? process.env : undefined;
+    // Spread opts without creating explicit undefined keys that would override DEFAULTS
+    const result = { ...opts };
+    if (env === null || env === void 0 ? void 0 : env.DOOW_TRACK_ENDPOINT)
+        result.endpoint = env.DOOW_TRACK_ENDPOINT;
+    if ((env === null || env === void 0 ? void 0 : env.DOOW_TRACK_DISABLED) === 'true')
+        result.enabled = false;
+    if ((env === null || env === void 0 ? void 0 : env.DOOW_TRACK_DEBUG) === 'true')
+        result.debug = true;
+    if ((env === null || env === void 0 ? void 0 : env.DOOW_TRACK_FLUSH_AT) !== undefined) {
+        const n = parseInt(env.DOOW_TRACK_FLUSH_AT, 10);
+        if (!isNaN(n) && n > 0)
+            result.flushAt = n;
+    }
+    if ((env === null || env === void 0 ? void 0 : env.DOOW_TRACK_FLUSH_INTERVAL) !== undefined) {
+        const n = parseInt(env.DOOW_TRACK_FLUSH_INTERVAL, 10);
+        if (!isNaN(n) && n > 0)
+            result.flushInterval = n;
+    }
+    if ((env === null || env === void 0 ? void 0 : env.DOOW_TRACK_ATTRIBUTION) !== undefined) {
+        try {
+            result.attribution = JSON.parse(env.DOOW_TRACK_ATTRIBUTION);
+        }
+        catch {
+            /* keep opts.attribution */
+        }
+    }
+    return result;
+}
+// ─── DoowTracker ───────────────────────────────────────────────────────────
+class DoowTracker {
+    constructor(apiKey, options = {}) {
+        var _a, _b, _c;
+        this._shutdownCalled = false;
+        this._sigHandlers = null;
+        // Validate API key prefix
+        const envApiKey = typeof process !== 'undefined' ? ((_a = process.env['DOOW_TRACK_API_KEY']) !== null && _a !== void 0 ? _a : apiKey) : apiKey;
+        if (!envApiKey.startsWith('dk_')) {
+            console.warn(`[doow/track] API key must start with "dk_". Got: "${envApiKey.slice(0, 10)}..."`);
+        }
+        this._apiKey = envApiKey;
+        // Merge options with env var overrides (env takes precedence)
+        const merged = resolveEnvOverrides(options);
+        // Log unknown options in debug mode
+        const knownKeys = new Set([
+            'endpoint',
+            'enabled',
+            'attribution',
+            'debug',
+            'flushAt',
+            'flushInterval',
+            'maxPayloadBytes',
+            'maxQueueSize',
+            'timeout',
+            'retryCount',
+            'disableCompression',
+            'onError',
+            'beforeSend',
+            'beforeFlush',
+            'transport',
+            'offlineStore',
+            'maxConcurrentFlushes',
+            'shutdownTimeout',
+        ]);
+        this._options = {
+            ...DEFAULTS,
+            ...merged,
+        };
+        const unknownKeys = Object.keys(options).filter((k) => !knownKeys.has(k));
+        const debugLogger = createDebugLogger((_b = this._options.debug) !== null && _b !== void 0 ? _b : false);
+        if (unknownKeys.length > 0) {
+            debugLogger.warn(`Unknown init options ignored: ${unknownKeys.join(', ')}`);
+        }
+        // If disabled — complete no-op, no buffers allocated
+        if (!this._options.enabled) {
+            debugLogger.log('SDK disabled — all operations are no-ops');
+            this._processor = null;
+            this._exporter = null;
+            return;
+        }
+        const onError = (_c = this._options.onError) !== null && _c !== void 0 ? _c : ((e) => console.warn(`[doow/track] ${e.kind}: ${e.message}`));
+        const exporterConfig = {
+            endpoint: this._options.endpoint,
+            apiKey: this._apiKey,
+            timeout: this._options.timeout,
+            retryCount: this._options.retryCount,
+            disableCompression: this._options.disableCompression,
+            maxConcurrentFlushes: this._options.maxConcurrentFlushes,
+            onError,
+            debug: debugLogger,
+        };
+        if (this._options.transport)
+            exporterConfig.transport = this._options.transport;
+        if (this._options.offlineStore)
+            exporterConfig.offlineStore = this._options.offlineStore;
+        this._exporter = new Exporter(exporterConfig);
+        const processorConfig = {
+            flushAt: this._options.flushAt,
+            flushInterval: this._options.flushInterval,
+            maxPayloadBytes: this._options.maxPayloadBytes,
+            maxQueueSize: this._options.maxQueueSize,
+            debug: debugLogger,
+        };
+        if (this._options.beforeSend)
+            processorConfig.beforeSend = this._options.beforeSend;
+        if (this._options.beforeFlush)
+            processorConfig.beforeFlush = this._options.beforeFlush;
+        this._processor = new EventProcessor(processorConfig, this._exporter);
+        if (typeof process !== 'undefined') {
+            const sigterm = () => {
+                void this.shutdown();
+            };
+            const beforeExit = () => {
+                void this.shutdown();
+            };
+            process.setMaxListeners(process.getMaxListeners() + 2);
+            process.on('SIGTERM', sigterm);
+            process.on('beforeExit', beforeExit);
+            this._sigHandlers = { sigterm, beforeExit };
+        }
+    }
+    /**
+     * Track a usage event.
+     * - Generates UUID v4 event_id at call time
+     * - Merges SDK-level attribution defaults
+     * - Enqueues to EventProcessor
+     * - No-op if SDK is disabled or stopped
+     */
+    track(event) {
+        var _a, _b, _c, _d;
+        if (!this._processor || !this._exporter)
+            return; // disabled
+        if (this._exporter.stopped)
+            return; // auth failure
+        if (this._shutdownCalled)
+            return;
+        const serialized = {
+            ...event,
+            event_id: generateUUID(),
+            timestamp: (_a = event.timestamp) !== null && _a !== void 0 ? _a : new Date().toISOString(),
+            attribution: {
+                ...((_b = this._options.attribution) !== null && _b !== void 0 ? _b : {}),
+                ...((_c = event.attribution) !== null && _c !== void 0 ? _c : {}),
+            },
+            kind: (_d = event.kind) !== null && _d !== void 0 ? _d : 'USAGE',
+        };
+        // Fire-and-forget enqueue — errors surface via onError
+        void this._processor.enqueue(serialized);
+    }
+    /**
+     * Manually flush the current buffer.
+     * Returns a Promise that resolves when the flush completes.
+     */
+    async flush() {
+        if (!this._processor)
+            return;
+        await this._processor.flush();
+    }
+    /**
+     * Drain all pending events and shut down.
+     * Registers SIGTERM + beforeExit handlers automatically.
+     * Best-effort — hard kill loses buffered events.
+     */
+    async shutdown(timeout) {
+        if (this._shutdownCalled)
+            return;
+        this._shutdownCalled = true;
+        // Remove signal handlers
+        if (this._sigHandlers && typeof process !== 'undefined') {
+            process.removeListener('SIGTERM', this._sigHandlers.sigterm);
+            process.removeListener('beforeExit', this._sigHandlers.beforeExit);
+            process.setMaxListeners(Math.max(0, process.getMaxListeners() - 2));
+            this._sigHandlers = null;
+        }
+        if (!this._processor)
+            return;
+        const timeoutMs = timeout !== null && timeout !== void 0 ? timeout : this._options.shutdownTimeout;
+        const shutdownPromise = this._processor.shutdown();
+        const timeoutPromise = new Promise((resolve) => setTimeout(resolve, timeoutMs));
+        await Promise.race([shutdownPromise, timeoutPromise]);
+    }
+    /** True if the SDK is enabled */
+    get enabled() {
+        return !!this._processor;
+    }
+    /** True if auth has failed and SDK stopped emitting */
+    get stopped() {
+        var _a, _b;
+        return (_b = (_a = this._exporter) === null || _a === void 0 ? void 0 : _a.stopped) !== null && _b !== void 0 ? _b : false;
+    }
+    /** S79: True if a per-category rate limit is currently active */
+    get rateLimited() {
+        var _a, _b;
+        return (_b = (_a = this._exporter) === null || _a === void 0 ? void 0 : _a.rateLimited) !== null && _b !== void 0 ? _b : false;
+    }
+    // ─── S81: Serverless wrappers ─────────────────────────────────────────────
+    /**
+     * Wrap an AWS Lambda handler.
+     * Sets flushAt=1 internally, calls shutdown() in a finally block.
+     *
+     * @example
+     * export const handler = meter.withLambda(async (event, context) => {
+     *   meter.track({ ... });
+     *   return { statusCode: 200 };
+     * });
+     */
+    withLambda(handler) {
+        // Override flushAt to 1 so every track() flushes immediately
+        if (this._processor) {
+            this._processor.setFlushAt(1);
+        }
+        return async (event, context) => {
+            try {
+                return await handler(event, context);
+            }
+            finally {
+                await this.flush();
+            }
+        };
+    }
+    /**
+     * Wrap a Vercel serverless function handler.
+     * Sets flushAt=1 internally, calls flush() in a finally block.
+     */
+    withVercel(handler) {
+        if (this._processor) {
+            this._processor.setFlushAt(1);
+        }
+        return async (req, res) => {
+            try {
+                await handler(req, res);
+            }
+            finally {
+                await this.flush();
+            }
+        };
+    }
+    /**
+     * Wrap an Azure Function handler.
+     * Sets flushAt=1 internally, calls flush() in a finally block.
+     */
+    withAzureFunction(handler) {
+        if (this._processor) {
+            this._processor.setFlushAt(1);
+        }
+        return async (context, input) => {
+            try {
+                return await handler(context, input);
+            }
+            finally {
+                await this.flush();
+            }
+        };
+    }
+}
+
+/**
+ * S82: Health check HTTP server.
+ *
+ * Serves GET /healthz on DOOW_TRACK_HEALTH_PORT (default 9090).
+ * Returns 200 OK with {"status":"ok"} when the sidecar is running.
+ */
+function createHealthServer(port) {
+    let server = null;
+    const handler = (_req, res) => {
+        const body = JSON.stringify({ status: 'ok' });
+        res.writeHead(200, {
+            'Content-Type': 'application/json',
+            'Content-Length': String(Buffer.byteLength(body)),
+        });
+        res.end(body);
+    };
+    return {
+        get port() {
+            return port;
+        },
+        async start() {
+            server = http__namespace.createServer(handler);
+            await new Promise((resolve, reject) => {
+                server.listen(port, () => resolve());
+                server.on('error', reject);
+            });
+        },
+        async stop() {
+            if (server) {
+                await new Promise((resolve) => {
+                    server.close(() => resolve());
+                });
+                server = null;
+            }
+        },
+    };
+}
+
+/**
+ * S82: InputReader — unified input source for sidecar and CLI.
+ *
+ * Supports three modes controlled by DOOW_TRACK_INPUT env var:
+ *   stdin         — newline-delimited JSON from process.stdin (default)
+ *   file:<path>   — tail a file, resuming from last cursor position
+ *   tcp:<port>    — TCP socket server accepting newline-delimited JSON
+ *
+ * Each valid JSON line is passed to onEvent. Malformed lines call onError.
+ * Call stop() to shut down cleanly.
+ */
+// ─── Line splitter ─────────────────────────────────────────────────────────
+/** Split a stream into lines, calling onLine for each complete line. */
+const MAX_LINE_BYTES = 1048576;
+function pipeLines(readable, onLine, onError) {
+    let buf = '';
+    readable.on('data', (chunk) => {
+        var _a;
+        buf += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        if (!buf.includes('\n') && buf.length > MAX_LINE_BYTES) {
+            onError === null || onError === void 0 ? void 0 : onError(new Error(`Line exceeds ${MAX_LINE_BYTES} bytes`), '');
+            buf = '';
+            return;
+        }
+        const parts = buf.split('\n');
+        // All but last are complete lines
+        for (let i = 0; i < parts.length - 1; i++) {
+            const line = parts[i].trim();
+            if (line.length > 0)
+                onLine(line);
+        }
+        buf = (_a = parts[parts.length - 1]) !== null && _a !== void 0 ? _a : '';
+    });
+    readable.on('end', () => {
+        const remaining = buf.trim();
+        if (remaining.length > 0)
+            onLine(remaining);
+        buf = '';
+    });
+}
+// ─── Parse helper ──────────────────────────────────────────────────────────
+function dispatchLine(line, onEvent, onError) {
+    try {
+        JSON.parse(line); // validate JSON — value not used here; caller validates shape
+        onEvent(line);
+    }
+    catch (e) {
+        onError(e instanceof Error ? e : new Error(String(e)), line);
+    }
+}
+// ─── Stdin mode ────────────────────────────────────────────────────────────
+function createStdinReader(onEvent, onError) {
+    let started = false;
+    return {
+        start() {
+            if (started)
+                return Promise.resolve();
+            started = true;
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            pipeLines(process.stdin, (line) => dispatchLine(line, onEvent, onError));
+            return Promise.resolve();
+        },
+        stop() {
+            // stdin mode: just let it close naturally
+            return Promise.resolve();
+        },
+    };
+}
+// ─── File tail mode ────────────────────────────────────────────────────────
+function createFileReader(filePath, onEvent, onError) {
+    let stopped = false;
+    let pollTimer = null;
+    let cursor = 0; // byte offset into file
+    async function readChunk() {
+        if (stopped)
+            return;
+        let stat;
+        try {
+            stat = await fs.promises.stat(filePath);
+        }
+        catch {
+            // File doesn't exist yet — wait
+            scheduleNext();
+            return;
+        }
+        if (stat.size <= cursor) {
+            // No new data
+            scheduleNext();
+            return;
+        }
+        // Read new bytes from cursor onward
+        await new Promise((resolve) => {
+            const stream = fs.createReadStream(filePath, {
+                start: cursor,
+                end: stat.size - 1,
+                encoding: 'utf8',
+            });
+            let buf = '';
+            stream.on('data', (chunk) => {
+                buf += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+            });
+            stream.on('end', () => {
+                cursor = stat.size;
+                // Process lines
+                const lines = buf.split('\n');
+                for (let i = 0; i < lines.length - 1; i++) {
+                    const line = lines[i].trim();
+                    if (line.length > 0)
+                        dispatchLine(line, onEvent, onError);
+                }
+                // Last segment may be incomplete — don't advance cursor past it
+                const last = lines[lines.length - 1].trim();
+                if (last.length > 0) {
+                    // Rewind cursor to not skip the incomplete line
+                    cursor -= Buffer.byteLength(lines[lines.length - 1], 'utf8');
+                }
+                resolve();
+            });
+            stream.on('error', () => resolve());
+        });
+        scheduleNext();
+    }
+    function scheduleNext() {
+        if (stopped)
+            return;
+        pollTimer = setTimeout(() => {
+            void readChunk();
+        }, 200);
+    }
+    return {
+        start() {
+            // Read existing content first, then poll for new content
+            return readChunk();
+        },
+        stop() {
+            stopped = true;
+            if (pollTimer !== null) {
+                clearTimeout(pollTimer);
+                pollTimer = null;
+            }
+            return Promise.resolve();
+        },
+    };
+}
+// ─── TCP mode ──────────────────────────────────────────────────────────────
+const MAX_TCP_CONNECTIONS = 10;
+function createTcpReader(port, onEvent, onError) {
+    let server = null;
+    return {
+        async start() {
+            server = net__namespace.createServer((socket) => {
+                socket.setEncoding('utf8');
+                socket.setTimeout(60000, () => socket.destroy());
+                pipeLines(socket, (line) => dispatchLine(line, onEvent, onError), onError);
+                socket.on('error', () => {
+                    /* ignore individual socket errors */
+                });
+            });
+            server.maxConnections = MAX_TCP_CONNECTIONS;
+            await new Promise((resolve, reject) => {
+                server.listen(port, () => resolve());
+                server.on('error', reject);
+            });
+        },
+        async stop() {
+            if (server) {
+                await new Promise((resolve) => {
+                    server.close(() => resolve());
+                });
+                server = null;
+            }
+        },
+    };
+}
+// ─── Factory ───────────────────────────────────────────────────────────────
+function createInputReader(opts) {
+    const { mode, onEvent, onError } = opts;
+    if (mode === 'stdin') {
+        return createStdinReader(onEvent, onError);
+    }
+    if (mode.type === 'file') {
+        return createFileReader(mode.path, onEvent, onError);
+    }
+    if (mode.type === 'tcp') {
+        return createTcpReader(mode.port, onEvent, onError);
+    }
+    // TypeScript exhaustive check
+    const _exhaustive = mode;
+    throw new Error(`Unknown input mode: ${JSON.stringify(_exhaustive)}`);
+}
+// ─── Env-based factory ────────────────────────────────────────────────────
+/**
+ * Parse DOOW_TRACK_INPUT env var and return the appropriate mode config.
+ *   ""            → stdin
+ *   "stdin"       → stdin
+ *   "file:/path"  → file mode
+ *   "tcp:9000"    → TCP mode on port 9000
+ */
+function parseInputMode(envValue) {
+    if (!envValue || envValue === 'stdin')
+        return 'stdin';
+    if (envValue.startsWith('file:')) {
+        const filePath = envValue.slice('file:'.length);
+        if (!filePath)
+            throw new Error(`DOOW_TRACK_INPUT file: mode requires a path`);
+        return { type: 'file', path: filePath };
+    }
+    if (envValue.startsWith('tcp:')) {
+        const portStr = envValue.slice('tcp:'.length);
+        const port = parseInt(portStr, 10);
+        if (isNaN(port) || port < 1 || port > 65535) {
+            throw new Error(`DOOW_TRACK_INPUT tcp: mode requires a valid port number`);
+        }
+        return { type: 'tcp', port };
+    }
+    throw new Error(`Unknown DOOW_TRACK_INPUT value: "${envValue}". Use stdin, file:<path>, or tcp:<port>.`);
+}
+
+/**
+ * S82: Doow Track Sidecar — entry point.
+ *
+ * Reads events from stdin / file / TCP and batch-POSTs via DoowTracker.
+ *
+ * Required env:
+ *   DOOW_TRACK_API_KEY          — SDK API key (must start with dk_)
+ *
+ * Optional env:
+ *   DOOW_TRACK_INPUT            — stdin (default) | file:<path> | tcp:<port>
+ *   DOOW_TRACK_HEALTH_PORT      — health check port (default 9090)
+ *   DOOW_TRACK_ENDPOINT         — override API endpoint
+ *   DOOW_TRACK_FLUSH_AT         — flush event count threshold
+ *   DOOW_TRACK_FLUSH_INTERVAL   — flush interval ms
+ *   DOOW_TRACK_DISABLED         — disable SDK
+ *   DOOW_TRACK_DEBUG            — enable debug logging
+ *   DOOW_TRACK_ATTRIBUTION      — JSON attribution bag
+ */
+async function main() {
+    // ─── Validate required env ───────────────────────────────────────────────
+    var _a;
+    const apiKey = process.env['DOOW_TRACK_API_KEY'];
+    if (!apiKey) {
+        console.error('[doow-sidecar] DOOW_TRACK_API_KEY is required');
+        process.exit(1);
+    }
+    // ─── Build tracker ───────────────────────────────────────────────────────
+    const tracker = new DoowTracker(apiKey, {
+        onError: (err) => {
+            console.error(`[doow-sidecar] SDK error [${err.kind}]: ${err.message}`);
+        },
+    });
+    // ─── Health server ───────────────────────────────────────────────────────
+    const healthPort = parseInt((_a = process.env['DOOW_TRACK_HEALTH_PORT']) !== null && _a !== void 0 ? _a : '9090', 10);
+    const health = createHealthServer(healthPort);
+    await health.start();
+    // ─── Input reader ────────────────────────────────────────────────────────
+    const inputMode = parseInputMode(process.env['DOOW_TRACK_INPUT']);
+    const reader = createInputReader({
+        mode: inputMode,
+        onEvent: (raw) => {
+            try {
+                const event = JSON.parse(raw);
+                tracker.track(event);
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(String(e));
+                console.warn(`[doow-sidecar] Malformed event — skipping: ${err.message}`);
+            }
+        },
+        onError: (err, line) => {
+            console.warn(`[doow-sidecar] Malformed line — skipping: ${err.message} | line: ${line.slice(0, 100)}`);
+        },
+    });
+    await reader.start();
+    // ─── Graceful shutdown ───────────────────────────────────────────────────
+    let shuttingDown = false;
+    async function shutdown() {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        process.stderr.write('[doow-sidecar] Shutting down...\n');
+        await reader.stop();
+        await tracker.shutdown();
+        await health.stop();
+        process.stderr.write('[doow-sidecar] Shutdown complete.\n');
+        process.exit(0);
+    }
+    process.on('SIGTERM', () => {
+        void shutdown();
+    });
+    process.on('SIGINT', () => {
+        void shutdown();
+    });
+    process.stderr.write(`[doow-sidecar] Running. Health: http://localhost:${healthPort}/healthz\n`);
+}
+main().catch((err) => {
+    console.error('[doow-sidecar] Fatal error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=sidecar.cjs.map