logixlysia 6.9.3 → 6.10.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 6.10.0
+
+### Minor Changes
+
+- 3423143: HTTP adapters no longer cap delivery at one 20-entry batch per round trip. Entries that arrive while a request is in flight wait and go out together in the next request, which starts as soon as the one in flight returns if a full batch (`maxBatchSize`) is waiting and on the `flushIntervalMs` timer otherwise, so light traffic is batched as before and a 50 ms backend now keeps up with thousands of records per second instead of dropping about half of them. Delivery order is unchanged. The new `maxEntriesPerRequest` option (default 500; 100 for Sentry) is the most entries one request carries; it applies to every request, so a `maxBatchSize` above it splits each batch. At most `maxPendingBatches × maxBatchSize` entries wait behind the request in flight, which carries up to `maxEntriesPerRequest` more, so an adapter holds at most 1,140 entries by default (740 for Sentry) where it held about 660; beyond that, entries are dropped, counted and reported once per request. Requests can carry more bytes than before, and vendor byte limits are not enforced. A failure of a request the queue started on its own goes to the adapter's `onError` (or rate-limited stderr), not to `config.onError`, because no `log()` call is awaiting it; a failure of the request started by a `log()` or `flush()` call is still rejected to that caller. `flush()` waits for the entries accepted before the call, not for the queue to go idle, and it resolves rather than rejects when those entries went out in a request the queue started on its own and that request failed, so `flushLogixlysia` no longer passes that failure to `config.onError`. `maxBatchSize` and `maxEntriesPerRequest` must be positive integers, and the adapter throws at construction otherwise; `maxBatchSize: 0` and `Infinity`, which used to mean one request per entry and timer-only batching, now throw too. The built-in HTTP adapters implement `close()`: it stops accepting entries, then flushes, so `flushLogixlysia(options, { close: true })` releases them. `close` is now a required member of the exported `AdapterTransport` type, so an object of your own typed as `AdapterTransport` needs one as well. A transport wrapped in `withRedaction` is not closed through the wrapper yet; it forwards `flush` only.
+
+### Patch Changes
+
+- 9ac4a0a: Compressed rotation archives are created with `logFileMode` (default `0o600`) instead of the process umask, so they are no more readable than the live log. An adapter's "invalid endpoint URL" error no longer echoes the credentials embedded in the URL, in its message or in its `cause`. File write and rotation failures reported on stderr (when `config.onError` is not set) are rate limited to one message every 5 seconds, like transport and formatting failures.
+- ca5fe30: `autoRedact` no longer throws, and therefore no longer drops the record, when an error's `name` or `message` is an inherited accessor (a `DOMException`, an app error class with `get name()`); redacted errors keep `message`, `name` and `stack` non-enumerable, as native errors do. A value with a `toJSON` method (Bun's `CookieMap`, app classes) is redacted as what it serializes to; errors keep their class even when they define `toJSON`, so an `HttpError` stays an `HttpError`. The password of a URL, `Bearer` and `Basic` credentials in any string, sensitive query keys inside an absolute URL in a `referer`, `location` or `content-location` header, and a field named `cookies` are now masked. Redaction and log serialization stop at a depth of 64 with `"[Depth]"`, so a deeply nested client payload no longer costs quadratic time or overflows the stack. Rotation sizes, intervals and retention given with units are rejected when they are zero, as the numeric zero already was.
+- 7b030bc: `LogFilter`, `LogixlysiaConfig`, `LogRotationConfig`, `SinkErrorContext` and `WebSocketLike` are exported from the package root as types, so a config object, a rotation config, an `onError` handler or a `wrapWs` hook can be typed without reaching into the package's internals. No runtime export changes.
+- 665b71b: The access line is now written once per request, after Elysia has produced the final response, so it carries the status the client received for every exit: a `mapResponse` rewrite, an error mapped by an `onError` hook in either registration order, `set.status` followed by a thrown `Error`, a response returned from an `onRequest` hook, and an auth short-circuit. A generator (streaming) handler is logged when its body finishes, so `{duration}` covers the whole stream, and a throw inside the body produces an error line. A plain object with `code` and `response` keys is no longer mistaken for Elysia's `status()` result. A thrown 2xx or 3xx `status()` now logs at INFO, as an access line without its message, where it was an ERROR line carrying the message. With `useAsyncLocalStorage`, `useLogger()` works inside hooks registered after the plugin, inside a generator body, inside a handler that awaits `app.handle()` for another route, and in work that outlives the response; outside a request it is still a no-op. The `X-Request-Id` response header is set as soon as the request starts, so short-circuited responses carry it too. The request boundary is app-wide: once the plugin is mounted anywhere, every request of the application gets a line, including routes defined on parent apps (previously those were silently unlogged); mount the plugin once at the root. Apps running with `aot: false`, or mounting the plugin inside `group()` or `guard()`, keep the previous hook-based behaviour, including a second error line for an error thrown after the handler returned. Consequences for existing expectations: an error thrown after the handler returned, by an `afterHandle` hook or while Elysia builds the response, now produces one error line instead of a success line followed by an error line; when an app-wide `onError` registered before the plugin answers, the plugin never sees the thrown value, so the line is an access line at the level of the status sent, with an empty message and no error payload, where it was an error line carrying the thrown value; an error that a later `onError` maps to a 2xx or 3xx (a redirect to a login page, say) is logged as an error line carrying that status and the thrown message, where it was logged as ERROR 500 before; a custom log made from a hook registered after the plugin replaces the access line, as a custom log from the handler always did, where it was a second line before, and a custom log made from a later `onError` now comes before the error line instead of after it; and with two plugin instances in sibling modules, access lines now go through the first instance's sinks, while a custom log made through a later instance's `log` still reaches that instance's transports, without a request ID, and replaces the access line for that request (create the plugin once and share it).
+- 0fb85de: `store.pino` is defined again. Since 6.7.0 the lazy pino Proxy was dropped by Elysia's `state()` because its target had no keys, so every handler that read `store.pino` threw. Assignments such as `store.pino.level = 'debug'` now reach pino. The plugin rejects at construction a `logFilter.level` that is not an array of `DEBUG`, `INFO`, `WARNING` or `ERROR`, `useTransportsOnly: true` without a transport, and a `flushTimeoutMs` that is not a finite number of milliseconds at or above 0; each of these used to turn logging off or misreport shutdown silently. `useTransportsOnly: true` with an empty `transports` list was previously accepted as an effectively disabled logger; use `disableInternalLogger` and `disableFileLogging` for that. `geoEnricher` ignores non-string fields in a Netlify `x-nf-geo` header instead of throwing. A `requestId.generator` that throws or returns an invalid id no longer produces an error line on every request; the plugin falls back to a generated UUID and reports the failure through `onError`, or on stderr at most once per interval when no hook is set.
+- c7667f2: The HTTP adapters now take a JSON-safe copy of each record's `meta` at the moment it is logged. A later change to a logged object is no longer shipped, which also closes a redaction bypass under `autoRedact` (an adapter wrapped by `withRedaction` takes its copy when the wrapper hands the record over, after its own asynchronous redaction, so that window is unchanged). A value that cannot be serialized (a throwing `toJSON` or getter) is replaced by `"[Unserializable]"` for that field only, where it previously turned a whole Axiom, Better Stack or Datadog batch into that string or rejected a ClickHouse, HyperDX, OTLP, PostHog or Sentry batch. A BigInt anywhere in `meta` is shipped as its decimal string by every adapter, so a BigInt user id now resolves to PostHog's `distinct_id`, and `flattenMeta` no longer renders a nested BigInt or cycle as `[object Object]`.
+- 3373fc1: `wrapWs` no longer discards what a hook returns. A returned string, object, `Buffer`, promise or generator reaches Elysia and is sent to the client exactly as without the wrapper; a hook that returned a value by accident (for example `(ws, m) => ws.send(m)`, whose result is Bun's numeric send status) now has that value sent too, as Elysia does for an unwrapped hook. An `async` hook that rejects is handled by Elysia's error path instead of becoming an unhandled rejection, and its lifecycle line is written after the hook settles.
+
+## 6.9.4
+
+### Patch Changes
+
+- 83e771c: `autoRedact` now masks values inside `Headers`, `URL`, `URLSearchParams`, `Map`, and `Set` objects. Before, these passed through unchanged and serialized with their original values. Compound key names such as `newPassword`, `apiSecret`, `aws_secret_access_key`, `authToken`, and `X-CSRF-Token` now count as sensitive. Every value of a repeated query parameter and every percent-encoded path segment is checked.
+- d6e5b08: Correct the `useAsyncLocalStorage` documentation: the request-scoped `log` is always available on the handler context. The option only makes `useLogger()` return the current request's logger from anywhere in the request.
+- e5acc3a: A request answered with Elysia's `status()` helper is now logged with the status the client received, not 200 or 500. This covers a returned `status()`, a thrown one, and one returned from `beforeHandle`. The message is the string body, or the status text when the body is not a string. A returned `Response` keeps its own status over `set.status` unless it is 200, as in Elysia. Requests that reach neither `onAfterHandle` nor `onError` now get their log line instead of none. These are an auth `resolve` that returns `status(401)` and an error that an app-wide `onError` registered before the plugin answers.
+- a7ec6d2: Logging no longer fails a request. An error whose message is an object, such as `throw status(401, { error: 'unauthorized' })` in `onRequest`, no longer turns the response into a 500, and a BigInt or circular value in request context no longer crashes requests that print `{context}`. The Axiom, Better Stack, Datadog and Loki adapters write BigInts as strings and circular references as `"[Circular]"` instead of dropping the whole batch. Context-tree keys and structured error fields are sanitized like values. Any other failure while building a log record is reported to `onError` with the new `sink: 'format'`.
+- c197893: WebSocket logging tracks each connection by Elysia's underlying socket (`ws.raw`) instead of the wrapper Elysia creates for every event. Message and close lines report the time since the connection opened instead of about 0 ms, context merged with `mergeContext(ws, …)` in one event is still there in the next, and the connection's state is released on close. `wrapWs` throws a `TypeError` when its first argument is not the route path.
+
 ## 6.9.3
 
 ### Patch Changes

package/dist/ai.d.ts

@@ -28,6 +28,8 @@ type RequestInfo = Request;
 type LogLevel = "DEBUG" | "INFO" | "WARNING" | "ERROR";
 interface StoreData {
 	beforeTime: bigint;
+	/** The status the client received, when the caller resolved it. `handleHttpError` prefers it over the thrown value. */
+	status?: number;
 }
 interface AIMetrics {
 	calls?: number;

package/dist/axiom.d.ts

@@ -29,17 +29,26 @@ interface BatchTransportOptions {
 	*/
 	maxBatchSize?: number;
 	/**
-	* Batches allowed to be waiting on the backend at once. Once the limit is
-	* reached, new batches are dropped and reported instead of buffered, so an
-	* unreachable backend cannot grow memory without bound.
+	* The most entries one request carries. Lower it for a backend with a
+	* per-request item limit. The Sentry adapter defaults to 100.
+	* @default 500
+	*/
+	maxEntriesPerRequest?: number;
+	/**
+	* Bound on the entries that wait behind the request in flight, as a
+	* multiple of `maxBatchSize`: at most `maxPendingBatches × maxBatchSize`
+	* entries wait, and entries beyond that are dropped and reported.
 	* @default 32
 	*/
 	maxPendingBatches?: number;
 	/**
-	* Called when a batch fails after retries, or is dropped because too
-	* many batches are pending. When omitted, failures go to stderr, rate
-	* limited to once every 5 seconds. Pass the same function you give
-	* `config.onError` to see transport failures in one place.
+	* Called when a request fails after retries, or when entries are dropped
+	* because too many were already waiting. Failures of a request that a
+	* `log()` or `flush()` call started are rejected to that caller instead.
+	* When omitted, failures go to stderr, rate limited to once every 5
+	* seconds. To see every transport failure in one place, forward them to
+	* the function you give `config.onError`, as
+	* `error => handle({ error, sink: 'transport' })`.
 	*/
 	onError?: (error: unknown) => void;
 	/**
@@ -55,6 +64,8 @@ interface BatchTransportOptions {
 }
 /** A {@link Transport} that batches entries and can be flushed on demand. */
 interface AdapterTransport extends Transport {
+	/** Stops accepting entries, then flushes the ones already accepted. Idempotent. */
+	close: () => Promise<void>;
 	/** Sends any buffered entries immediately. Call before process exit. */
 	flush: () => Promise<void>;
 }

package/dist/axiom.js

@@ -1,4 +1,4 @@
-import{c as G,d as k,e as q,g as J}from"./shared/Logixlysia-z6rmszwk.js";import"./shared/Logixlysia-e797097d.js";var P="https://api.axiom.co",V=(j={})=>{let u=j.apiKey??k("AXIOM_API_KEY");if(!u)throw q("Axiom","missing API token. Set AXIOM_API_KEY or pass apiKey to createAxiomTransport()");let x=j.dataset??k("AXIOM_DATASET");if(!x)throw q("Axiom","missing dataset. Set AXIOM_DATASET or pass dataset to createAxiomTransport()");let N=G(j.baseUrl??k("AXIOM_URL")??P),z=j.orgId??k("AXIOM_ORG_ID"),C={Authorization:`Bearer ${u}`,"Content-Type":"application/json"};if(z)C["X-Axiom-Org-Id"]=z;return J({body:(O)=>JSON.stringify(O.map((m)=>({...m.meta,_time:m.timestamp.toISOString(),level:m.level,message:m.message}))),headers:C,name:"Axiom",options:j,url:`${N}/v1/datasets/${encodeURIComponent(x)}/ingest`})};export{V as createAxiomTransport};
+import{c as O,d as m,e as x,g as P}from"./shared/Logixlysia-xb08zg3q.js";import{k as N}from"./shared/Logixlysia-tqpczh9a.js";var W="https://api.axiom.co",Z=(k={})=>{let z=k.apiKey??m("AXIOM_API_KEY");if(!z)throw x("Axiom","missing API token. Set AXIOM_API_KEY or pass apiKey to createAxiomTransport()");let C=k.dataset??m("AXIOM_DATASET");if(!C)throw x("Axiom","missing dataset. Set AXIOM_DATASET or pass dataset to createAxiomTransport()");let Q=O(k.baseUrl??m("AXIOM_URL")??W),G=k.orgId??m("AXIOM_ORG_ID"),J={Authorization:`Bearer ${z}`,"Content-Type":"application/json"};if(G)J["X-Axiom-Org-Id"]=G;return P({body:(V)=>N(V.map((q)=>({...q.meta,_time:q.timestamp.toISOString(),level:q.level,message:q.message}))),headers:J,name:"Axiom",options:k,url:`${Q}/v1/datasets/${encodeURIComponent(C)}/ingest`})};export{Z as createAxiomTransport};
 
-//# debugId=0147D398D571443F64756E2164756E21
-//# sourceMappingURL=data:application/json;base64,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
+//# debugId=9DE441F47039740664756E2164756E21
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-stack.d.ts

@@ -29,17 +29,26 @@ interface BatchTransportOptions {
 	*/
 	maxBatchSize?: number;
 	/**
-	* Batches allowed to be waiting on the backend at once. Once the limit is
-	* reached, new batches are dropped and reported instead of buffered, so an
-	* unreachable backend cannot grow memory without bound.
+	* The most entries one request carries. Lower it for a backend with a
+	* per-request item limit. The Sentry adapter defaults to 100.
+	* @default 500
+	*/
+	maxEntriesPerRequest?: number;
+	/**
+	* Bound on the entries that wait behind the request in flight, as a
+	* multiple of `maxBatchSize`: at most `maxPendingBatches × maxBatchSize`
+	* entries wait, and entries beyond that are dropped and reported.
 	* @default 32
 	*/
 	maxPendingBatches?: number;
 	/**
-	* Called when a batch fails after retries, or is dropped because too
-	* many batches are pending. When omitted, failures go to stderr, rate
-	* limited to once every 5 seconds. Pass the same function you give
-	* `config.onError` to see transport failures in one place.
+	* Called when a request fails after retries, or when entries are dropped
+	* because too many were already waiting. Failures of a request that a
+	* `log()` or `flush()` call started are rejected to that caller instead.
+	* When omitted, failures go to stderr, rate limited to once every 5
+	* seconds. To see every transport failure in one place, forward them to
+	* the function you give `config.onError`, as
+	* `error => handle({ error, sink: 'transport' })`.
 	*/
 	onError?: (error: unknown) => void;
 	/**
@@ -55,6 +64,8 @@ interface BatchTransportOptions {
 }
 /** A {@link Transport} that batches entries and can be flushed on demand. */
 interface AdapterTransport extends Transport {
+	/** Stops accepting entries, then flushes the ones already accepted. Idempotent. */
+	close: () => Promise<void>;
 	/** Sends any buffered entries immediately. Call before process exit. */
 	flush: () => Promise<void>;
 }

package/dist/better-stack.js

@@ -1,4 +1,4 @@
-import{c as z,d as q,e as C,g as G,j as J}from"./shared/Logixlysia-z6rmszwk.js";import"./shared/Logixlysia-e797097d.js";var Q="https://in.logs.betterstack.com",V=(m={})=>{let x=m.sourceToken??q("BETTER_STACK_SOURCE_TOKEN");if(!x)throw C("Better Stack","missing source token. Set BETTER_STACK_SOURCE_TOKEN or pass sourceToken to createBetterStackTransport()");return G({body:(K)=>JSON.stringify(K.map((j)=>({...j.meta,dt:j.timestamp.toISOString(),level:j.level,message:J(j)}))),headers:{Authorization:`Bearer ${x}`,"Content-Type":"application/json"},name:"Better Stack",options:m,url:z(m.endpoint??q("BETTER_STACK_INGESTING_HOST")??Q)})};export{V as createBetterStackTransport};
+import{c as G,d as x,e as J,g as K,j as Q}from"./shared/Logixlysia-xb08zg3q.js";import{k as C}from"./shared/Logixlysia-tqpczh9a.js";var V="https://in.logs.betterstack.com",Y=(q={})=>{let z=q.sourceToken??x("BETTER_STACK_SOURCE_TOKEN");if(!z)throw J("Better Stack","missing source token. Set BETTER_STACK_SOURCE_TOKEN or pass sourceToken to createBetterStackTransport()");return K({body:(R)=>C(R.map((m)=>({...m.meta,dt:m.timestamp.toISOString(),level:m.level,message:Q(m)}))),headers:{Authorization:`Bearer ${z}`,"Content-Type":"application/json"},name:"Better Stack",options:q,url:G(q.endpoint??x("BETTER_STACK_INGESTING_HOST")??V)})};export{Y as createBetterStackTransport};
 
-//# debugId=0B7C1B3FBF59798064756E2164756E21
-//# sourceMappingURL=data:application/json;base64,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
+//# debugId=45939F6D5FC2E8D764756E2164756E21
+//# sourceMappingURL=data:application/json;base64,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

package/dist/clickhouse.d.ts

@@ -29,17 +29,26 @@ interface BatchTransportOptions {
 	*/
 	maxBatchSize?: number;
 	/**
-	* Batches allowed to be waiting on the backend at once. Once the limit is
-	* reached, new batches are dropped and reported instead of buffered, so an
-	* unreachable backend cannot grow memory without bound.
+	* The most entries one request carries. Lower it for a backend with a
+	* per-request item limit. The Sentry adapter defaults to 100.
+	* @default 500
+	*/
+	maxEntriesPerRequest?: number;
+	/**
+	* Bound on the entries that wait behind the request in flight, as a
+	* multiple of `maxBatchSize`: at most `maxPendingBatches × maxBatchSize`
+	* entries wait, and entries beyond that are dropped and reported.
 	* @default 32
 	*/
 	maxPendingBatches?: number;
 	/**
-	* Called when a batch fails after retries, or is dropped because too
-	* many batches are pending. When omitted, failures go to stderr, rate
-	* limited to once every 5 seconds. Pass the same function you give
-	* `config.onError` to see transport failures in one place.
+	* Called when a request fails after retries, or when entries are dropped
+	* because too many were already waiting. Failures of a request that a
+	* `log()` or `flush()` call started are rejected to that caller instead.
+	* When omitted, failures go to stderr, rate limited to once every 5
+	* seconds. To see every transport failure in one place, forward them to
+	* the function you give `config.onError`, as
+	* `error => handle({ error, sink: 'transport' })`.
 	*/
 	onError?: (error: unknown) => void;
 	/**
@@ -55,6 +64,8 @@ interface BatchTransportOptions {
 }
 /** A {@link Transport} that batches entries and can be flushed on demand. */
 interface AdapterTransport extends Transport {
+	/** Stops accepting entries, then flushes the ones already accepted. Idempotent. */
+	close: () => Promise<void>;
 	/** Sends any buffered entries immediately. Call before process exit. */
 	flush: () => Promise<void>;
 }

package/dist/clickhouse.js

@@ -1,4 +1,4 @@
-import{c as $,d as G,e as x,g as J,h as M,j as O}from"./shared/Logixlysia-z6rmszwk.js";import"./shared/Logixlysia-e797097d.js";var C="http://localhost:8123",N="default",q="logs",B=/^[A-Za-z0-9_]+$/u,Z=(j,z)=>{if(!B.test(j))throw x("ClickHouse",`invalid ${z} '${j}'. Only letters, digits, and underscores are allowed`);return j},H=(j)=>{let z={};for(let[K,Q]of Object.entries(M(j.meta)))z[K]=String(Q);return JSON.stringify({attributes:z,level:j.level,message:O(j),timestamp:j.timestamp.toISOString()})},k=(j={})=>{let z=$(j.url??G("CLICKHOUSE_URL")??C),K=Z(j.database??G("CLICKHOUSE_DATABASE")??N,"database"),Q=Z(j.table??G("CLICKHOUSE_TABLE")??q,"table"),X=j.username??G("CLICKHOUSE_USERNAME"),Y=j.password??G("CLICKHOUSE_PASSWORD"),P=new URLSearchParams({date_time_input_format:"best_effort",query:`INSERT INTO ${K}.${Q} FORMAT JSONEachRow`}),V={"Content-Type":"application/json"};if(X)V["X-ClickHouse-User"]=X;if(Y)V["X-ClickHouse-Key"]=Y;return J({body:(W)=>W.map(H).join(`
+import{c as $,d as G,e as x,g as J,h as M,j as O}from"./shared/Logixlysia-xb08zg3q.js";import"./shared/Logixlysia-tqpczh9a.js";var C="http://localhost:8123",N="default",q="logs",B=/^[A-Za-z0-9_]+$/u,Z=(j,z)=>{if(!B.test(j))throw x("ClickHouse",`invalid ${z} '${j}'. Only letters, digits, and underscores are allowed`);return j},H=(j)=>{let z={};for(let[K,Q]of Object.entries(M(j.meta)))z[K]=String(Q);return JSON.stringify({attributes:z,level:j.level,message:O(j),timestamp:j.timestamp.toISOString()})},k=(j={})=>{let z=$(j.url??G("CLICKHOUSE_URL")??C),K=Z(j.database??G("CLICKHOUSE_DATABASE")??N,"database"),Q=Z(j.table??G("CLICKHOUSE_TABLE")??q,"table"),X=j.username??G("CLICKHOUSE_USERNAME"),Y=j.password??G("CLICKHOUSE_PASSWORD"),P=new URLSearchParams({date_time_input_format:"best_effort",query:`INSERT INTO ${K}.${Q} FORMAT JSONEachRow`}),V={"Content-Type":"application/json"};if(X)V["X-ClickHouse-User"]=X;if(Y)V["X-ClickHouse-Key"]=Y;return J({body:(W)=>W.map(H).join(`
 `),headers:V,name:"ClickHouse",options:j,url:`${z}/?${P.toString()}`})};export{k as createClickHouseTransport};
 
 //# debugId=1B6FC943015B221464756E2164756E21

package/dist/datadog.d.ts

@@ -29,17 +29,26 @@ interface BatchTransportOptions {
 	*/
 	maxBatchSize?: number;
 	/**
-	* Batches allowed to be waiting on the backend at once. Once the limit is
-	* reached, new batches are dropped and reported instead of buffered, so an
-	* unreachable backend cannot grow memory without bound.
+	* The most entries one request carries. Lower it for a backend with a
+	* per-request item limit. The Sentry adapter defaults to 100.
+	* @default 500
+	*/
+	maxEntriesPerRequest?: number;
+	/**
+	* Bound on the entries that wait behind the request in flight, as a
+	* multiple of `maxBatchSize`: at most `maxPendingBatches × maxBatchSize`
+	* entries wait, and entries beyond that are dropped and reported.
 	* @default 32
 	*/
 	maxPendingBatches?: number;
 	/**
-	* Called when a batch fails after retries, or is dropped because too
-	* many batches are pending. When omitted, failures go to stderr, rate
-	* limited to once every 5 seconds. Pass the same function you give
-	* `config.onError` to see transport failures in one place.
+	* Called when a request fails after retries, or when entries are dropped
+	* because too many were already waiting. Failures of a request that a
+	* `log()` or `flush()` call started are rejected to that caller instead.
+	* When omitted, failures go to stderr, rate limited to once every 5
+	* seconds. To see every transport failure in one place, forward them to
+	* the function you give `config.onError`, as
+	* `error => handle({ error, sink: 'transport' })`.
 	*/
 	onError?: (error: unknown) => void;
 	/**
@@ -55,6 +64,8 @@ interface BatchTransportOptions {
 }
 /** A {@link Transport} that batches entries and can be flushed on demand. */
 interface AdapterTransport extends Transport {
+	/** Stops accepting entries, then flushes the ones already accepted. Idempotent. */
+	close: () => Promise<void>;
 	/** Sends any buffered entries immediately. Call before process exit. */
 	flush: () => Promise<void>;
 }

package/dist/datadog.js

@@ -1,4 +1,4 @@
-import{d as x,e as N,g as Q,j as V}from"./shared/Logixlysia-z6rmszwk.js";import"./shared/Logixlysia-e797097d.js";var $="datadoghq.com",M="logixlysia",B=(q={})=>{let z=q.apiKey??x("DD_API_KEY");if(!z)throw N("Datadog","missing API key. Set DD_API_KEY or pass apiKey to createDatadogTransport()");let W=q.site??x("DD_SITE")??$,X=q.service??x("DD_SERVICE")??M,G=q.hostname??x("DD_HOSTNAME"),Y=q.source??M,J=Object.entries(q.tags??{}).map(([j,w])=>`${j}:${w}`).join(","),Z=(j)=>{let w={...j.meta,ddsource:Y,message:V(j),service:X,status:j.level.toLowerCase(),timestamp:j.timestamp.toISOString()};if(J)w.ddtags=J;if(G)w.hostname=G;if(typeof j.meta.status==="number")w.http={status_code:j.meta.status};return w};return Q({body:(j)=>JSON.stringify(j.map(Z)),headers:{"Content-Type":"application/json","DD-API-KEY":z},name:"Datadog",options:q,url:`https://http-intake.logs.${W}/api/v2/logs`})};export{B as createDatadogTransport};
+import{d as z,e as V,g as W,j as X}from"./shared/Logixlysia-xb08zg3q.js";import{k as Q}from"./shared/Logixlysia-tqpczh9a.js";var B="datadoghq.com",N="logixlysia",b=(w={})=>{let G=w.apiKey??z("DD_API_KEY");if(!G)throw V("Datadog","missing API key. Set DD_API_KEY or pass apiKey to createDatadogTransport()");let Y=w.site??z("DD_SITE")??B,Z=w.service??z("DD_SERVICE")??N,J=w.hostname??z("DD_HOSTNAME"),$=w.source??N,M=Object.entries(w.tags??{}).map(([q,x])=>`${q}:${x}`).join(","),j=(q)=>{let x={...q.meta,ddsource:$,message:X(q),service:Z,status:q.level.toLowerCase(),timestamp:q.timestamp.toISOString()};if(M)x.ddtags=M;if(J)x.hostname=J;if(typeof q.meta.status==="number")x.http={status_code:q.meta.status};return x};return W({body:(q)=>Q(q.map(j)),headers:{"Content-Type":"application/json","DD-API-KEY":G},name:"Datadog",options:w,url:`https://http-intake.logs.${Y}/api/v2/logs`})};export{b as createDatadogTransport};
 
-//# debugId=409B5062E931721164756E2164756E21
-//# sourceMappingURL=data:application/json;base64,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
+//# debugId=2A62BE9F1CA2BFC064756E2164756E21
+//# sourceMappingURL=data:application/json;base64,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

package/dist/enrichers.js

@@ -1,4 +1,4 @@
-var H=/^(?<version>[\da-f]{2})-(?<traceId>[\da-f]{32})-(?<spanId>[\da-f]{16})-(?<flags>[\da-f]{2})(?:-.+)?$/u,L="0".repeat(32),T="0".repeat(16);var c=(j={})=>{let J=j.header??"traceparent";return{request(Q){let K=Q.headers.get(J);if(!K)return;let $=K.trim(),U=H.exec($);if(!U)return;let[,W,V,z,Z]=U;if(W==="ff"||V===L||z===T||W==="00"&&$.length!==55)return;let x={span_id:z,trace_flags:Z,trace_id:V,trace_sampled:Number.parseInt(Z,16)%2===1};if(j.tracestate){let F=Q.headers.get("tracestate");if(F)x.tracestate=F.slice(0,512)}return x}}},B=/bot|crawl|spider|slurp|facebookexternalhit|preview|headless/iu,C=/ipad|tablet|playbook|silk|kindle/iu,N=/mobi|iphone|ipod|windows phone/iu,A=/android.*mobile/iu,S=[["Edge",/edg(?:a|ios)?\/(?<version>[\d.]+)/iu],["Opera",/(?:opr|opios|opera)\/(?<version>[\d.]+)/iu],["Samsung Internet",/samsungbrowser\/(?<version>[\d.]+)/iu],["Firefox",/(?:firefox|fxios)\/(?<version>[\d.]+)/iu],["Chrome",/(?:chrome|crios)\/(?<version>[\d.]+)/iu],["Safari",/version\/(?<version>[\d.]+).*safari/iu]],w=[["iOS",/iphone|ipad|ipod/iu],["Android",/android/iu],["ChromeOS",/cros/iu],["Windows",/windows nt/iu],["macOS",/mac os x/iu],["Linux",/linux/iu]],P=(j,J)=>{for(let[Q,K]of j){let $=K.exec(J);if($)return{name:Q,version:$[1]}}},D=(j,J)=>{if(J)return"bot";if(C.test(j))return"tablet";if(N.test(j)||A.test(j))return"mobile";return"desktop"},m=()=>({request(j){let J=j.headers.get("user-agent");if(!J)return;let Q=B.test(J),K=P(S,J),$=P(w,J);return{ua:{bot:Q,...K?{browser:K.name}:{},...K?.version?{browserVersion:K.version}:{},device:D(J,Q),...$?{os:$.name}:{}}}}}),G=[["city",["x-vercel-ip-city","cf-ipcity"]],["country",["x-vercel-ip-country","cf-ipcountry"]],["region",["x-vercel-ip-country-region","cf-region-code","cf-region"]],["timezone",["x-vercel-ip-timezone","cf-timezone"]]],b=[["latitude",["x-vercel-ip-latitude","cf-iplatitude"],[-90,90]],["longitude",["x-vercel-ip-longitude","cf-iplongitude"],[-180,180]]];var Y=/^[A-Za-z0-9-]{1,10}$/u,M=(j,J)=>{for(let Q of J){let K=j.headers.get(Q);if(K)return K}},y=(j)=>{try{return decodeURIComponent(j).slice(0,128)}catch{return j.slice(0,128)}},k=(j,J,Q)=>j>=J&&j<=Q,I=(j)=>{let J=j.headers.get("x-nf-geo");if(!J||J.length>2048)return;let Q;try{Q=JSON.parse(atob(J))}catch{return}if(Q===null||typeof Q!=="object")return;let K=Q,$={};if(K.city)$.city=K.city.slice(0,128);if(K.country?.code&&Y.test(K.country.code))$.country=K.country.code;if(K.subdivision?.code&&Y.test(K.subdivision.code))$.region=K.subdivision.code;if(K.timezone)$.timezone=K.timezone.slice(0,128);if(typeof K.latitude==="number"&&k(K.latitude,-90,90))$.latitude=K.latitude;if(typeof K.longitude==="number"&&k(K.longitude,-180,180))$.longitude=K.longitude;return Object.keys($).length>0?$:void 0},f=new Set(["country","region"]),_=(j,J)=>{for(let[Q,K]of G){let $=M(j,K);if(!$)continue;let U=y($);if(!f.has(Q)||Y.test(U))J[Q]=U}},O=(j,J)=>{for(let[Q,K,[$,U]]of b){let W=M(j,K),V=W===void 0?Number.NaN:Number(W);if(Number.isFinite(V)&&k(V,$,U))J[Q]=V}},q=()=>({request(j){let J={};if(_(j,J),O(j,J),Object.keys(J).length>0)return{geo:J};let Q=I(j);return Q?{geo:Q}:void 0}}),X=(j)=>{if(typeof j==="number"&&Number.isFinite(j)&&j>=0)return j;if(typeof j!=="string"||j.length===0)return;let J=Number(j);return Number.isFinite(J)&&J>=0?J:void 0},R=(j,J)=>{for(let[Q,K]of Object.entries(j))if(Q.toLowerCase()===J)return K},p=()=>({request(j){let J=X(j.headers.get("content-length"));return J===void 0?void 0:{requestBytes:J}},response(j){let J=X(R(j.headers,"content-length"));return J===void 0?void 0:{responseBytes:J}}});export{m as userAgentEnricher,c as traceparentEnricher,p as sizeEnricher,q as geoEnricher};
+var B=/^(?<version>[\da-f]{2})-(?<traceId>[\da-f]{32})-(?<spanId>[\da-f]{16})-(?<flags>[\da-f]{2})(?:-.+)?$/u,N="0".repeat(32),A="0".repeat(16);var p=(j={})=>{let J=j.header??"traceparent";return{request(Q){let K=Q.headers.get(J);if(!K)return;let $=K.trim(),U=B.exec($);if(!U)return;let[,W,V,Y,X]=U;if(W==="ff"||V===N||Y===A||W==="00"&&$.length!==55)return;let Z={span_id:Y,trace_flags:X,trace_id:V,trace_sampled:Number.parseInt(X,16)%2===1};if(j.tracestate){let F=Q.headers.get("tracestate");if(F)Z.tracestate=F.slice(0,512)}return Z}}},C=/bot|crawl|spider|slurp|facebookexternalhit|preview|headless/iu,S=/ipad|tablet|playbook|silk|kindle/iu,T=/mobi|iphone|ipod|windows phone/iu,w=/android.*mobile/iu,D=[["Edge",/edg(?:a|ios)?\/(?<version>[\d.]+)/iu],["Opera",/(?:opr|opios|opera)\/(?<version>[\d.]+)/iu],["Samsung Internet",/samsungbrowser\/(?<version>[\d.]+)/iu],["Firefox",/(?:firefox|fxios)\/(?<version>[\d.]+)/iu],["Chrome",/(?:chrome|crios)\/(?<version>[\d.]+)/iu],["Safari",/version\/(?<version>[\d.]+).*safari/iu]],G=[["iOS",/iphone|ipad|ipod/iu],["Android",/android/iu],["ChromeOS",/cros/iu],["Windows",/windows nt/iu],["macOS",/mac os x/iu],["Linux",/linux/iu]],P=(j,J)=>{for(let[Q,K]of j){let $=K.exec(J);if($)return{name:Q,version:$[1]}}},b=(j,J)=>{if(J)return"bot";if(S.test(j))return"tablet";if(T.test(j)||w.test(j))return"mobile";return"desktop"},c=()=>({request(j){let J=j.headers.get("user-agent");if(!J)return;let Q=C.test(J),K=P(D,J),$=P(G,J);return{ua:{bot:Q,...K?{browser:K.name}:{},...K?.version?{browserVersion:K.version}:{},device:b(J,Q),...$?{os:$.name}:{}}}}}),I=[["city",["x-vercel-ip-city","cf-ipcity"]],["country",["x-vercel-ip-country","cf-ipcountry"]],["region",["x-vercel-ip-country-region","cf-region-code","cf-region"]],["timezone",["x-vercel-ip-timezone","cf-timezone"]]],_=[["latitude",["x-vercel-ip-latitude","cf-iplatitude"],[-90,90]],["longitude",["x-vercel-ip-longitude","cf-iplongitude"],[-180,180]]];var H=/^[A-Za-z0-9-]{1,10}$/u,L=(j,J)=>{for(let Q of J){let K=j.headers.get(Q);if(K)return K}},f=(j)=>{try{return decodeURIComponent(j).slice(0,128)}catch{return j.slice(0,128)}},k=(j,J,Q)=>j>=J&&j<=Q,z=(j)=>typeof j==="string"&&j.length>0?j.slice(0,128):void 0,M=(j)=>typeof j==="string"&&H.test(j)?j:void 0,O=(j)=>{let J=j.headers.get("x-nf-geo");if(!J||J.length>2048)return;let Q;try{Q=JSON.parse(atob(J))}catch{return}if(Q===null||typeof Q!=="object")return;let K=Q,$={},U=z(K.city);if(U!==void 0)$.city=U;let W=M(K.country?.code);if(W!==void 0)$.country=W;let V=M(K.subdivision?.code);if(V!==void 0)$.region=V;let Y=z(K.timezone);if(Y!==void 0)$.timezone=Y;if(typeof K.latitude==="number"&&k(K.latitude,-90,90))$.latitude=K.latitude;if(typeof K.longitude==="number"&&k(K.longitude,-180,180))$.longitude=K.longitude;return Object.keys($).length>0?$:void 0},y=new Set(["country","region"]),R=(j,J)=>{for(let[Q,K]of I){let $=L(j,K);if(!$)continue;let U=f($);if(!y.has(Q)||H.test(U))J[Q]=U}},q=(j,J)=>{for(let[Q,K,[$,U]]of _){let W=L(j,K),V=W===void 0?Number.NaN:Number(W);if(Number.isFinite(V)&&k(V,$,U))J[Q]=V}},h=()=>({request(j){let J={};if(R(j,J),q(j,J),Object.keys(J).length>0)return{geo:J};let Q=O(j);return Q?{geo:Q}:void 0}}),x=(j)=>{if(typeof j==="number"&&Number.isFinite(j)&&j>=0)return j;if(typeof j!=="string"||j.length===0)return;let J=Number(j);return Number.isFinite(J)&&J>=0?J:void 0},m=(j,J)=>{for(let[Q,K]of Object.entries(j))if(Q.toLowerCase()===J)return K},E=()=>({request(j){let J=x(j.headers.get("content-length"));return J===void 0?void 0:{requestBytes:J}},response(j){let J=x(m(j.headers,"content-length"));return J===void 0?void 0:{responseBytes:J}}});export{c as userAgentEnricher,p as traceparentEnricher,E as sizeEnricher,h as geoEnricher};
 
-//# debugId=BC77FE35BFD197A864756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/enrichers.ts"],
  "sourcesContent": [
    "import type {\n  Enricher,\n  EnricherFields,\n  EnricherResponseInput\n} from './types/enricher'\n\nexport type {\n  Enricher,\n  EnricherFields,\n  EnricherLike,\n  EnricherResponseInput\n} from './types/enricher'\n\nconst HEX_RADIX = 16\nconst MAX_TRACESTATE_LENGTH = 512\n\n// version-trace_id-parent_id-flags, with an optional tail for versions > 00.\nconst TRACEPARENT =\n  /^(?<version>[\\da-f]{2})-(?<traceId>[\\da-f]{32})-(?<spanId>[\\da-f]{16})-(?<flags>[\\da-f]{2})(?:-.+)?$/u\nconst ZERO_TRACE_ID = '0'.repeat(32)\nconst ZERO_SPAN_ID = '0'.repeat(16)\nconst INVALID_VERSION = 'ff'\nconst CURRENT_VERSION = '00'\n/** `00-` + 32 + `-` + 16 + `-` + 2: version 00 is exactly these four fields. */\nconst VERSION_00_LENGTH = 55\n\nexport interface TraceparentEnricherOptions {\n  /**\n   * Header to read the trace context from.\n   * @default 'traceparent'\n   */\n  header?: string\n  /**\n   * Also record the raw `tracestate` header (truncated to 512 characters).\n   * @default false\n   */\n  tracestate?: boolean\n}\n\n/**\n * Reads W3C trace context straight off the request headers, so logs link to\n * traces in Sentry, HyperDX, or any OTLP backend without an OpenTelemetry SDK\n * in the process.\n *\n * Use `logixlysia/otel` instead when you already run the SDK and want the ids\n * of the *active span* rather than the ids the caller propagated.\n *\n * Adds `trace_id`, `span_id`, `trace_flags`, and `trace_sampled`.\n */\nexport const traceparentEnricher = (\n  options: TraceparentEnricherOptions = {}\n): Enricher => {\n  const header = options.header ?? 'traceparent'\n\n  return {\n    request(request) {\n      const raw = request.headers.get(header)\n      if (!raw) {\n        return\n      }\n\n      const value = raw.trim()\n      const match = TRACEPARENT.exec(value)\n      if (!match) {\n        return\n      }\n\n      const [, version, traceId, spanId, flags] = match\n\n      // `ff` is reserved, all-zero ids are invalid, and a version-00 header\n      // carrying extra fields is malformed rather than forward-compatible.\n      if (\n        version === INVALID_VERSION ||\n        traceId === ZERO_TRACE_ID ||\n        spanId === ZERO_SPAN_ID ||\n        (version === CURRENT_VERSION && value.length !== VERSION_00_LENGTH)\n      ) {\n        return\n      }\n\n      const fields: Record<string, unknown> = {\n        span_id: spanId,\n        trace_flags: flags,\n        trace_id: traceId,\n        // `sampled` is the low bit of the flags byte, so an odd value is set.\n        trace_sampled: Number.parseInt(flags, HEX_RADIX) % 2 === 1\n      }\n\n      if (options.tracestate) {\n        const state = request.headers.get('tracestate')\n        if (state) {\n          fields.tracestate = state.slice(0, MAX_TRACESTATE_LENGTH)\n        }\n      }\n\n      return fields\n    }\n  }\n}\n\nconst BOT = /bot|crawl|spider|slurp|facebookexternalhit|preview|headless/iu\nconst TABLET = /ipad|tablet|playbook|silk|kindle/iu\nconst MOBILE = /mobi|iphone|ipod|windows phone/iu\nconst ANDROID_MOBILE = /android.*mobile/iu\n\n/** First match wins, so more specific engines are listed before their base. */\nconst BROWSERS: readonly [name: string, pattern: RegExp][] = [\n  ['Edge', /edg(?:a|ios)?\\/(?<version>[\\d.]+)/iu],\n  ['Opera', /(?:opr|opios|opera)\\/(?<version>[\\d.]+)/iu],\n  ['Samsung Internet', /samsungbrowser\\/(?<version>[\\d.]+)/iu],\n  ['Firefox', /(?:firefox|fxios)\\/(?<version>[\\d.]+)/iu],\n  ['Chrome', /(?:chrome|crios)\\/(?<version>[\\d.]+)/iu],\n  ['Safari', /version\\/(?<version>[\\d.]+).*safari/iu]\n]\n\nconst OPERATING_SYSTEMS: readonly [name: string, pattern: RegExp][] = [\n  ['iOS', /iphone|ipad|ipod/iu],\n  ['Android', /android/iu],\n  ['ChromeOS', /cros/iu],\n  ['Windows', /windows nt/iu],\n  ['macOS', /mac os x/iu],\n  ['Linux', /linux/iu]\n]\n\nconst matchName = (\n  candidates: readonly [string, RegExp][],\n  value: string\n): { name: string; version?: string } | undefined => {\n  for (const [name, pattern] of candidates) {\n    const match = pattern.exec(value)\n    if (match) {\n      return { name, version: match[1] }\n    }\n  }\n}\n\nconst resolveDevice = (value: string, bot: boolean): string => {\n  if (bot) {\n    return 'bot'\n  }\n  if (TABLET.test(value)) {\n    return 'tablet'\n  }\n  if (MOBILE.test(value) || ANDROID_MOBILE.test(value)) {\n    return 'mobile'\n  }\n  return 'desktop'\n}\n\n/**\n * Turns the `user-agent` header into queryable fields under `ua`: `browser`,\n * `browserVersion`, `os`, `device` (`desktop` | `mobile` | `tablet` | `bot`),\n * and `bot`.\n *\n * Deliberately a heuristic — user agents are not a parseable grammar. It is\n * built for grouping traffic in a dashboard, not for making access decisions.\n */\nexport const userAgentEnricher = (): Enricher => ({\n  request(request) {\n    const value = request.headers.get('user-agent')\n    if (!value) {\n      return\n    }\n\n    const bot = BOT.test(value)\n    const browser = matchName(BROWSERS, value)\n    const os = matchName(OPERATING_SYSTEMS, value)\n\n    return {\n      ua: {\n        bot,\n        ...(browser ? { browser: browser.name } : {}),\n        ...(browser?.version ? { browserVersion: browser.version } : {}),\n        device: resolveDevice(value, bot),\n        ...(os ? { os: os.name } : {})\n      }\n    }\n  }\n})\n\n/** Header candidates per geo field, in priority order across platforms. */\nconst GEO_HEADERS: readonly [field: string, headers: readonly string[]][] = [\n  ['city', ['x-vercel-ip-city', 'cf-ipcity']],\n  ['country', ['x-vercel-ip-country', 'cf-ipcountry']],\n  ['region', ['x-vercel-ip-country-region', 'cf-region-code', 'cf-region']],\n  ['timezone', ['x-vercel-ip-timezone', 'cf-timezone']]\n]\n\nconst GEO_NUMERIC_HEADERS: readonly [\n  field: string,\n  headers: readonly string[],\n  range: readonly [number, number]\n][] = [\n  ['latitude', ['x-vercel-ip-latitude', 'cf-iplatitude'], [-90, 90]],\n  ['longitude', ['x-vercel-ip-longitude', 'cf-iplongitude'], [-180, 180]]\n]\n\nconst NETLIFY_GEO_HEADER = 'x-nf-geo'\nconst GEO_STRING_MAX = 128\nconst GEO_RAW_HEADER_MAX = 2048\n/** ISO-3166-ish country/region codes: short alphanumeric tokens, never free text. */\nconst GEO_CODE_REGEX = /^[A-Za-z0-9-]{1,10}$/u\n\nconst firstHeader = (\n  request: Request,\n  headers: readonly string[]\n): string | undefined => {\n  for (const header of headers) {\n    const value = request.headers.get(header)\n    if (value) {\n      return value\n    }\n  }\n}\n\n/** Vercel percent-encodes city names, so `S%C3%A3o%20Paulo` must be decoded. */\nconst decodeHeaderValue = (value: string): string => {\n  try {\n    return decodeURIComponent(value).slice(0, GEO_STRING_MAX)\n  } catch {\n    return value.slice(0, GEO_STRING_MAX)\n  }\n}\n\nconst isInRange = (value: number, min: number, max: number): boolean =>\n  value >= min && value <= max\n\ninterface NetlifyGeo {\n  city?: string\n  country?: { code?: string }\n  latitude?: number\n  longitude?: number\n  subdivision?: { code?: string }\n  timezone?: string\n}\n\nconst readNetlifyGeo = (\n  request: Request\n): Record<string, unknown> | undefined => {\n  const raw = request.headers.get(NETLIFY_GEO_HEADER)\n  if (!raw || raw.length > GEO_RAW_HEADER_MAX) {\n    return\n  }\n\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(atob(raw))\n  } catch {\n    return\n  }\n\n  if (parsed === null || typeof parsed !== 'object') {\n    return\n  }\n\n  const data = parsed as NetlifyGeo\n  const geo: Record<string, unknown> = {}\n  if (data.city) {\n    geo.city = data.city.slice(0, GEO_STRING_MAX)\n  }\n  if (data.country?.code && GEO_CODE_REGEX.test(data.country.code)) {\n    geo.country = data.country.code\n  }\n  if (data.subdivision?.code && GEO_CODE_REGEX.test(data.subdivision.code)) {\n    geo.region = data.subdivision.code\n  }\n  if (data.timezone) {\n    geo.timezone = data.timezone.slice(0, GEO_STRING_MAX)\n  }\n  if (typeof data.latitude === 'number' && isInRange(data.latitude, -90, 90)) {\n    geo.latitude = data.latitude\n  }\n  if (\n    typeof data.longitude === 'number' &&\n    isInRange(data.longitude, -180, 180)\n  ) {\n    geo.longitude = data.longitude\n  }\n\n  return Object.keys(geo).length > 0 ? geo : undefined\n}\n\n/** Fields whose value must look like a short country/region code, not free text. */\nconst GEO_CODE_FIELDS = new Set(['country', 'region'])\n\nconst readGeoStringFields = (\n  request: Request,\n  geo: Record<string, unknown>\n): void => {\n  for (const [field, headers] of GEO_HEADERS) {\n    const value = firstHeader(request, headers)\n    if (!value) {\n      continue\n    }\n    const decoded = decodeHeaderValue(value)\n    if (!GEO_CODE_FIELDS.has(field) || GEO_CODE_REGEX.test(decoded)) {\n      geo[field] = decoded\n    }\n  }\n}\n\nconst readGeoNumericFields = (\n  request: Request,\n  geo: Record<string, unknown>\n): void => {\n  for (const [field, headers, [min, max]] of GEO_NUMERIC_HEADERS) {\n    const value = firstHeader(request, headers)\n    const parsed = value === undefined ? Number.NaN : Number(value)\n    if (Number.isFinite(parsed) && isInRange(parsed, min, max)) {\n      geo[field] = parsed\n    }\n  }\n}\n\n/**\n * Reads the geo headers the edge already attached — Vercel, Cloudflare, or\n * Netlify — into `geo.city`, `geo.country`, `geo.region`, `geo.timezone`,\n * `geo.latitude`, and `geo.longitude`.\n *\n * Nothing is derived from the IP address itself, so behind a platform that\n * does not set these headers the enricher simply adds nothing.\n *\n * These headers are client-settable unless an edge in front of the app\n * overwrites them on every request — trust the values only behind such an\n * edge.\n */\nexport const geoEnricher = (): Enricher => ({\n  request(request) {\n    const geo: Record<string, unknown> = {}\n\n    readGeoStringFields(request, geo)\n    readGeoNumericFields(request, geo)\n\n    if (Object.keys(geo).length > 0) {\n      return { geo }\n    }\n\n    const netlify = readNetlifyGeo(request)\n    return netlify ? { geo: netlify } : undefined\n  }\n})\n\nconst readContentLength = (value: unknown): number | undefined => {\n  if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {\n    return value\n  }\n  if (typeof value !== 'string' || value.length === 0) {\n    return\n  }\n  const parsed = Number(value)\n  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined\n}\n\nconst findHeader = (\n  headers: Record<string, unknown>,\n  name: string\n): unknown => {\n  for (const [key, value] of Object.entries(headers)) {\n    if (key.toLowerCase() === name) {\n      return value\n    }\n  }\n}\n\n/**\n * Records payload sizes as `requestBytes` and `responseBytes`.\n *\n * Both come from `content-length`, which is the only size the plugin can read\n * without buffering a body. A chunked or streamed response has no\n * `content-length`, so `responseBytes` is omitted rather than guessed.\n */\nexport const sizeEnricher = (): Enricher => ({\n  request(request): EnricherFields {\n    const bytes = readContentLength(request.headers.get('content-length'))\n    return bytes === undefined ? undefined : { requestBytes: bytes }\n  },\n  response(input: EnricherResponseInput): EnricherFields {\n    const bytes = readContentLength(findHeader(input.headers, 'content-length'))\n    return bytes === undefined ? undefined : { responseBytes: bytes }\n  }\n})\n"
  ],
  "mappings": "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",
  "debugId": "BC77FE35BFD197A864756E2164756E21",
  "names": []
}
+//# debugId=F9439F8C6145769D64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/enrichers.ts"],
  "sourcesContent": [
    "import type {\n  Enricher,\n  EnricherFields,\n  EnricherResponseInput\n} from './types/enricher'\n\nexport type {\n  Enricher,\n  EnricherFields,\n  EnricherLike,\n  EnricherResponseInput\n} from './types/enricher'\n\nconst HEX_RADIX = 16\nconst MAX_TRACESTATE_LENGTH = 512\n\n// version-trace_id-parent_id-flags, with an optional tail for versions > 00.\nconst TRACEPARENT =\n  /^(?<version>[\\da-f]{2})-(?<traceId>[\\da-f]{32})-(?<spanId>[\\da-f]{16})-(?<flags>[\\da-f]{2})(?:-.+)?$/u\nconst ZERO_TRACE_ID = '0'.repeat(32)\nconst ZERO_SPAN_ID = '0'.repeat(16)\nconst INVALID_VERSION = 'ff'\nconst CURRENT_VERSION = '00'\n/** `00-` + 32 + `-` + 16 + `-` + 2: version 00 is exactly these four fields. */\nconst VERSION_00_LENGTH = 55\n\nexport interface TraceparentEnricherOptions {\n  /**\n   * Header to read the trace context from.\n   * @default 'traceparent'\n   */\n  header?: string\n  /**\n   * Also record the raw `tracestate` header (truncated to 512 characters).\n   * @default false\n   */\n  tracestate?: boolean\n}\n\n/**\n * Reads W3C trace context straight off the request headers, so logs link to\n * traces in Sentry, HyperDX, or any OTLP backend without an OpenTelemetry SDK\n * in the process.\n *\n * Use `logixlysia/otel` instead when you already run the SDK and want the ids\n * of the *active span* rather than the ids the caller propagated.\n *\n * Adds `trace_id`, `span_id`, `trace_flags`, and `trace_sampled`.\n */\nexport const traceparentEnricher = (\n  options: TraceparentEnricherOptions = {}\n): Enricher => {\n  const header = options.header ?? 'traceparent'\n\n  return {\n    request(request) {\n      const raw = request.headers.get(header)\n      if (!raw) {\n        return\n      }\n\n      const value = raw.trim()\n      const match = TRACEPARENT.exec(value)\n      if (!match) {\n        return\n      }\n\n      const [, version, traceId, spanId, flags] = match\n\n      // `ff` is reserved, all-zero ids are invalid, and a version-00 header\n      // carrying extra fields is malformed rather than forward-compatible.\n      if (\n        version === INVALID_VERSION ||\n        traceId === ZERO_TRACE_ID ||\n        spanId === ZERO_SPAN_ID ||\n        (version === CURRENT_VERSION && value.length !== VERSION_00_LENGTH)\n      ) {\n        return\n      }\n\n      const fields: Record<string, unknown> = {\n        span_id: spanId,\n        trace_flags: flags,\n        trace_id: traceId,\n        // `sampled` is the low bit of the flags byte, so an odd value is set.\n        trace_sampled: Number.parseInt(flags, HEX_RADIX) % 2 === 1\n      }\n\n      if (options.tracestate) {\n        const state = request.headers.get('tracestate')\n        if (state) {\n          fields.tracestate = state.slice(0, MAX_TRACESTATE_LENGTH)\n        }\n      }\n\n      return fields\n    }\n  }\n}\n\nconst BOT = /bot|crawl|spider|slurp|facebookexternalhit|preview|headless/iu\nconst TABLET = /ipad|tablet|playbook|silk|kindle/iu\nconst MOBILE = /mobi|iphone|ipod|windows phone/iu\nconst ANDROID_MOBILE = /android.*mobile/iu\n\n/** First match wins, so more specific engines are listed before their base. */\nconst BROWSERS: readonly [name: string, pattern: RegExp][] = [\n  ['Edge', /edg(?:a|ios)?\\/(?<version>[\\d.]+)/iu],\n  ['Opera', /(?:opr|opios|opera)\\/(?<version>[\\d.]+)/iu],\n  ['Samsung Internet', /samsungbrowser\\/(?<version>[\\d.]+)/iu],\n  ['Firefox', /(?:firefox|fxios)\\/(?<version>[\\d.]+)/iu],\n  ['Chrome', /(?:chrome|crios)\\/(?<version>[\\d.]+)/iu],\n  ['Safari', /version\\/(?<version>[\\d.]+).*safari/iu]\n]\n\nconst OPERATING_SYSTEMS: readonly [name: string, pattern: RegExp][] = [\n  ['iOS', /iphone|ipad|ipod/iu],\n  ['Android', /android/iu],\n  ['ChromeOS', /cros/iu],\n  ['Windows', /windows nt/iu],\n  ['macOS', /mac os x/iu],\n  ['Linux', /linux/iu]\n]\n\nconst matchName = (\n  candidates: readonly [string, RegExp][],\n  value: string\n): { name: string; version?: string } | undefined => {\n  for (const [name, pattern] of candidates) {\n    const match = pattern.exec(value)\n    if (match) {\n      return { name, version: match[1] }\n    }\n  }\n}\n\nconst resolveDevice = (value: string, bot: boolean): string => {\n  if (bot) {\n    return 'bot'\n  }\n  if (TABLET.test(value)) {\n    return 'tablet'\n  }\n  if (MOBILE.test(value) || ANDROID_MOBILE.test(value)) {\n    return 'mobile'\n  }\n  return 'desktop'\n}\n\n/**\n * Turns the `user-agent` header into queryable fields under `ua`: `browser`,\n * `browserVersion`, `os`, `device` (`desktop` | `mobile` | `tablet` | `bot`),\n * and `bot`.\n *\n * Deliberately a heuristic — user agents are not a parseable grammar. It is\n * built for grouping traffic in a dashboard, not for making access decisions.\n */\nexport const userAgentEnricher = (): Enricher => ({\n  request(request) {\n    const value = request.headers.get('user-agent')\n    if (!value) {\n      return\n    }\n\n    const bot = BOT.test(value)\n    const browser = matchName(BROWSERS, value)\n    const os = matchName(OPERATING_SYSTEMS, value)\n\n    return {\n      ua: {\n        bot,\n        ...(browser ? { browser: browser.name } : {}),\n        ...(browser?.version ? { browserVersion: browser.version } : {}),\n        device: resolveDevice(value, bot),\n        ...(os ? { os: os.name } : {})\n      }\n    }\n  }\n})\n\n/** Header candidates per geo field, in priority order across platforms. */\nconst GEO_HEADERS: readonly [field: string, headers: readonly string[]][] = [\n  ['city', ['x-vercel-ip-city', 'cf-ipcity']],\n  ['country', ['x-vercel-ip-country', 'cf-ipcountry']],\n  ['region', ['x-vercel-ip-country-region', 'cf-region-code', 'cf-region']],\n  ['timezone', ['x-vercel-ip-timezone', 'cf-timezone']]\n]\n\nconst GEO_NUMERIC_HEADERS: readonly [\n  field: string,\n  headers: readonly string[],\n  range: readonly [number, number]\n][] = [\n  ['latitude', ['x-vercel-ip-latitude', 'cf-iplatitude'], [-90, 90]],\n  ['longitude', ['x-vercel-ip-longitude', 'cf-iplongitude'], [-180, 180]]\n]\n\nconst NETLIFY_GEO_HEADER = 'x-nf-geo'\nconst GEO_STRING_MAX = 128\nconst GEO_RAW_HEADER_MAX = 2048\n/** ISO-3166-ish country/region codes: short alphanumeric tokens, never free text. */\nconst GEO_CODE_REGEX = /^[A-Za-z0-9-]{1,10}$/u\n\nconst firstHeader = (\n  request: Request,\n  headers: readonly string[]\n): string | undefined => {\n  for (const header of headers) {\n    const value = request.headers.get(header)\n    if (value) {\n      return value\n    }\n  }\n}\n\n/** Vercel percent-encodes city names, so `S%C3%A3o%20Paulo` must be decoded. */\nconst decodeHeaderValue = (value: string): string => {\n  try {\n    return decodeURIComponent(value).slice(0, GEO_STRING_MAX)\n  } catch {\n    return value.slice(0, GEO_STRING_MAX)\n  }\n}\n\nconst isInRange = (value: number, min: number, max: number): boolean =>\n  value >= min && value <= max\n\ninterface NetlifyGeo {\n  city?: string\n  country?: { code?: string }\n  latitude?: number\n  longitude?: number\n  subdivision?: { code?: string }\n  timezone?: string\n}\n\n/** A non-empty string field, bounded; any other type is ignored. */\nconst geoText = (value: unknown): string | undefined =>\n  typeof value === 'string' && value.length > 0\n    ? value.slice(0, GEO_STRING_MAX)\n    : undefined\n\n/** A string that is a short country or region code; any other value is ignored. */\nconst geoCode = (value: unknown): string | undefined =>\n  typeof value === 'string' && GEO_CODE_REGEX.test(value) ? value : undefined\n\nconst readNetlifyGeo = (\n  request: Request\n): Record<string, unknown> | undefined => {\n  const raw = request.headers.get(NETLIFY_GEO_HEADER)\n  if (!raw || raw.length > GEO_RAW_HEADER_MAX) {\n    return\n  }\n\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(atob(raw))\n  } catch {\n    return\n  }\n\n  if (parsed === null || typeof parsed !== 'object') {\n    return\n  }\n\n  const data = parsed as NetlifyGeo\n  const geo: Record<string, unknown> = {}\n  const city = geoText(data.city)\n  if (city !== undefined) {\n    geo.city = city\n  }\n  const country = geoCode(data.country?.code)\n  if (country !== undefined) {\n    geo.country = country\n  }\n  const region = geoCode(data.subdivision?.code)\n  if (region !== undefined) {\n    geo.region = region\n  }\n  const timezone = geoText(data.timezone)\n  if (timezone !== undefined) {\n    geo.timezone = timezone\n  }\n  if (typeof data.latitude === 'number' && isInRange(data.latitude, -90, 90)) {\n    geo.latitude = data.latitude\n  }\n  if (\n    typeof data.longitude === 'number' &&\n    isInRange(data.longitude, -180, 180)\n  ) {\n    geo.longitude = data.longitude\n  }\n\n  return Object.keys(geo).length > 0 ? geo : undefined\n}\n\n/** Fields whose value must look like a short country/region code, not free text. */\nconst GEO_CODE_FIELDS = new Set(['country', 'region'])\n\nconst readGeoStringFields = (\n  request: Request,\n  geo: Record<string, unknown>\n): void => {\n  for (const [field, headers] of GEO_HEADERS) {\n    const value = firstHeader(request, headers)\n    if (!value) {\n      continue\n    }\n    const decoded = decodeHeaderValue(value)\n    if (!GEO_CODE_FIELDS.has(field) || GEO_CODE_REGEX.test(decoded)) {\n      geo[field] = decoded\n    }\n  }\n}\n\nconst readGeoNumericFields = (\n  request: Request,\n  geo: Record<string, unknown>\n): void => {\n  for (const [field, headers, [min, max]] of GEO_NUMERIC_HEADERS) {\n    const value = firstHeader(request, headers)\n    const parsed = value === undefined ? Number.NaN : Number(value)\n    if (Number.isFinite(parsed) && isInRange(parsed, min, max)) {\n      geo[field] = parsed\n    }\n  }\n}\n\n/**\n * Reads the geo headers the edge already attached — Vercel, Cloudflare, or\n * Netlify — into `geo.city`, `geo.country`, `geo.region`, `geo.timezone`,\n * `geo.latitude`, and `geo.longitude`.\n *\n * Nothing is derived from the IP address itself, so behind a platform that\n * does not set these headers the enricher simply adds nothing.\n *\n * These headers are client-settable unless an edge in front of the app\n * overwrites them on every request — trust the values only behind such an\n * edge.\n */\nexport const geoEnricher = (): Enricher => ({\n  request(request) {\n    const geo: Record<string, unknown> = {}\n\n    readGeoStringFields(request, geo)\n    readGeoNumericFields(request, geo)\n\n    if (Object.keys(geo).length > 0) {\n      return { geo }\n    }\n\n    const netlify = readNetlifyGeo(request)\n    return netlify ? { geo: netlify } : undefined\n  }\n})\n\nconst readContentLength = (value: unknown): number | undefined => {\n  if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {\n    return value\n  }\n  if (typeof value !== 'string' || value.length === 0) {\n    return\n  }\n  const parsed = Number(value)\n  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined\n}\n\nconst findHeader = (\n  headers: Record<string, unknown>,\n  name: string\n): unknown => {\n  for (const [key, value] of Object.entries(headers)) {\n    if (key.toLowerCase() === name) {\n      return value\n    }\n  }\n}\n\n/**\n * Records payload sizes as `requestBytes` and `responseBytes`.\n *\n * Both come from `content-length`, which is the only size the plugin can read\n * without buffering a body. A chunked or streamed response has no\n * `content-length`, so `responseBytes` is omitted rather than guessed.\n */\nexport const sizeEnricher = (): Enricher => ({\n  request(request): EnricherFields {\n    const bytes = readContentLength(request.headers.get('content-length'))\n    return bytes === undefined ? undefined : { requestBytes: bytes }\n  },\n  response(input: EnricherResponseInput): EnricherFields {\n    const bytes = readContentLength(findHeader(input.headers, 'content-length'))\n    return bytes === undefined ? undefined : { responseBytes: bytes }\n  }\n})\n"
  ],
  "mappings": "AAiBA,IAAM,EACJ,wGACI,EAAgB,IAAI,OAAO,EAAE,EAC7B,EAAe,IAAI,OAAO,EAAE,EA6B3B,IAAM,EAAsB,CACjC,EAAsC,CAAC,IAC1B,CACb,IAAM,EAAS,EAAQ,QAAU,cAEjC,MAAO,CACL,OAAO,CAAC,EAAS,CACf,IAAM,EAAM,EAAQ,QAAQ,IAAI,CAAM,EACtC,GAAI,CAAC,EACH,OAGF,IAAM,EAAQ,EAAI,KAAK,EACjB,EAAQ,EAAY,KAAK,CAAK,EACpC,GAAI,CAAC,EACH,OAGF,KAAS,EAAS,EAAS,EAAQ,GAAS,EAI5C,GACE,IAnDgB,MAoDhB,IAAY,GACZ,IAAW,GACV,IArDe,MAqDgB,EAAM,SAnDpB,GAqDlB,OAGF,IAAM,EAAkC,CACtC,QAAS,EACT,YAAa,EACb,SAAU,EAEV,cAAe,OAAO,SAAS,EAxErB,EAwEqC,EAAI,IAAM,CAC3D,EAEA,GAAI,EAAQ,WAAY,CACtB,IAAM,EAAQ,EAAQ,QAAQ,IAAI,YAAY,EAC9C,GAAI,EACF,EAAO,WAAa,EAAM,MAAM,EA7EZ,GA6EoC,EAI5D,OAAO,EAEX,GAGI,EAAM,gEACN,EAAS,qCACT,EAAS,mCACT,EAAiB,oBAGjB,EAAuD,CAC3D,CAAC,OAAQ,qCAAqC,EAC9C,CAAC,QAAS,2CAA2C,EACrD,CAAC,mBAAoB,sCAAsC,EAC3D,CAAC,UAAW,yCAAyC,EACrD,CAAC,SAAU,wCAAwC,EACnD,CAAC,SAAU,uCAAuC,CACpD,EAEM,EAAgE,CACpE,CAAC,MAAO,oBAAoB,EAC5B,CAAC,UAAW,WAAW,EACvB,CAAC,WAAY,QAAQ,EACrB,CAAC,UAAW,cAAc,EAC1B,CAAC,QAAS,YAAY,EACtB,CAAC,QAAS,SAAS,CACrB,EAEM,EAAY,CAChB,EACA,IACmD,CACnD,QAAY,EAAM,KAAY,EAAY,CACxC,IAAM,EAAQ,EAAQ,KAAK,CAAK,EAChC,GAAI,EACF,MAAO,CAAE,OAAM,QAAS,EAAM,EAAG,IAKjC,EAAgB,CAAC,EAAe,IAAyB,CAC7D,GAAI,EACF,MAAO,MAET,GAAI,EAAO,KAAK,CAAK,EACnB,MAAO,SAET,GAAI,EAAO,KAAK,CAAK,GAAK,EAAe,KAAK,CAAK,EACjD,MAAO,SAET,MAAO,WAWI,EAAoB,KAAiB,CAChD,OAAO,CAAC,EAAS,CACf,IAAM,EAAQ,EAAQ,QAAQ,IAAI,YAAY,EAC9C,GAAI,CAAC,EACH,OAGF,IAAM,EAAM,EAAI,KAAK,CAAK,EACpB,EAAU,EAAU,EAAU,CAAK,EACnC,EAAK,EAAU,EAAmB,CAAK,EAE7C,MAAO,CACL,GAAI,CACF,SACI,EAAU,CAAE,QAAS,EAAQ,IAAK,EAAI,CAAC,KACvC,GAAS,QAAU,CAAE,eAAgB,EAAQ,OAAQ,EAAI,CAAC,EAC9D,OAAQ,EAAc,EAAO,CAAG,KAC5B,EAAK,CAAE,GAAI,EAAG,IAAK,EAAI,CAAC,CAC9B,CACF,EAEJ,GAGM,EAAsE,CAC1E,CAAC,OAAQ,CAAC,mBAAoB,WAAW,CAAC,EAC1C,CAAC,UAAW,CAAC,sBAAuB,cAAc,CAAC,EACnD,CAAC,SAAU,CAAC,6BAA8B,iBAAkB,WAAW,CAAC,EACxE,CAAC,WAAY,CAAC,uBAAwB,aAAa,CAAC,CACtD,EAEM,EAIA,CACJ,CAAC,WAAY,CAAC,uBAAwB,eAAe,EAAG,CAAC,IAAK,EAAE,CAAC,EACjE,CAAC,YAAa,CAAC,wBAAyB,gBAAgB,EAAG,CAAC,KAAM,GAAG,CAAC,CACxE,EAMA,IAAM,EAAiB,wBAEjB,EAAc,CAClB,EACA,IACuB,CACvB,QAAW,KAAU,EAAS,CAC5B,IAAM,EAAQ,EAAQ,QAAQ,IAAI,CAAM,EACxC,GAAI,EACF,OAAO,IAMP,EAAoB,CAAC,IAA0B,CACnD,GAAI,CACF,OAAO,mBAAmB,CAAK,EAAE,MAAM,EApBpB,GAoBqC,EACxD,KAAM,CACN,OAAO,EAAM,MAAM,EAtBA,GAsBiB,IAIlC,EAAY,CAAC,EAAe,EAAa,IAC7C,GAAS,GAAO,GAAS,EAYrB,EAAU,CAAC,IACf,OAAO,IAAU,UAAY,EAAM,OAAS,EACxC,EAAM,MAAM,EAzCK,GAyCY,EAC7B,OAGA,EAAU,CAAC,IACf,OAAO,IAAU,UAAY,EAAe,KAAK,CAAK,EAAI,EAAQ,OAE9D,EAAiB,CACrB,IACwC,CACxC,IAAM,EAAM,EAAQ,QAAQ,IApDH,UAoDyB,EAClD,GAAI,CAAC,GAAO,EAAI,OAnDS,KAoDvB,OAGF,IAAI,EACJ,GAAI,CACF,EAAS,KAAK,MAAM,KAAK,CAAG,CAAC,EAC7B,KAAM,CACN,OAGF,GAAI,IAAW,MAAQ,OAAO,IAAW,SACvC,OAGF,IAAM,EAAO,EACP,EAA+B,CAAC,EAChC,EAAO,EAAQ,EAAK,IAAI,EAC9B,GAAI,IAAS,OACX,EAAI,KAAO,EAEb,IAAM,EAAU,EAAQ,EAAK,SAAS,IAAI,EAC1C,GAAI,IAAY,OACd,EAAI,QAAU,EAEhB,IAAM,EAAS,EAAQ,EAAK,aAAa,IAAI,EAC7C,GAAI,IAAW,OACb,EAAI,OAAS,EAEf,IAAM,EAAW,EAAQ,EAAK,QAAQ,EACtC,GAAI,IAAa,OACf,EAAI,SAAW,EAEjB,GAAI,OAAO,EAAK,WAAa,UAAY,EAAU,EAAK,SAAU,IAAK,EAAE,EACvE,EAAI,SAAW,EAAK,SAEtB,GACE,OAAO,EAAK,YAAc,UAC1B,EAAU,EAAK,UAAW,KAAM,GAAG,EAEnC,EAAI,UAAY,EAAK,UAGvB,OAAO,OAAO,KAAK,CAAG,EAAE,OAAS,EAAI,EAAM,QAIvC,EAAkB,IAAI,IAAI,CAAC,UAAW,QAAQ,CAAC,EAE/C,EAAsB,CAC1B,EACA,IACS,CACT,QAAY,EAAO,KAAY,EAAa,CAC1C,IAAM,EAAQ,EAAY,EAAS,CAAO,EAC1C,GAAI,CAAC,EACH,SAEF,IAAM,EAAU,EAAkB,CAAK,EACvC,GAAI,CAAC,EAAgB,IAAI,CAAK,GAAK,EAAe,KAAK,CAAO,EAC5D,EAAI,GAAS,IAKb,EAAuB,CAC3B,EACA,IACS,CACT,QAAY,EAAO,GAAU,EAAK,MAAS,EAAqB,CAC9D,IAAM,EAAQ,EAAY,EAAS,CAAO,EACpC,EAAS,IAAU,OAAY,OAAO,IAAM,OAAO,CAAK,EAC9D,GAAI,OAAO,SAAS,CAAM,GAAK,EAAU,EAAQ,EAAK,CAAG,EACvD,EAAI,GAAS,IAiBN,EAAc,KAAiB,CAC1C,OAAO,CAAC,EAAS,CACf,IAAM,EAA+B,CAAC,EAKtC,GAHA,EAAoB,EAAS,CAAG,EAChC,EAAqB,EAAS,CAAG,EAE7B,OAAO,KAAK,CAAG,EAAE,OAAS,EAC5B,MAAO,CAAE,KAAI,EAGf,IAAM,EAAU,EAAe,CAAO,EACtC,OAAO,EAAU,CAAE,IAAK,CAAQ,EAAI,OAExC,GAEM,EAAoB,CAAC,IAAuC,CAChE,GAAI,OAAO,IAAU,UAAY,OAAO,SAAS,CAAK,GAAK,GAAS,EAClE,OAAO,EAET,GAAI,OAAO,IAAU,UAAY,EAAM,SAAW,EAChD,OAEF,IAAM,EAAS,OAAO,CAAK,EAC3B,OAAO,OAAO,SAAS,CAAM,GAAK,GAAU,EAAI,EAAS,QAGrD,EAAa,CACjB,EACA,IACY,CACZ,QAAY,EAAK,KAAU,OAAO,QAAQ,CAAO,EAC/C,GAAI,EAAI,YAAY,IAAM,EACxB,OAAO,GAYA,EAAe,KAAiB,CAC3C,OAAO,CAAC,EAAyB,CAC/B,IAAM,EAAQ,EAAkB,EAAQ,QAAQ,IAAI,gBAAgB,CAAC,EACrE,OAAO,IAAU,OAAY,OAAY,CAAE,aAAc,CAAM,GAEjE,QAAQ,CAAC,EAA8C,CACrD,IAAM,EAAQ,EAAkB,EAAW,EAAM,QAAS,gBAAgB,CAAC,EAC3E,OAAO,IAAU,OAAY,OAAY,CAAE,cAAe,CAAM,EAEpE",
  "debugId": "F9439F8C6145769D64756E2164756E21",
  "names": []
}

package/dist/hyperdx.d.ts

@@ -29,17 +29,26 @@ interface BatchTransportOptions {
 	*/
 	maxBatchSize?: number;
 	/**
-	* Batches allowed to be waiting on the backend at once. Once the limit is
-	* reached, new batches are dropped and reported instead of buffered, so an
-	* unreachable backend cannot grow memory without bound.
+	* The most entries one request carries. Lower it for a backend with a
+	* per-request item limit. The Sentry adapter defaults to 100.
+	* @default 500
+	*/
+	maxEntriesPerRequest?: number;
+	/**
+	* Bound on the entries that wait behind the request in flight, as a
+	* multiple of `maxBatchSize`: at most `maxPendingBatches × maxBatchSize`
+	* entries wait, and entries beyond that are dropped and reported.
 	* @default 32
 	*/
 	maxPendingBatches?: number;
 	/**
-	* Called when a batch fails after retries, or is dropped because too
-	* many batches are pending. When omitted, failures go to stderr, rate
-	* limited to once every 5 seconds. Pass the same function you give
-	* `config.onError` to see transport failures in one place.
+	* Called when a request fails after retries, or when entries are dropped
+	* because too many were already waiting. Failures of a request that a
+	* `log()` or `flush()` call started are rejected to that caller instead.
+	* When omitted, failures go to stderr, rate limited to once every 5
+	* seconds. To see every transport failure in one place, forward them to
+	* the function you give `config.onError`, as
+	* `error => handle({ error, sink: 'transport' })`.
 	*/
 	onError?: (error: unknown) => void;
 	/**
@@ -55,6 +64,8 @@ interface BatchTransportOptions {
 }
 /** A {@link Transport} that batches entries and can be flushed on demand. */
 interface AdapterTransport extends Transport {
+	/** Stops accepting entries, then flushes the ones already accepted. Idempotent. */
+	close: () => Promise<void>;
 	/** Sends any buffered entries immediately. Call before process exit. */
 	flush: () => Promise<void>;
 }

package/dist/hyperdx.js

@@ -1,4 +1,4 @@
-import{a as V}from"./shared/Logixlysia-x3k2mm9p.js";import{c as G,d as z,e as Q}from"./shared/Logixlysia-z6rmszwk.js";import"./shared/Logixlysia-e797097d.js";var Z="https://in-otel.hyperdx.io",w=(j={})=>{let B=j.apiKey??z("HYPERDX_API_KEY");if(!B)throw Q("HyperDX","missing API key. Set HYPERDX_API_KEY or pass apiKey to createHyperDXTransport()");let Y=G(j.endpoint??z("HYPERDX_OTLP_ENDPOINT")??Z);return V({headers:{authorization:B},name:"HyperDX",options:j,resourceAttributes:j.resourceAttributes??{},serviceName:j.serviceName??z("HYPERDX_SERVICE_NAME")??z("OTEL_SERVICE_NAME")??"logixlysia",url:`${Y}/v1/logs`})};export{w as createHyperDXTransport};
+import{a as V}from"./shared/Logixlysia-pa8v7y86.js";import{c as G,d as z,e as Q}from"./shared/Logixlysia-xb08zg3q.js";import"./shared/Logixlysia-tqpczh9a.js";var Z="https://in-otel.hyperdx.io",w=(j={})=>{let B=j.apiKey??z("HYPERDX_API_KEY");if(!B)throw Q("HyperDX","missing API key. Set HYPERDX_API_KEY or pass apiKey to createHyperDXTransport()");let Y=G(j.endpoint??z("HYPERDX_OTLP_ENDPOINT")??Z);return V({headers:{authorization:B},name:"HyperDX",options:j,resourceAttributes:j.resourceAttributes??{},serviceName:j.serviceName??z("HYPERDX_SERVICE_NAME")??z("OTEL_SERVICE_NAME")??"logixlysia",url:`${Y}/v1/logs`})};export{w as createHyperDXTransport};
 
 //# debugId=F0CC0AB3AC4FB4E264756E2164756E21
 //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsic3JjL2h5cGVyZHgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbCiAgICAiaW1wb3J0IHsgY3JlYXRlT3RscENvcmUgfSBmcm9tICcuL2FkYXB0ZXJzL290bHAtY29yZSdcbmltcG9ydCB7XG4gIGVudlN0cmluZyxcbiAgc3RyaXBUcmFpbGluZ1NsYXNoZXMsXG4gIHRyYW5zcG9ydEVycm9yXG59IGZyb20gJy4vYWRhcHRlcnMvc2hhcmVkJ1xuaW1wb3J0IHR5cGUgeyBBZGFwdGVyVHJhbnNwb3J0LCBCYXRjaFRyYW5zcG9ydE9wdGlvbnMgfSBmcm9tICcuL2FkYXB0ZXJzL3NoYXJlZCdcblxuY29uc3QgREVGQVVMVF9FTkRQT0lOVCA9ICdodHRwczovL2luLW90ZWwuaHlwZXJkeC5pbydcblxuZXhwb3J0IGludGVyZmFjZSBIeXBlckRYVHJhbnNwb3J0T3B0aW9ucyBleHRlbmRzIEJhdGNoVHJhbnNwb3J0T3B0aW9ucyB7XG4gIC8qKlxuICAgKiBIeXBlckRYIGluZ2VzdGlvbiBBUEkga2V5LCBzZW50IGFzIHRoZSBgYXV0aG9yaXphdGlvbmAgaGVhZGVyLlxuICAgKiBGYWxscyBiYWNrIHRvIHRoZSBgSFlQRVJEWF9BUElfS0VZYCBlbnZpcm9ubWVudCB2YXJpYWJsZS5cbiAgICovXG4gIGFwaUtleT86IHN0cmluZ1xuICAvKipcbiAgICogT1RMUCBIVFRQIGJhc2UgVVJMIOKAlCB0aGUgYWRhcHRlciBhcHBlbmRzIGAvdjEvbG9nc2AuIEZvciBzZWxmLWhvc3RlZFxuICAgKiBjb2xsZWN0b3JzIHBhc3MgdGhlIGJhc2UgVVJMIG9ubHkgKHBvcnQgNDMxOCBieSBkZWZhdWx0KS5cbiAgICogRmFsbHMgYmFjayB0byBgSFlQRVJEWF9PVExQX0VORFBPSU5UYC5cbiAgICogQGRlZmF1bHQgJ2h0dHBzOi8vaW4tb3RlbC5oeXBlcmR4LmlvJ1xuICAgKi9cbiAgZW5kcG9pbnQ/OiBzdHJpbmdcbiAgLyoqIEV4dHJhIE9UTFAgcmVzb3VyY2UgYXR0cmlidXRlcyBtZXJnZWQgbmV4dCB0byBgc2VydmljZS5uYW1lYC4gKi9cbiAgcmVzb3VyY2VBdHRyaWJ1dGVzPzogUmVjb3JkPHN0cmluZywgc3RyaW5nPlxuICAvKipcbiAgICogVmFsdWUgb2YgdGhlIGBzZXJ2aWNlLm5hbWVgIHJlc291cmNlIGF0dHJpYnV0ZS5cbiAgICogRmFsbHMgYmFjayB0byBgSFlQRVJEWF9TRVJWSUNFX05BTUVgLCB0aGVuIGBPVEVMX1NFUlZJQ0VfTkFNRWAuXG4gICAqIEBkZWZhdWx0ICdsb2dpeGx5c2lhJ1xuICAgKi9cbiAgc2VydmljZU5hbWU/OiBzdHJpbmdcbn1cblxuLyoqXG4gKiBDcmVhdGVzIGEgdHJhbnNwb3J0IHRoYXQgc2hpcHMgbG9ncyB0byBIeXBlckRYIGFzIE9UTFAgSlNPTlxuICogKGBFeHBvcnRMb2dzU2VydmljZVJlcXVlc3RgKSBvdmVyIEhUVFAuIE1ldGEgZmllbGRzIGJlY29tZSBkb3Qtbm90YXRpb24gbG9nXG4gKiBhdHRyaWJ1dGVzIChgcmVxdWVzdC5tZXRob2RgLCBgY29udGV4dC5yZXF1ZXN0SWRgLCDigKYpIHNvIHRoZXkgYXJlIHNlYXJjaGFibGVcbiAqIGluIHRoZSBIeXBlckRYIFVJLlxuICpcbiAqIEB0aHJvd3Mge0Vycm9yfSBXaGVuIG5vIEFQSSBrZXkgaXMgY29uZmlndXJlZC5cbiAqL1xuZXhwb3J0IGNvbnN0IGNyZWF0ZUh5cGVyRFhUcmFuc3BvcnQgPSAoXG4gIG9wdGlvbnM6IEh5cGVyRFhUcmFuc3BvcnRPcHRpb25zID0ge31cbik6IEFkYXB0ZXJUcmFuc3BvcnQgPT4ge1xuICBjb25zdCBhcGlLZXkgPSBvcHRpb25zLmFwaUtleSA/PyBlbnZTdHJpbmcoJ0hZUEVSRFhfQVBJX0tFWScpXG4gIGlmICghYXBpS2V5KSB7XG4gICAgdGhyb3cgdHJhbnNwb3J0RXJyb3IoXG4gICAgICAnSHlwZXJEWCcsXG4gICAgICAnbWlzc2luZyBBUEkga2V5LiBTZXQgSFlQRVJEWF9BUElfS0VZIG9yIHBhc3MgYXBpS2V5IHRvIGNyZWF0ZUh5cGVyRFhUcmFuc3BvcnQoKSdcbiAgICApXG4gIH1cblxuICBjb25zdCBlbmRwb2ludCA9IHN0cmlwVHJhaWxpbmdTbGFzaGVzKFxuICAgIG9wdGlvbnMuZW5kcG9pbnQgPz8gZW52U3RyaW5nKCdIWVBFUkRYX09UTFBfRU5EUE9JTlQnKSA/PyBERUZBVUxUX0VORFBPSU5UXG4gIClcblxuICByZXR1cm4gY3JlYXRlT3RscENvcmUoe1xuICAgIGhlYWRlcnM6IHsgYXV0aG9yaXphdGlvbjogYXBpS2V5IH0sXG4gICAgbmFtZTogJ0h5cGVyRFgnLFxuICAgIG9wdGlvbnMsXG4gICAgcmVzb3VyY2VBdHRyaWJ1dGVzOiBvcHRpb25zLnJlc291cmNlQXR0cmlidXRlcyA/PyB7fSxcbiAgICBzZXJ2aWNlTmFtZTpcbiAgICAgIG9wdGlvbnMuc2VydmljZU5hbWUgPz9cbiAgICAgIGVudlN0cmluZygnSFlQRVJEWF9TRVJWSUNFX05BTUUnKSA/P1xuICAgICAgZW52U3RyaW5nKCdPVEVMX1NFUlZJQ0VfTkFNRScpID8/XG4gICAgICAnbG9naXhseXNpYScsXG4gICAgdXJsOiBgJHtlbmRwb2ludH0vdjEvbG9nc2BcbiAgfSlcbn1cblxuZXhwb3J0IHR5cGUgeyBBZGFwdGVyVHJhbnNwb3J0IH0gZnJvbSAnLi9hZGFwdGVycy9zaGFyZWQnXG4iCiAgXSwKICAibWFwcGluZ3MiOiAia0pBUUEsVUFBTSxRQUFtQiw2QkFpQ1osRUFBeUIsQ0FDcEMsRUFBbUMsQ0FBQyxJQUNmLENBQ3JCLElBQU0sRUFBUyxFQUFRLFFBQVUsRUFBVSxpQkFBaUIsRUFDNUQsR0FBSSxDQUFDLEVBQ0gsTUFBTSxFQUNKLFVBQ0EsaUZBQ0YsRUFHRixJQUFNLEVBQVcsRUFDZixFQUFRLFVBQVksRUFBVSx1QkFBdUIsR0FBSyxDQUM1RCxFQUVBLE9BQU8sRUFBZSxDQUNwQixRQUFTLENBQUUsY0FBZSxDQUFPLEVBQ2pDLEtBQU0sVUFDTixVQUNBLG1CQUFvQixFQUFRLG9CQUFzQixDQUFDLEVBQ25ELFlBQ0UsRUFBUSxhQUNSLEVBQVUsc0JBQXNCLEdBQ2hDLEVBQVUsbUJBQW1CLEdBQzdCLGFBQ0YsSUFBSyxHQUFHLFdBQ1YsQ0FBQyIsCiAgImRlYnVnSWQiOiAiRjBDQzBBQjNBQzRGQjRFMjY0NzU2RTIxNjQ3NTZFMjEiLAogICJuYW1lcyI6IFtdCn0=