@zuplo/cli 7.7.7 → 7.7.9

package/node_modules/@posthog/core/dist/traces/context.d.ts

@@ -0,0 +1,18 @@
+import type { Span } from '@posthog/types';
+import type { SpanContextManager } from './types';
+/**
+ * Synchronous active-span tracking: restores the previous active span when the
+ * callback returns, which for an async callback means when it returns its
+ * promise — so spans started after an `await` won't see it as active.
+ *
+ * The fallback for runtimes with no ambient async context; Node injects an
+ * `AsyncLocalStorage`-backed manager instead. `parent` is the escape hatch.
+ *
+ * @internal Exposed for cross-package use within this SDK; not part of the stable public API.
+ */
+export declare class SyncSpanContextManager implements SpanContextManager {
+    private _active;
+    active(): Span | undefined;
+    with<T>(span: Span, fn: () => T): T;
+}
+//# sourceMappingURL=context.d.ts.map

package/node_modules/@posthog/core/dist/traces/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/traces/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAEjD;;;;;;;;;GASG;AACH,qBAAa,sBAAuB,YAAW,kBAAkB;IAC/D,OAAO,CAAC,OAAO,CAAkB;IAEjC,MAAM,IAAI,IAAI,GAAG,SAAS;IAI1B,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;CASpC"}

package/node_modules/@posthog/core/dist/traces/context.js

@@ -0,0 +1,53 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+class SyncSpanContextManager {
+    active() {
+        return this._active;
+    }
+    with(span, fn) {
+        const previous = this._active;
+        this._active = span;
+        try {
+            return fn();
+        } finally{
+            this._active = previous;
+        }
+    }
+}
+__webpack_require__.d(__webpack_exports__, {
+    SyncSpanContextManager: ()=>SyncSpanContextManager
+});
+exports.SyncSpanContextManager = __webpack_exports__.SyncSpanContextManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SyncSpanContextManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/node_modules/@posthog/core/dist/traces/context.mjs

@@ -0,0 +1,15 @@
+class SyncSpanContextManager {
+    active() {
+        return this._active;
+    }
+    with(span, fn) {
+        const previous = this._active;
+        this._active = span;
+        try {
+            return fn();
+        } finally{
+            this._active = previous;
+        }
+    }
+}
+export { SyncSpanContextManager };

package/node_modules/@posthog/core/dist/traces/ids.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Random bytes from the platform's CSPRNG, falling back to `Math.random`.
+ *
+ * The fallback exists for React Native, which has no global `crypto` without a
+ * polyfill. Trace ids need collision resistance, not unpredictability.
+ */
+export declare function getRandomBytes(byteLength: number): Uint8Array;
+export declare function newTraceId(): string;
+export declare function newSpanId(): string;
+export declare function isValidTraceId(value: unknown): value is string;
+export declare function isValidSpanId(value: unknown): value is string;
+//# sourceMappingURL=ids.d.ts.map

package/node_modules/@posthog/core/dist/traces/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/traces/ids.ts"],"names":[],"mappings":"AAkBA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAe7D;AAiBD,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAMD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE9D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE7D"}

package/node_modules/@posthog/core/dist/traces/ids.js

@@ -0,0 +1,92 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const TRACE_ID_BYTES = 16;
+const SPAN_ID_BYTES = 8;
+const TRACE_ID_HEX = 2 * TRACE_ID_BYTES;
+const SPAN_ID_HEX = 2 * SPAN_ID_BYTES;
+const INVALID_TRACE_ID = '0'.repeat(TRACE_ID_HEX);
+const INVALID_SPAN_ID = '0'.repeat(SPAN_ID_HEX);
+const HEX_RE = /^[0-9a-f]+$/;
+function getRandomBytes(byteLength) {
+    const bytes = new Uint8Array(byteLength);
+    const cryptoLike = globalThis.crypto;
+    if (cryptoLike && 'function' == typeof cryptoLike.getRandomValues) try {
+        cryptoLike.getRandomValues(bytes);
+        return bytes;
+    } catch  {}
+    for(let i = 0; i < byteLength; i++)bytes[i] = Math.floor(256 * Math.random());
+    return bytes;
+}
+function bytesToHex(bytes) {
+    let hex = '';
+    for(let i = 0; i < bytes.length; i++)hex += bytes[i].toString(16).padStart(2, '0');
+    return hex;
+}
+function randomHexId(byteLength) {
+    const hex = bytesToHex(getRandomBytes(byteLength));
+    return /[^0]/.test(hex) ? hex : hex.slice(0, -1) + '1';
+}
+function newTraceId() {
+    return randomHexId(TRACE_ID_BYTES);
+}
+function newSpanId() {
+    return randomHexId(SPAN_ID_BYTES);
+}
+function isValidHexId(value, length, invalid) {
+    return 'string' == typeof value && value.length === length && value !== invalid && HEX_RE.test(value);
+}
+function isValidTraceId(value) {
+    return isValidHexId(value, TRACE_ID_HEX, INVALID_TRACE_ID);
+}
+function isValidSpanId(value) {
+    return isValidHexId(value, SPAN_ID_HEX, INVALID_SPAN_ID);
+}
+__webpack_require__.d(__webpack_exports__, {
+    getRandomBytes: ()=>getRandomBytes,
+    isValidSpanId: ()=>isValidSpanId,
+    isValidTraceId: ()=>isValidTraceId,
+    newSpanId: ()=>newSpanId,
+    newTraceId: ()=>newTraceId
+});
+exports.getRandomBytes = __webpack_exports__.getRandomBytes;
+exports.isValidSpanId = __webpack_exports__.isValidSpanId;
+exports.isValidTraceId = __webpack_exports__.isValidTraceId;
+exports.newSpanId = __webpack_exports__.newSpanId;
+exports.newTraceId = __webpack_exports__.newTraceId;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getRandomBytes",
+    "isValidSpanId",
+    "isValidTraceId",
+    "newSpanId",
+    "newTraceId"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/node_modules/@posthog/core/dist/traces/ids.mjs

@@ -0,0 +1,42 @@
+const TRACE_ID_BYTES = 16;
+const SPAN_ID_BYTES = 8;
+const TRACE_ID_HEX = 2 * TRACE_ID_BYTES;
+const SPAN_ID_HEX = 2 * SPAN_ID_BYTES;
+const INVALID_TRACE_ID = '0'.repeat(TRACE_ID_HEX);
+const INVALID_SPAN_ID = '0'.repeat(SPAN_ID_HEX);
+const HEX_RE = /^[0-9a-f]+$/;
+function getRandomBytes(byteLength) {
+    const bytes = new Uint8Array(byteLength);
+    const cryptoLike = globalThis.crypto;
+    if (cryptoLike && 'function' == typeof cryptoLike.getRandomValues) try {
+        cryptoLike.getRandomValues(bytes);
+        return bytes;
+    } catch  {}
+    for(let i = 0; i < byteLength; i++)bytes[i] = Math.floor(256 * Math.random());
+    return bytes;
+}
+function bytesToHex(bytes) {
+    let hex = '';
+    for(let i = 0; i < bytes.length; i++)hex += bytes[i].toString(16).padStart(2, '0');
+    return hex;
+}
+function randomHexId(byteLength) {
+    const hex = bytesToHex(getRandomBytes(byteLength));
+    return /[^0]/.test(hex) ? hex : hex.slice(0, -1) + '1';
+}
+function newTraceId() {
+    return randomHexId(TRACE_ID_BYTES);
+}
+function newSpanId() {
+    return randomHexId(SPAN_ID_BYTES);
+}
+function isValidHexId(value, length, invalid) {
+    return 'string' == typeof value && value.length === length && value !== invalid && HEX_RE.test(value);
+}
+function isValidTraceId(value) {
+    return isValidHexId(value, TRACE_ID_HEX, INVALID_TRACE_ID);
+}
+function isValidSpanId(value) {
+    return isValidHexId(value, SPAN_ID_HEX, INVALID_SPAN_ID);
+}
+export { getRandomBytes, isValidSpanId, isValidTraceId, newSpanId, newTraceId };

package/node_modules/@posthog/core/dist/traces/index.d.ts

@@ -0,0 +1,150 @@
+import type { Span, StartSpanOptions } from '@posthog/types';
+import type { Logger } from '../types';
+import type { ResolvedTracesConfig, SpanContextManager, TraceSdkContext, TracesHost } from './types';
+type SpanCallback<T> = (span: Span) => T;
+/**
+ * The traces pipeline: span creation, active-span parenting, and OTLP export.
+ * Separate from the analytics-events pipeline — own queue, endpoint and flush
+ * cycle — mirroring logs and metrics.
+ *
+ * @internal Exposed for cross-package use within this SDK; not part of the stable public API.
+ */
+export declare class PostHogTraces {
+    private readonly _instance;
+    private readonly _config;
+    private readonly _logger;
+    private readonly _getContext;
+    private readonly _contextManager;
+    /** Told when a span joins the queue, so a serverless host can keep the invocation alive. */
+    private readonly _onSpanQueued?;
+    private _queue;
+    private readonly _flushTimer;
+    private _flushPromise;
+    private _backgroundFlush?;
+    private _maxExportBatchSize;
+    private _droppedSinceWarning;
+    private _lastDropWarningAt;
+    private _dropReasons;
+    private _consecutiveFlushFailures;
+    private _flushJitter;
+    private _retryAfter;
+    private _headBatchFailures;
+    private _headBatchSize;
+    private _headBatchChargeableAt;
+    private _generation;
+    private _liveSpans;
+    constructor(_instance: TracesHost, _config: ResolvedTracesConfig, _logger: Logger, _getContext: () => TraceSdkContext, _contextManager: SpanContextManager, 
+    /** Told when a span joins the queue, so a serverless host can keep the invocation alive. */
+    _onSpanQueued?: (() => void) | undefined);
+    /**
+     * Starts a span without making it active. Always returns a handle — an inert
+     * one when tracing cannot run — so calling code never branches.
+     */
+    startSpan(name: string, options?: StartSpanOptions): Span;
+    /**
+     * Runs a callback with a span active for its duration and guarantees the span
+     * ends — at return for a sync callback, at settle for an async one.
+     *
+     * A throw or rejection is recorded on the span and rethrown unmodified: the
+     * SDK never swallows application control flow.
+     */
+    withSpan<T>(name: string, fn: SpanCallback<T>): T;
+    withSpan<T>(name: string, options: StartSpanOptions, fn: SpanCallback<T>): T;
+    /** The active span, or `null` outside any `withSpan` callback. */
+    getActiveSpan(): Span | null;
+    /**
+     * Drains the span queue in repeated passes: joining a single in-flight pass
+     * would leave spans enqueued after its watermark behind.
+     *
+     * A pass reports spans removed — queue length can't stand in, since a send
+     * concurrent with an arrival leaves it unchanged.
+     *
+     * An open `Retry-After` window does not stop this: an explicit flush, or one a
+     * host runs to keep a request alive, sends whatever is queued — a serverless
+     * isolate may not be around for the armed timer to fire. The window is honoured
+     * by not charging such an attempt against the head batch's retry budget, so the
+     * wait costs a request rather than the spans. The periodic flush does wait it
+     * out.
+     */
+    /**
+     * Whether the endpoint has asked this queue to wait. An automatic flush skips
+     * it; the traces flush timer already drains once the window closes.
+     */
+    get throttled(): boolean;
+    flush(): Promise<void>;
+    private _startFlush;
+    /** Clears the queue and timer. Used on shutdown and between tests. */
+    reset(): void;
+    /** Called wherever the head batch leaves or changes shape, so its budget goes with it. */
+    private _resetHeadBatchBudget;
+    /**
+     * Resolves a span's parent: an explicit `parent`, then the active span, then a
+     * fresh root. A no-op explicit parent is rejected earlier, in `startSpan`.
+     */
+    private _resolveParent;
+    /**
+     * PostHog context snapshotted at span start. These are the product's join
+     * keys — they're what makes a span reachable from a person or a session.
+     */
+    private _autoContextAttributes;
+    /**
+     * Records a callback failure on the span: an `exception` event always, plus
+     * status `error` unless the callback explicitly marked the span `ok`.
+     */
+    private _recordCallbackError;
+    /**
+     * Drops live accounting for spans older than `maxSpanAgeMs`. An evicted span
+     * is never exported — its `end()` finds no entry — so one leak returns its
+     * slot instead of disabling tracing for the rest of the process.
+     */
+    private _evictAgedSpans;
+    private _onSpanEnd;
+    /**
+     * One diagnostic per span when its limits discarded anything, which is what
+     * OTel asks for. Counted after the post-hook pass, so drops a `beforeSpanSend`
+     * hook caused are included.
+     */
+    private _reportLimitDrops;
+    /**
+     * Runs the `beforeSpanSend` chain, returning the span to enqueue or `null` to
+     * drop it.
+     *
+     * A throwing hook drops the span: the hook is the documented scrubbing point,
+     * so a broken scrubber must not let the unscrubbed record through. Identity
+     * fields are restored afterwards, since rewriting them orphans shipped children.
+     */
+    private _runBeforeSpanSend;
+    /**
+     * Restores the fields a hook must not change. Runs per hook so a later hook in
+     * the chain cannot sample on an id an earlier one forged.
+     */
+    private _keepSpanIdentity;
+    private _recordDrop;
+    /** At most one warning per flush pass, naming the total and every reason behind it. */
+    private _warnAboutDrops;
+    /**
+     * Encodes a batch, dropping any span whose attributes can't be encoded.
+     * An unguarded throw here would leave the queue unspliced, so every later
+     * flush would die on the same span.
+     */
+    private _encodeBatch;
+    /**
+     * Discards the queue when consent has been withdrawn, returning how many spans
+     * it dropped. Spans carry `posthogDistinctId` and `sessionId`, so anything still
+     * queued when the user opts out must not be exported.
+     */
+    private _discardQueueIfConsentWithdrawn;
+    /** Returns how many spans it removed from the queue, sent or dropped. */
+    private _flushInner;
+    /**
+     * One background drain at a time. `flush()` is a multi-pass loop that keeps
+     * going while the queue stays above the batch size, so a trigger per span end
+     * would stack a loop per span on a busy service — each retaining its frames.
+     */
+    private _flushInBackground;
+    private _armFlushTimerIfQueued;
+    private _armFlushTimerIfQueuedNoEarlierThan;
+    private _nextFlushDelay;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@posthog/core/dist/traces/index.d.ts.map

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