@posthog/core 1.27.8 → 1.28.0

package/dist/index.d.ts

@@ -4,7 +4,8 @@ export * from './utils';
 export * as ErrorTracking from './error-tracking';
 export { buildOtlpLogRecord, buildOtlpLogsPayload, getOtlpSeverityNumber, getOtlpSeverityText, toOtlpAnyValue, toOtlpKeyValueList, } from './logs/logs-utils';
 export { PostHogLogs } from './logs';
-export type { BufferedLogEntry, PostHogLogsConfig, ResolvedPostHogLogsConfig } from './logs/types';
+export type { BeforeSendLogFn, BufferedLogEntry, CaptureLogger, LogSdkContext, PostHogLogsConfig, ResolvedPostHogLogsConfig, } from './logs/types';
+export type { CaptureLogOptions, LogAttributeValue, LogAttributes, LogSeverityLevel } from './logs/types';
 export { uuidv7 } from './vendor/uuidv7';
 export * from './posthog-core';
 export * from './posthog-core-stateless';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,0BAA0B,EAAE,MAAM,QAAQ,CAAA;AACjE,cAAc,SAAS,CAAA;AACvB,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAA;AACjD,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,GACnB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AACpC,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AAClG,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,0BAA0B,EAAE,MAAM,QAAQ,CAAA;AACjE,cAAc,SAAS,CAAA;AACvB,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAA;AACjD,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,GACnB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AACpC,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,cAAc,CAAA;AAIrB,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACzG,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/logs/index.d.ts

@@ -1,17 +1,107 @@
-import type { LogSdkContext } from '@posthog/types';
 import { Logger } from '../types';
 import type { PostHogCoreStateless } from '../posthog-core-stateless';
-import type { CaptureLogOptions, ResolvedPostHogLogsConfig } from './types';
+import type { CaptureLogOptions, LogSdkContext, ResolvedPostHogLogsConfig } from './types';
 export declare class PostHogLogs {
     private readonly _instance;
     private readonly _config;
     private readonly _logger;
     private readonly _getContext;
     private readonly _onReady;
-    private _localEnabled;
+    private readonly _waitForStoragePersist;
     private _maxBufferSize;
-    constructor(_instance: PostHogCoreStateless, _config: ResolvedPostHogLogsConfig, _logger: Logger, _getContext: () => LogSdkContext, _onReady: (fn: () => void) => void);
+    private _flushIntervalMs;
+    private _maxBatchRecordsPerPost;
+    private _flushTimer?;
+    private _flushPromise;
+    private _rateCapWindowMs;
+    private _maxLogsPerInterval?;
+    private _intervalWindowStart;
+    private _intervalLogCount;
+    private _droppedWarned;
+    constructor(_instance: PostHogCoreStateless, _config: ResolvedPostHogLogsConfig, _logger: Logger, _getContext: () => LogSdkContext, _onReady: (fn: () => void) => void, _waitForStoragePersist?: () => Promise<void>);
     captureLog(options: CaptureLogOptions): void;
+    /**
+     * Runs the configured `beforeSend` hook(s) on a capture record:
+     *   - single fn OR array of fns (chain, left-to-right)
+     *   - returning `null` drops the record (logged at info)
+     *   - a thrown error is logged and the chain *continues* with the previous
+     *     result — a buggy user filter must never crash the caller's
+     *     `captureLog()` call
+     */
+    private _runBeforeSend;
+    /**
+     * Returns `true` if this capture fits within the current rate-cap window,
+     * `false` if it should be dropped.
+     *
+     * Fixed (tumbling) window: the counter resets the first time `captureLog`
+     * fires after `rateCapWindowMs` has elapsed — no timer needed.
+     * `maxLogsPerInterval === undefined` means unbounded.
+     *
+     * Wall-clock safety: if `Date.now()` jumps backward (manual device-clock
+     * change, big NTP correction), `elapsed` goes negative. We treat that the
+     * same as "window expired" and reset — otherwise the rate cap would be
+     * stuck until the clock caught up to the old window start, potentially
+     * dropping logs for hours.
+     *
+     * Pre-init note: the counter increments here, before `_onReady` defers
+     * `_enqueue` to the init promise. If init resolves slowly and the user is
+     * later opted out, the counter has already consumed budget for records
+     * that won't enqueue. Cosmetic — no record is "lost" beyond what's
+     * already gated, and the window rolls on its own.
+     */
+    private _checkRateLimit;
+    /**
+     * Drains `LogsQueue` in `maxBatchRecordsPerPost` slices, POSTing each as an
+     * OTLP payload.
+     *   - Network error   → keep items in queue, re-throw (caller retries later)
+     *   - 413             → halve batch size, retry same records (do not advance)
+     *   - Any other error → drop the batch (avoid infinite loop on malformed data),
+     *                       re-throw so callers can log/report
+     * Concurrent calls are serialized through `_flushPromise` so records at the
+     * head of the queue can't be sent twice.
+     */
+    flush(): Promise<void>;
+    private _flushInner;
+    private _persistQueueAdvance;
+    /**
+     * OTLP resource attributes for every batch.
+     *
+     * Layout: user `resourceAttributes` spread first, then SDK-controlled
+     * keys layered on top so users cannot accidentally clobber them. Most logs
+     * backends index on `service.name` and `telemetry.sdk.*` for routing,
+     * SDK-version dashboards, and bug-correlation; letting a stray user key
+     * overwrite them silently breaks ingestion attribution. The dedicated
+     * `serviceName` / `environment` / `serviceVersion` config fields are the
+     * supported way to override `service.name` / `deployment.environment` /
+     * `service.version`.
+     */
+    private _buildResourceAttributes;
     private _enqueue;
+    /**
+     * Stops the timer-based flush and sends anything still in the queue.
+     * Intended for process-teardown paths (RN `_shutdown` override). Swallows
+     * errors so a failing final flush can't block the broader shutdown.
+     *
+     * If `timeoutMs` is provided, the final flush races against that budget so
+     * a slow network/storage can't hold up shutdown indefinitely. Without it,
+     * flush time is bounded only by `fetchRetryCount * (requestTimeout +
+     * fetchRetryDelay)`, which can exceed the caller's shutdown SLA.
+     */
+    shutdown(timeoutMs?: number): Promise<void>;
+    /**
+     * Time-bounded flush for transient lifecycle events (e.g. RN
+     * foreground→background) that must complete inside an OS-imposed window.
+     * Unlike `shutdown`, this leaves the periodic flush timer in place so the
+     * pipeline keeps draining if the process is resumed instead of suspended.
+     *
+     * Errors propagate so the host SDK can route them through its standard
+     * lifecycle error handler (e.g. RN's `logFlushError`). If the timer wins
+     * the race, a late rejection from the in-flight flush is silenced via a
+     * no-op handler attached after the race settles, to avoid noisy
+     * unhandled-rejection logs — the next regular flush cycle will retry.
+     */
+    flushWithTimeout(timeoutMs: number): Promise<void>;
+    private _flushInBackground;
+    private _clearFlushTimer;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/logs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logs/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,EAAE,MAAM,EAA4B,MAAM,UAAU,CAAA;AAC3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AACrE,OAAO,KAAK,EAAoB,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AAE7F,qBAAa,WAAW;IAKpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAR3B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,cAAc,CAAQ;gBAGX,SAAS,EAAE,oBAAoB,EAC/B,OAAO,EAAE,yBAAyB,EAClC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,aAAa,EAChC,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI;IAMrD,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAoB5C,OAAO,CAAC,QAAQ;CAgBjB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logs/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAA4B,MAAM,UAAU,CAAA;AAC3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAErE,OAAO,KAAK,EAGV,iBAAiB,EACjB,aAAa,EACb,yBAAyB,EAC1B,MAAM,SAAS,CAAA;AAEhB,qBAAa,WAAW;IAuBpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAMzB,OAAO,CAAC,QAAQ,CAAC,sBAAsB;IAhCzC,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,gBAAgB,CAAQ;IAIhC,OAAO,CAAC,uBAAuB,CAAQ;IACvC,OAAO,CAAC,WAAW,CAAC,CAAmC;IAGvD,OAAO,CAAC,aAAa,CAA6B;IAMlD,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,mBAAmB,CAAC,CAAQ;IACpC,OAAO,CAAC,oBAAoB,CAAI;IAChC,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,cAAc,CAAQ;gBAGX,SAAS,EAAE,oBAAoB,EAC/B,OAAO,EAAE,yBAAyB,EAClC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,aAAa,EAChC,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,EAMlC,sBAAsB,GAAE,MAAM,OAAO,CAAC,IAAI,CAA2B;IASxF,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAgC5C;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAwBtB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,eAAe;IAwBvB;;;;;;;;;OASG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAUd,WAAW;YAiEX,oBAAoB;IAUlC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,wBAAwB;IAWhC,OAAO,CAAC,QAAQ;IAgChB;;;;;;;;;OASG;IACG,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcjD;;;;;;;;;;;OAWG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBxD,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,gBAAgB;CAMzB"}

package/dist/logs/index.js

@@ -28,26 +28,128 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_logs_utils_js_namespaceObject = require("./logs-utils.js");
 const external_types_js_namespaceObject = require("../types.js");
+const index_js_namespaceObject = require("../utils/index.js");
 class PostHogLogs {
-    constructor(_instance, _config, _logger, _getContext, _onReady){
+    constructor(_instance, _config, _logger, _getContext, _onReady, _waitForStoragePersist = ()=>Promise.resolve()){
         this._instance = _instance;
         this._config = _config;
         this._logger = _logger;
         this._getContext = _getContext;
         this._onReady = _onReady;
-        this._localEnabled = false !== _config.enabled;
+        this._waitForStoragePersist = _waitForStoragePersist;
+        this._flushPromise = null;
+        this._intervalWindowStart = 0;
+        this._intervalLogCount = 0;
+        this._droppedWarned = false;
         this._maxBufferSize = _config.maxBufferSize;
+        this._flushIntervalMs = _config.flushIntervalMs;
+        this._maxBatchRecordsPerPost = _config.maxBatchRecordsPerPost;
+        this._rateCapWindowMs = _config.rateCapWindowMs;
+        this._maxLogsPerInterval = _config.maxLogsPerInterval;
     }
     captureLog(options) {
-        if (!this._localEnabled) return;
         if (this._instance.optedOut) return;
         if (!options?.body) return;
-        const record = (0, external_logs_utils_js_namespaceObject.buildOtlpLogRecord)(options, this._getContext());
+        const filtered = this._runBeforeSend(options);
+        if (null === filtered) return;
+        if (!filtered.body) return;
+        if (!this._checkRateLimit()) return;
+        const record = (0, external_logs_utils_js_namespaceObject.buildOtlpLogRecord)(filtered, this._getContext());
         const entry = {
             record
         };
         this._onReady(()=>this._enqueue(entry));
     }
+    _runBeforeSend(options) {
+        const beforeSend = this._config.beforeSend;
+        if (!beforeSend) return options;
+        const fns = (0, index_js_namespaceObject.isArray)(beforeSend) ? beforeSend : [
+            beforeSend
+        ];
+        let result = options;
+        for (const fn of fns)try {
+            const next = fn(result);
+            if (!next) {
+                this._logger.info("Log was rejected in beforeSend function");
+                return null;
+            }
+            result = next;
+        } catch (e) {
+            this._logger.error("Error in beforeSend function for log:", e);
+        }
+        return result;
+    }
+    _checkRateLimit() {
+        if (void 0 === this._maxLogsPerInterval) return true;
+        const now = Date.now();
+        const elapsed = now - this._intervalWindowStart;
+        if (elapsed >= this._rateCapWindowMs || elapsed < 0) {
+            this._intervalWindowStart = now;
+            this._intervalLogCount = 0;
+            this._droppedWarned = false;
+        }
+        if (this._intervalLogCount >= this._maxLogsPerInterval) {
+            if (!this._droppedWarned) {
+                this._logger.warn(`captureLog dropping logs: exceeded ${this._maxLogsPerInterval} logs per ${this._rateCapWindowMs}ms`);
+                this._droppedWarned = true;
+            }
+            return false;
+        }
+        this._intervalLogCount++;
+        return true;
+    }
+    async flush() {
+        if (this._flushPromise) return this._flushPromise;
+        this._flushPromise = this._flushInner().finally(()=>{
+            this._flushPromise = null;
+        });
+        return this._flushPromise;
+    }
+    async _flushInner() {
+        this._clearFlushTimer();
+        let queue = this._instance.getPersistedProperty(external_types_js_namespaceObject.PostHogPersistedProperty.LogsQueue) ?? [];
+        if (0 === queue.length) return;
+        const originalQueueLength = queue.length;
+        let sentCount = 0;
+        while(queue.length > 0 && sentCount < originalQueueLength){
+            const batchSize = Math.min(queue.length, this._maxBatchRecordsPerPost);
+            const batch = queue.slice(0, batchSize);
+            const records = batch.map((e)=>e.record);
+            const payload = (0, external_logs_utils_js_namespaceObject.buildOtlpLogsPayload)(records, this._buildResourceAttributes(), this._instance.getLibraryId(), this._instance.getLibraryVersion());
+            const outcome = await this._instance._sendLogsBatch(payload);
+            if ('too-large' === outcome.kind && batch.length > 1) {
+                this._maxBatchRecordsPerPost = Math.max(1, Math.floor(batch.length / 2));
+                this._logger.warn(`Received 413 when sending logs batch of size ${batch.length}, reducing batch size to ${this._maxBatchRecordsPerPost}`);
+                continue;
+            }
+            if ('retry-later' === outcome.kind) throw outcome.error;
+            if ('too-large' === outcome.kind) this._logger.warn("Dropping a single log record after 413 with batch size 1 \u2014 the record is larger than the server cap and cannot be split further.");
+            else if ('ok' === outcome.kind && this._maxBatchRecordsPerPost < this._config.maxBatchRecordsPerPost) this._maxBatchRecordsPerPost = Math.min(this._config.maxBatchRecordsPerPost, this._maxBatchRecordsPerPost + 1);
+            await this._persistQueueAdvance(batch.length);
+            queue = this._instance.getPersistedProperty(external_types_js_namespaceObject.PostHogPersistedProperty.LogsQueue) ?? [];
+            sentCount += batch.length;
+            if ('fatal' === outcome.kind) throw outcome.error;
+        }
+    }
+    async _persistQueueAdvance(consumed) {
+        const refreshed = this._instance.getPersistedProperty(external_types_js_namespaceObject.PostHogPersistedProperty.LogsQueue) ?? [];
+        this._instance.setPersistedProperty(external_types_js_namespaceObject.PostHogPersistedProperty.LogsQueue, refreshed.slice(consumed));
+        await this._waitForStoragePersist();
+    }
+    _buildResourceAttributes() {
+        return {
+            ...this._config.resourceAttributes,
+            'service.name': this._config.serviceName || 'unknown_service',
+            ...this._config.environment && {
+                'deployment.environment': this._config.environment
+            },
+            ...this._config.serviceVersion && {
+                'service.version': this._config.serviceVersion
+            },
+            'telemetry.sdk.name': this._instance.getLibraryId(),
+            'telemetry.sdk.version': this._instance.getLibraryVersion()
+        };
+    }
     _enqueue(entry) {
         if (this._instance.optedOut) return;
         const queue = this._instance.getPersistedProperty(external_types_js_namespaceObject.PostHogPersistedProperty.LogsQueue) ?? [];
@@ -57,6 +159,47 @@ class PostHogLogs {
         }
         queue.push(entry);
         this._instance.setPersistedProperty(external_types_js_namespaceObject.PostHogPersistedProperty.LogsQueue, queue);
+        if (queue.length >= this._maxBufferSize) return void this._flushInBackground();
+        if (!this._flushTimer) this._flushTimer = (0, index_js_namespaceObject.safeSetTimeout)(()=>{
+            this._flushTimer = void 0;
+            this._flushInBackground();
+        }, this._flushIntervalMs);
+    }
+    async shutdown(timeoutMs) {
+        this._clearFlushTimer();
+        const flushPromise = this.flush().catch(()=>{});
+        if (void 0 === timeoutMs) return void await flushPromise;
+        await Promise.race([
+            flushPromise,
+            new Promise((resolve)=>(0, index_js_namespaceObject.safeSetTimeout)(resolve, timeoutMs))
+        ]);
+    }
+    async flushWithTimeout(timeoutMs) {
+        let timedOut = false;
+        const flushPromise = this.flush();
+        const timerPromise = new Promise((resolve)=>(0, index_js_namespaceObject.safeSetTimeout)(()=>{
+                timedOut = true;
+                resolve();
+            }, timeoutMs));
+        try {
+            await Promise.race([
+                flushPromise,
+                timerPromise
+            ]);
+        } finally{
+            if (timedOut) flushPromise.catch(()=>{});
+        }
+    }
+    _flushInBackground() {
+        this.flush().catch((err)=>{
+            this._logger.error('PostHog logs flush failed:', err);
+        });
+    }
+    _clearFlushTimer() {
+        if (this._flushTimer) {
+            clearTimeout(this._flushTimer);
+            this._flushTimer = void 0;
+        }
     }
 }
 exports.PostHogLogs = __webpack_exports__.PostHogLogs;

package/dist/logs/index.mjs

@@ -1,25 +1,127 @@
-import { buildOtlpLogRecord } from "./logs-utils.mjs";
+import { buildOtlpLogRecord, buildOtlpLogsPayload } from "./logs-utils.mjs";
 import { PostHogPersistedProperty } from "../types.mjs";
+import { isArray, safeSetTimeout } from "../utils/index.mjs";
 class PostHogLogs {
-    constructor(_instance, _config, _logger, _getContext, _onReady){
+    constructor(_instance, _config, _logger, _getContext, _onReady, _waitForStoragePersist = ()=>Promise.resolve()){
         this._instance = _instance;
         this._config = _config;
         this._logger = _logger;
         this._getContext = _getContext;
         this._onReady = _onReady;
-        this._localEnabled = false !== _config.enabled;
+        this._waitForStoragePersist = _waitForStoragePersist;
+        this._flushPromise = null;
+        this._intervalWindowStart = 0;
+        this._intervalLogCount = 0;
+        this._droppedWarned = false;
         this._maxBufferSize = _config.maxBufferSize;
+        this._flushIntervalMs = _config.flushIntervalMs;
+        this._maxBatchRecordsPerPost = _config.maxBatchRecordsPerPost;
+        this._rateCapWindowMs = _config.rateCapWindowMs;
+        this._maxLogsPerInterval = _config.maxLogsPerInterval;
     }
     captureLog(options) {
-        if (!this._localEnabled) return;
         if (this._instance.optedOut) return;
         if (!options?.body) return;
-        const record = buildOtlpLogRecord(options, this._getContext());
+        const filtered = this._runBeforeSend(options);
+        if (null === filtered) return;
+        if (!filtered.body) return;
+        if (!this._checkRateLimit()) return;
+        const record = buildOtlpLogRecord(filtered, this._getContext());
         const entry = {
             record
         };
         this._onReady(()=>this._enqueue(entry));
     }
+    _runBeforeSend(options) {
+        const beforeSend = this._config.beforeSend;
+        if (!beforeSend) return options;
+        const fns = isArray(beforeSend) ? beforeSend : [
+            beforeSend
+        ];
+        let result = options;
+        for (const fn of fns)try {
+            const next = fn(result);
+            if (!next) {
+                this._logger.info("Log was rejected in beforeSend function");
+                return null;
+            }
+            result = next;
+        } catch (e) {
+            this._logger.error("Error in beforeSend function for log:", e);
+        }
+        return result;
+    }
+    _checkRateLimit() {
+        if (void 0 === this._maxLogsPerInterval) return true;
+        const now = Date.now();
+        const elapsed = now - this._intervalWindowStart;
+        if (elapsed >= this._rateCapWindowMs || elapsed < 0) {
+            this._intervalWindowStart = now;
+            this._intervalLogCount = 0;
+            this._droppedWarned = false;
+        }
+        if (this._intervalLogCount >= this._maxLogsPerInterval) {
+            if (!this._droppedWarned) {
+                this._logger.warn(`captureLog dropping logs: exceeded ${this._maxLogsPerInterval} logs per ${this._rateCapWindowMs}ms`);
+                this._droppedWarned = true;
+            }
+            return false;
+        }
+        this._intervalLogCount++;
+        return true;
+    }
+    async flush() {
+        if (this._flushPromise) return this._flushPromise;
+        this._flushPromise = this._flushInner().finally(()=>{
+            this._flushPromise = null;
+        });
+        return this._flushPromise;
+    }
+    async _flushInner() {
+        this._clearFlushTimer();
+        let queue = this._instance.getPersistedProperty(PostHogPersistedProperty.LogsQueue) ?? [];
+        if (0 === queue.length) return;
+        const originalQueueLength = queue.length;
+        let sentCount = 0;
+        while(queue.length > 0 && sentCount < originalQueueLength){
+            const batchSize = Math.min(queue.length, this._maxBatchRecordsPerPost);
+            const batch = queue.slice(0, batchSize);
+            const records = batch.map((e)=>e.record);
+            const payload = buildOtlpLogsPayload(records, this._buildResourceAttributes(), this._instance.getLibraryId(), this._instance.getLibraryVersion());
+            const outcome = await this._instance._sendLogsBatch(payload);
+            if ('too-large' === outcome.kind && batch.length > 1) {
+                this._maxBatchRecordsPerPost = Math.max(1, Math.floor(batch.length / 2));
+                this._logger.warn(`Received 413 when sending logs batch of size ${batch.length}, reducing batch size to ${this._maxBatchRecordsPerPost}`);
+                continue;
+            }
+            if ('retry-later' === outcome.kind) throw outcome.error;
+            if ('too-large' === outcome.kind) this._logger.warn("Dropping a single log record after 413 with batch size 1 \u2014 the record is larger than the server cap and cannot be split further.");
+            else if ('ok' === outcome.kind && this._maxBatchRecordsPerPost < this._config.maxBatchRecordsPerPost) this._maxBatchRecordsPerPost = Math.min(this._config.maxBatchRecordsPerPost, this._maxBatchRecordsPerPost + 1);
+            await this._persistQueueAdvance(batch.length);
+            queue = this._instance.getPersistedProperty(PostHogPersistedProperty.LogsQueue) ?? [];
+            sentCount += batch.length;
+            if ('fatal' === outcome.kind) throw outcome.error;
+        }
+    }
+    async _persistQueueAdvance(consumed) {
+        const refreshed = this._instance.getPersistedProperty(PostHogPersistedProperty.LogsQueue) ?? [];
+        this._instance.setPersistedProperty(PostHogPersistedProperty.LogsQueue, refreshed.slice(consumed));
+        await this._waitForStoragePersist();
+    }
+    _buildResourceAttributes() {
+        return {
+            ...this._config.resourceAttributes,
+            'service.name': this._config.serviceName || 'unknown_service',
+            ...this._config.environment && {
+                'deployment.environment': this._config.environment
+            },
+            ...this._config.serviceVersion && {
+                'service.version': this._config.serviceVersion
+            },
+            'telemetry.sdk.name': this._instance.getLibraryId(),
+            'telemetry.sdk.version': this._instance.getLibraryVersion()
+        };
+    }
     _enqueue(entry) {
         if (this._instance.optedOut) return;
         const queue = this._instance.getPersistedProperty(PostHogPersistedProperty.LogsQueue) ?? [];
@@ -29,6 +131,47 @@ class PostHogLogs {
         }
         queue.push(entry);
         this._instance.setPersistedProperty(PostHogPersistedProperty.LogsQueue, queue);
+        if (queue.length >= this._maxBufferSize) return void this._flushInBackground();
+        if (!this._flushTimer) this._flushTimer = safeSetTimeout(()=>{
+            this._flushTimer = void 0;
+            this._flushInBackground();
+        }, this._flushIntervalMs);
+    }
+    async shutdown(timeoutMs) {
+        this._clearFlushTimer();
+        const flushPromise = this.flush().catch(()=>{});
+        if (void 0 === timeoutMs) return void await flushPromise;
+        await Promise.race([
+            flushPromise,
+            new Promise((resolve)=>safeSetTimeout(resolve, timeoutMs))
+        ]);
+    }
+    async flushWithTimeout(timeoutMs) {
+        let timedOut = false;
+        const flushPromise = this.flush();
+        const timerPromise = new Promise((resolve)=>safeSetTimeout(()=>{
+                timedOut = true;
+                resolve();
+            }, timeoutMs));
+        try {
+            await Promise.race([
+                flushPromise,
+                timerPromise
+            ]);
+        } finally{
+            if (timedOut) flushPromise.catch(()=>{});
+        }
+    }
+    _flushInBackground() {
+        this.flush().catch((err)=>{
+            this._logger.error('PostHog logs flush failed:', err);
+        });
+    }
+    _clearFlushTimer() {
+        if (this._flushTimer) {
+            clearTimeout(this._flushTimer);
+            this._flushTimer = void 0;
+        }
     }
 }
 export { PostHogLogs };

package/dist/logs/logs-utils.d.ts

@@ -1,4 +1,5 @@
-import type { CaptureLogOptions, LogAttributeValue, LogSdkContext, LogSeverityLevel, OtlpAnyValue, OtlpKeyValue, OtlpLogRecord, OtlpLogsPayload, OtlpSeverityText } from '@posthog/types';
+import type { CaptureLogOptions, LogAttributeValue, LogSeverityLevel, OtlpAnyValue, OtlpKeyValue, OtlpLogRecord, OtlpLogsPayload, OtlpSeverityText } from '@posthog/types';
+import type { LogSdkContext } from './types';
 export declare function getOtlpSeverityText(level: LogSeverityLevel): OtlpSeverityText;
 export declare function getOtlpSeverityNumber(level: LogSeverityLevel): number;
 export declare function toOtlpAnyValue(value: LogAttributeValue): OtlpAnyValue;

package/dist/logs/logs-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logs-utils.d.ts","sourceRoot":"","sources":["../../src/logs/logs-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,eAAe,EAEf,gBAAgB,EACjB,MAAM,gBAAgB,CAAA;AAkBvB,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,CAE7E;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAErE;AAMD,wBAAgB,cAAc,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CAiCrE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,YAAY,EAAE,CAU3F;AAiBD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,aAAa,GAAG,aAAa,CAmDvG;AAMD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,aAAa,EAAE,EAC3B,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,eAAe,CAcjB"}
+{"version":3,"file":"logs-utils.d.ts","sourceRoot":"","sources":["../../src/logs/logs-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,eAAe,EAEf,gBAAgB,EACjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAkB5C,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,CAE7E;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAErE;AAMD,wBAAgB,cAAc,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CAiCrE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,YAAY,EAAE,CAU3F;AAiBD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,aAAa,GAAG,aAAa,CAmDvG;AAMD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,aAAa,EAAE,EAC3B,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,eAAe,CAcjB"}