@nxgt/telemetry-otlp 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steve Tsala
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,228 @@
+# @nxgt/telemetry-otlp
+
+Logs and traces from [`@nxgt/telemetry`](https://www.npmjs.com/package/@nxgt/telemetry)
+to any OpenTelemetry collector, as OTLP/HTTP JSON — over `fetch`, with no
+OpenTelemetry SDK.
+
+```sh
+bun add @nxgt/telemetry @nxgt/telemetry-otlp
+```
+
+```ts
+import { createTelemetry } from '@nxgt/telemetry';
+import { otlpExporter } from '@nxgt/telemetry-otlp';
+
+createTelemetry('checkout', {
+  version: '1.4.0',
+  environment: 'production',
+  exporters: [otlpExporter({ endpoint: 'http://localhost:4318' })],
+}).install();
+```
+
+## What it is
+
+OTLP is a **wire format**, not a library. The whole of it a collector needs is
+two JSON documents over HTTP, and that is what this package writes — which is
+why it has one dependency, no transitive tree, and nothing that wants to own
+your context propagation.
+
+The alternative is the OpenTelemetry JavaScript SDK: an exporter, a processor, a
+provider, a context manager and a propagator, forty-odd packages between them,
+and a `Context` that has to be wired to `AsyncLocalStorage` anyway. This is the
+same bytes on the socket.
+
+Everything it sends is checked against a real HTTP server in the specs, not
+against a `fetch` double: a hand-written wire format has to be read over a wire
+at least once.
+
+## The collector
+
+```ts
+otlpExporter({
+  endpoint: 'http://localhost:4318',
+  headers: { 'x-api-key': key },
+})
+```
+
+`endpoint` is the base URL. `/v1/logs` and `/v1/traces` are appended, which is
+where every collector listens; `logsPath` and `tracesPath` move them for a
+gateway that mounts OTLP somewhere else.
+
+| option | default | |
+| --- | --- | --- |
+| `endpoint` | — | the collector's base URL |
+| `logsPath` | `/v1/logs` | appended to `endpoint` |
+| `tracesPath` | `/v1/traces` | appended to `endpoint` |
+| `headers` | — | sent on every request — an API key, a tenant |
+| `timeout` | `10s` | per attempt |
+| `attempts` | `3` | how many requests one document gets. `1` disables retrying |
+| `backoff` | `500ms` | the first wait between attempts, doubled each time |
+| `gzip` | `true` | compress a document over 1 KiB |
+| `onPartialSuccess` | — | called when the collector kept the request but not every record |
+| `fetch` | global | for a specs double, or an application that routes its own traffic |
+| `sleep` | `setTimeout` | how the backoff waits. For specs; the default does not hold the process open |
+
+## A mixed batch is two requests
+
+A batch of logs and spans becomes one `/v1/logs` POST and one `/v1/traces` POST,
+sent together. Logs failing must not cost the traces of the same batch, so both
+are attempted before either failure is thrown. A batch with nothing of one kind
+makes no request of that kind: an empty document is a request worth not making.
+
+## When it fails
+
+Every failure is thrown out of `export`, which means it reaches
+`onExportError` and nothing else. A collector being down is not a reason for a
+request to fail.
+
+| | when | retried |
+| --- | --- | --- |
+| `OtlpUnreachableError` | no answer at all — DNS, a refused connection, the timeout | yes, to the end of `attempts` |
+| `OtlpRefusedError` | `408`, `429`, `500`, `502`, `503`, `504` | yes, to the end of `attempts` |
+| `OtlpRejectedError` | any other status | **no** |
+
+A rejection is not retried because sending the same bytes again gets the same
+answer: the collector is saying the request is wrong, not that it is busy. All
+three carry `url`, `signal` (`'logs'` or `'traces'`) and `attempts`; the two
+that had an answer carry its `status` and the first 500 characters of its body.
+
+`url` is the **full request URL** — the endpoint plus the path — with its
+userinfo, query string and fragment removed. A vendor hands out a collector URL
+with the key in one of those often enough that a failure must not be the thing
+that writes it to a log, and a failure is exactly what `onExportError` logs.
+
+When both documents fail, for different reasons, both are reported: they go to
+two paths, and a `400` on one with a refused connection on the other is not one
+outage. Two failures arrive as an `AggregateError`; one arrives on its own.
+
+```ts
+createTelemetry('checkout', {
+  exporters: [otlpExporter({ endpoint })],
+  onExportError: (failure) => {
+    if (failure instanceof OtlpRejectedError) alert.page(failure);   // we are misconfigured
+    else metrics.increment('telemetry.export.failed');               // they are down
+  },
+});
+```
+
+## Partial success
+
+A collector that took the request but threw some records away answers `200`
+with a `partialSuccess`. That is **not** retried — it already accepted
+everything else, and sending the bytes again would duplicate them.
+
+```ts
+otlpExporter({
+  endpoint,
+  onPartialSuccess: ({ signal, rejected, message }) =>
+    console.warn(`collector dropped ${rejected} ${signal}: ${message}`),
+})
+```
+
+The hook is what decides whether the body is read at all: without one, the
+ordinary empty answer is never parsed.
+
+## The conversion
+
+| this library | OTLP |
+| --- | --- |
+| epoch milliseconds | `timeUnixNano`, as a **decimal string** |
+| `TraceId` / `SpanId` | lowercase hex, **not** base64 |
+| `debug` `info` `warn` `error` | `5` `9` `13` `17`, with the name as `severityText` |
+| `internal`…`consumer` | `1`…`5` |
+| `ok` / `error` / `cancelled` | `1` / `2` / **`0`** |
+| the log's `name` | the record `body` |
+| the logger's `source` | one `ScopeLogs` per source |
+| a span | one `ScopeSpans` named `nxgt-telemetry` |
+| `service`, `version`, `environment` | `service.name`, `service.version`, `deployment.environment.name` |
+| `ErrorInfo` | `exception.type`, `exception.message`, `exception.stacktrace`, on logs and spans alike |
+| a whole number | `intValue`, as a string |
+| a fractional number | `doubleValue` |
+| `null` | the unset value, `{}` |
+
+`cancelled` maps to **unset**, not error. A shutdown and a timeout are not
+failures, and OTLP has no third code, so the honest answer is to say nothing
+rather than to say "failed".
+
+The converter is exported — `logsRequest`, `tracesRequest`, `otlpResource`,
+`anyValue`, `keyValues`, `nanos` — so a transport this package does not have
+(gRPC, a queue, a file of OTLP documents) can be written without redoing it.
+
+## API
+
+### Exporting
+
+| | |
+| --- | --- |
+| `otlpExporter(options)` | an `Exporter` that POSTs OTLP/HTTP JSON |
+| `OtlpExporterOptions` | the options above |
+| `PartialSuccessReport` | `{ signal, rejected, message }` |
+| `RETRYABLE` | the statuses worth sending the same bytes again for |
+| `DEFAULT_LOGS_PATH`, `DEFAULT_TRACES_PATH` | `/v1/logs`, `/v1/traces` |
+| `DEFAULT_TIMEOUT`, `DEFAULT_ATTEMPTS`, `DEFAULT_BACKOFF` | `10_000`, `3`, `500` |
+| `COMPRESSION_FLOOR` | `1024` — below it, compressing costs more than it saves |
+| `Transport`, `post`, `encode`, `safeUrl`, `wait` | the transport, for a collector this package does not reach |
+
+### Failures
+
+| | |
+| --- | --- |
+| `OtlpError` | the shared base: `url`, `signal`, `attempts` |
+| `OtlpUnreachableError` | no answer; carries the `cause` `fetch` threw |
+| `OtlpRefusedError` | a retryable status that kept coming back; `status`, `body` |
+| `OtlpRejectedError` | a status that will not change; `status`, `body` |
+| `OtlpSignal` | `'logs' \| 'traces'` |
+| `BODY_LIMIT` | `500` — how much of an answer is kept |
+
+### Converting
+
+| | |
+| --- | --- |
+| `logsRequest(resource, batch)` | the `/v1/logs` document, or `undefined` |
+| `tracesRequest(resource, batch)` | the `/v1/traces` document, or `undefined` |
+| `otlpResource(resource)` | the resource, with the three conventional keys |
+| `anyValue(value)`, `keyValues(attributes)` | an attribute, tagged the way OTLP tags it |
+| `nanos(at)` | epoch milliseconds as decimal nanoseconds |
+| `SPAN_SCOPE`, `STATUS_CODE` | `'nxgt-telemetry'`, the status mapping |
+
+### The documents
+
+`AnyValue`, `KeyValue`, `OtlpResource`, `InstrumentationScope`,
+`OtlpLogRecord`, `ScopeLogs`, `ResourceLogs`, `ExportLogsServiceRequest`,
+`OtlpSpan`, `OtlpSpanEvent`, `OtlpStatus`, `ScopeSpans`, `ResourceSpans`,
+`ExportTraceServiceRequest`, `PartialSuccess` — types only, hand-written from
+the specification.
+
+## Traps
+
+- **A whole number past `Number.MAX_SAFE_INTEGER` crosses as a `doubleValue`,
+  not an `intValue`.** `Number.isInteger` is true well past the safe range, and
+  `String` switches to exponential notation at 1e21 — so `"1e+21"` where OTLP
+  asks for a decimal string, or the wrong last digits where it does not. Past
+  the safe range a double is all the precision the value had anyway. Put a real
+  64-bit identifier in a string attribute.
+- **`nanos` goes through `BigInt`, and has to.** `Date.now() * 1e6` passed
+  `Number.MAX_SAFE_INTEGER` in 2001, so the float path answers the same instant
+  for two signals a microsecond apart. That is also why the field is text on the
+  wire.
+- **Ids are hex, not base64.** Proto3 JSON would encode a `bytes` field as
+  base64; the OTLP specification overrides that for `trace_id`, `span_id` and
+  `parent_span_id`, and a collector that reads base64 there sees a different
+  trace.
+- **A retry is `.unref()`ed**, so a process that has nothing else to do exits
+  rather than waiting out a backoff. Telemetry must not be the reason a
+  container takes thirty seconds to stop; `close()`'s `drainTimeout` is the
+  other half of that.
+- **`Retry-After` is not read.** The backoff is the one this exporter was given,
+  doubled. A collector that asks for longer gets the same schedule.
+- **gzip needs `node:zlib`.** A bundle for the browser that shims the builtin
+  away still exports — uncompressed, which every collector accepts — rather
+  than failing to load.
+- **The batch is gone when `export` throws.** There is no disk queue behind
+  this. A collector that is down for longer than the retries costs those
+  batches; `fileExporter` beside this one is what an estate that cannot afford
+  that uses.
+
+## License
+
+MIT

package/dist/export/errors.d.ts

@@ -0,0 +1,61 @@
+/** Which document failed. A mixed batch is two requests, and either can fail. */
+export type OtlpSignal = 'logs' | 'traces';
+/** How much of a collector's answer is kept. Enough to read; not a log flood. */
+export declare const BODY_LIMIT = 500;
+/**
+ * The shared shape. All three are thrown out of `export`, which means they
+ * reach `onExportError` and nothing else: a collector being down is not a
+ * reason for a request to fail.
+ *
+ * They are plain classes with a `name` rather than a discriminated union
+ * because that is what a `catch` reads, and `instanceof` across two copies of
+ * this package would answer false.
+ */
+export declare abstract class OtlpError extends Error {
+    /**
+     * The request URL — the endpoint and the path — **with any credentials
+     * removed**. A vendor's collector URL carries its key in the userinfo or
+     * the query string often enough that a failure must not be the thing that
+     * writes it to a log.
+     */
+    readonly url: string;
+    readonly signal: OtlpSignal;
+    /** How many requests were made, including the one that failed. */
+    readonly attempts: number;
+    constructor(message: string, url: string, signal: OtlpSignal, attempts: number);
+}
+/**
+ * The collector never answered: DNS, a refused connection, a timeout. Retried
+ * to the end of `attempts` before this is thrown.
+ */
+export declare class OtlpUnreachableError extends OtlpError {
+    readonly name = "OtlpUnreachableError";
+    /** What `fetch` threw on the last attempt. */
+    readonly cause: unknown;
+    constructor(url: string, signal: OtlpSignal, attempts: number, cause: unknown);
+}
+/**
+ * The collector answered, and kept answering, with a status worth retrying —
+ * `408`, `429`, or a `5xx` it declares. The queue it was busy with is still
+ * busy.
+ */
+export declare class OtlpRefusedError extends OtlpError {
+    readonly name = "OtlpRefusedError";
+    readonly status: number;
+    /** The first `BODY_LIMIT` characters of the last answer. */
+    readonly body: string;
+    constructor(url: string, signal: OtlpSignal, attempts: number, status: number, body: string);
+}
+/**
+ * The collector rejected the request outright — a bad path, a missing header, a
+ * document it will not accept. **Not retried**: sending the same bytes again
+ * gets the same answer, and the batch is lost either way.
+ */
+export declare class OtlpRejectedError extends OtlpError {
+    readonly name = "OtlpRejectedError";
+    readonly status: number;
+    /** The first `BODY_LIMIT` characters of the answer. */
+    readonly body: string;
+    constructor(url: string, signal: OtlpSignal, attempts: number, status: number, body: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/export/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/export/errors.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE3C,iFAAiF;AACjF,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B;;;;;;;;GAQG;AACH,8BAAsB,SAAU,SAAQ,KAAK;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAGzB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM;CAOjB;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAClD,SAAkB,IAAI,0BAA0B;IAChD,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;gBAGvB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO;CAUf;AAED;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;IAC9C,SAAkB,IAAI,sBAAsB;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAGrB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM;CAWb;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC/C,SAAkB,IAAI,uBAAuB;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAGrB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM;CAWb"}

package/dist/export/otlp.d.ts

@@ -0,0 +1,48 @@
+import type { Exporter } from '@nxgt/telemetry';
+import { type PartialSuccessReport } from './transport';
+export declare const DEFAULT_LOGS_PATH = "/v1/logs";
+export declare const DEFAULT_TRACES_PATH = "/v1/traces";
+export interface OtlpExporterOptions {
+    /** The collector's base URL, e.g. `http://localhost:4318`. */
+    readonly endpoint: string;
+    /** Appended to `endpoint`. Default `/v1/logs`. */
+    readonly logsPath?: string;
+    /** Appended to `endpoint`. Default `/v1/traces`. */
+    readonly tracesPath?: string;
+    /** Sent on every request — an API key, a tenant. */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Per attempt, in milliseconds. Default 10s. */
+    readonly timeout?: number;
+    /** How many requests one document gets. Default 3. `1` disables retrying. */
+    readonly attempts?: number;
+    /** The first wait between attempts, doubled each time. Default 500ms. */
+    readonly backoff?: number;
+    /** Gzip a document over 1 KiB. Default true. */
+    readonly gzip?: boolean;
+    /** Called when the collector accepted the request but not every record. */
+    readonly onPartialSuccess?: (report: PartialSuccessReport) => void;
+    /** For specs, and for an application that routes its own traffic. */
+    readonly fetch?: typeof fetch;
+    /** For specs. Default a `setTimeout` that does not hold the process open. */
+    readonly sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * Logs and traces to an OpenTelemetry collector, as OTLP/HTTP JSON.
+ *
+ * ```ts
+ * otlpExporter({ endpoint: 'http://localhost:4318', headers: { 'x-api-key': key } })
+ * ```
+ *
+ * There is no OpenTelemetry SDK behind this. OTLP is a wire format, and the
+ * whole of it that a collector needs is two JSON documents over `fetch` — which
+ * is what lets this package have one dependency and no transitive tree, and
+ * what keeps the context in `AsyncLocalStorage` instead of in the Java SDK's
+ * thread-local shape.
+ *
+ * A mixed batch is **two requests**, one per document, sent together: logs
+ * failing must not cost the traces of the same batch. Both are attempted, and
+ * both failures are thrown — as an `AggregateError` when there are two —
+ * which means they reach `onExportError` and nothing else.
+ */
+export declare function otlpExporter(options: OtlpExporterOptions): Exporter;
+//# sourceMappingURL=otlp.d.ts.map

package/dist/export/otlp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp.d.ts","sourceRoot":"","sources":["../../src/export/otlp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,iBAAiB,CAAC;AAElE,OAAO,EAIN,KAAK,oBAAoB,EAIzB,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,iBAAiB,aAAa,CAAC;AAC5C,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAEhD,MAAM,WAAW,mBAAmB;IACnC,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,iDAAiD;IACjD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,gDAAgD;IAChD,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACnE,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IAC9B,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,QAAQ,CAiCnE"}

package/dist/export/transport.d.ts

@@ -0,0 +1,56 @@
+import * as zlib from 'node:zlib';
+import { type OtlpSignal } from './errors';
+export declare const DEFAULT_TIMEOUT = 10000;
+export declare const DEFAULT_ATTEMPTS = 3;
+export declare const DEFAULT_BACKOFF = 500;
+/** Below this, compressing costs more than the bytes it saves. */
+export declare const COMPRESSION_FLOOR = 1024;
+/**
+ * The statuses worth sending the same bytes again for. Everything else is the
+ * collector saying the request is wrong, and a retry would only repeat it.
+ */
+export declare const RETRYABLE: ReadonlySet<number>;
+/** What a collector accepted with reservations. */
+export interface PartialSuccessReport {
+    readonly signal: OtlpSignal;
+    /** How many records the collector threw away. */
+    readonly rejected: number;
+    readonly message: string;
+}
+/** Everything `post` needs, resolved once when the exporter is built. */
+export interface Transport {
+    readonly headers: Readonly<Record<string, string>>;
+    readonly timeout: number;
+    readonly attempts: number;
+    readonly backoff: number;
+    readonly gzip: boolean;
+    readonly onPartialSuccess?: (report: PartialSuccessReport) => void;
+    readonly fetch: typeof fetch;
+    readonly sleep: (ms: number) => Promise<void>;
+}
+/**
+ * One document to one URL, retried to the end of `attempts`.
+ *
+ * The body is encoded **once**, before the loop: a retry sends the same bytes,
+ * and gzipping them again each time would be work for nothing.
+ */
+export declare function post(transport: Transport, url: string, signal: OtlpSignal, document: unknown): Promise<void>;
+/**
+ * The URL as it may be repeated in an error message and read by whatever
+ * `onExportError` logs to — **without its credentials**. A collector URL of the
+ * shape `https://user:token@otlp.vendor.example/v1/logs` and one with the key
+ * in the query string are both things vendors hand out, and a failure is not a
+ * reason to put either in a log line.
+ */
+export declare function safeUrl(url: string): string;
+/**
+ * Gzip when it is worth it, and only where `node:zlib` exists. A bundle for the
+ * browser that shims the builtin away still exports — uncompressed, which every
+ * collector accepts — rather than failing to load.
+ */
+export declare function encode(json: string, compress: boolean, gzip?: typeof zlib.gzip | null): Promise<{
+    bytes: Uint8Array<ArrayBuffer>;
+    encoded: boolean;
+}>;
+export declare function wait(ms: number): Promise<void>;
+//# sourceMappingURL=transport.d.ts.map

package/dist/export/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/export/transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,EAIN,KAAK,UAAU,EAEf,MAAM,UAAU,CAAC;AAElB,eAAO,MAAM,eAAe,QAAS,CAAC;AACtC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,kEAAkE;AAClE,eAAO,MAAM,iBAAiB,OAAQ,CAAC;AAMvC;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,WAAW,CAAC,MAAM,CAExC,CAAC;AAEH,mDAAmD;AACnD,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,iDAAiD;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAED,yEAAyE;AACzE,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACnE,QAAQ,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C;AAED;;;;;GAKG;AACH,wBAAsB,IAAI,CACzB,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,OAAO,GACf,OAAO,CAAC,IAAI,CAAC,CAgDf;AAwED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAY3C;AAED;;;;GAIG;AACH,wBAAsB,MAAM,CAC3B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,EAIjB,IAAI,GAAE,OAAO,IAAI,CAAC,IAAI,GAAG,IAAqB,GAC5C,OAAO,CAAC;IAAE,KAAK,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAoB/D;AAED,wBAAgB,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM9C"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './export/errors';
+export * from './export/otlp';
+export * from './export/transport';
+export * from './wire/convert';
+export type * from './wire/documents';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,mBAAmB,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,347 @@
+// src/export/errors.ts
+var BODY_LIMIT = 500;
+
+class OtlpError extends Error {
+  constructor(message, url, signal, attempts) {
+    super(message);
+    this.url = url;
+    this.signal = signal;
+    this.attempts = attempts;
+  }
+}
+
+class OtlpUnreachableError extends OtlpError {
+  constructor(url, signal, attempts, cause) {
+    super(`[telemetry] ${url} did not answer for ${signal} after ${attempts} attempt(s)`, url, signal, attempts);
+    this.name = "OtlpUnreachableError";
+    this.cause = cause;
+  }
+}
+
+class OtlpRefusedError extends OtlpError {
+  constructor(url, signal, attempts, status, body) {
+    super(`[telemetry] ${url} refused ${signal} with ${status} after ${attempts} attempt(s): ${body}`, url, signal, attempts);
+    this.name = "OtlpRefusedError";
+    this.status = status;
+    this.body = body;
+  }
+}
+
+class OtlpRejectedError extends OtlpError {
+  constructor(url, signal, attempts, status, body) {
+    super(`[telemetry] ${url} rejected ${signal} with ${status}: ${body}`, url, signal, attempts);
+    this.name = "OtlpRejectedError";
+    this.status = status;
+    this.body = body;
+  }
+}
+// src/wire/convert.ts
+import { SEVERITY_NUMBER, SPAN_KIND_NUMBER } from "@nxgt/telemetry";
+var SPAN_SCOPE = "nxgt-telemetry";
+var STATUS_CODE = Object.freeze({
+  ok: 1,
+  error: 2,
+  cancelled: 0
+});
+function nanos(at) {
+  return (BigInt(Math.round(at)) * 1000000n).toString();
+}
+function anyValue(value) {
+  if (value === null)
+    return {};
+  if (typeof value === "string")
+    return { stringValue: value };
+  if (typeof value === "boolean")
+    return { boolValue: value };
+  if (typeof value === "number") {
+    return Number.isSafeInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+  }
+  return { arrayValue: { values: value.map(anyValue) } };
+}
+function keyValues(attributes) {
+  return Object.keys(attributes).map((key) => ({
+    key,
+    value: anyValue(attributes[key])
+  }));
+}
+function otlpResource(resource) {
+  const declared = {
+    "service.name": resource.service
+  };
+  if (resource.version !== undefined) {
+    declared["service.version"] = resource.version;
+  }
+  if (resource.environment !== undefined) {
+    declared["deployment.environment.name"] = resource.environment;
+  }
+  return { attributes: keyValues({ ...declared, ...resource.attributes }) };
+}
+function logsRequest(resource, batch) {
+  const bySource = new Map;
+  for (const signal of batch) {
+    if (signal.type !== "log")
+      continue;
+    const found = bySource.get(signal.source) ?? [];
+    found.push(otlpLog(signal));
+    bySource.set(signal.source, found);
+  }
+  if (bySource.size === 0)
+    return;
+  const scopeLogs = [...bySource].map(([name, logRecords]) => ({
+    scope: { name },
+    logRecords
+  }));
+  return { resourceLogs: [{ resource: otlpResource(resource), scopeLogs }] };
+}
+function tracesRequest(resource, batch) {
+  const spans = batch.filter((signal) => signal.type === "span").map(otlpSpan);
+  if (spans.length === 0)
+    return;
+  return {
+    resourceSpans: [
+      {
+        resource: otlpResource(resource),
+        scopeSpans: [{ scope: { name: SPAN_SCOPE }, spans }]
+      }
+    ]
+  };
+}
+function otlpLog(log) {
+  const at = nanos(log.at);
+  return {
+    timeUnixNano: at,
+    observedTimeUnixNano: at,
+    severityNumber: SEVERITY_NUMBER[log.severity],
+    severityText: log.severity.toUpperCase(),
+    body: { stringValue: log.name },
+    attributes: keyValues({ ...log.attributes, ...exception(log.error) }),
+    ...log.span === undefined ? {} : {
+      traceId: log.span.traceId,
+      spanId: log.span.spanId,
+      flags: log.span.sampled ? 1 : 0
+    }
+  };
+}
+function otlpSpan(span) {
+  return {
+    traceId: span.context.traceId,
+    spanId: span.context.spanId,
+    ...span.parent === undefined ? {} : { parentSpanId: span.parent },
+    name: span.name,
+    kind: SPAN_KIND_NUMBER[span.kind],
+    startTimeUnixNano: nanos(span.startedAt),
+    endTimeUnixNano: nanos(span.endedAt),
+    attributes: keyValues({ ...span.attributes, ...exception(span.error) }),
+    events: span.events.map((happened) => ({
+      timeUnixNano: nanos(happened.at),
+      name: happened.name,
+      attributes: keyValues(happened.attributes)
+    })),
+    status: {
+      code: STATUS_CODE[span.status],
+      ...span.error?.message === undefined ? {} : { message: span.error.message }
+    }
+  };
+}
+function exception(error) {
+  if (error === undefined)
+    return {};
+  return {
+    "exception.type": error.type,
+    ...error.message === undefined ? {} : { "exception.message": error.message },
+    ...error.stackTrace === undefined ? {} : { "exception.stacktrace": error.stackTrace }
+  };
+}
+
+// src/export/transport.ts
+import * as zlib from "node:zlib";
+var DEFAULT_TIMEOUT = 1e4;
+var DEFAULT_ATTEMPTS = 3;
+var DEFAULT_BACKOFF = 500;
+var COMPRESSION_FLOOR = 1024;
+var AVAILABLE_GZIP = zlib.gzip ?? null;
+var RETRYABLE = new Set([
+  408,
+  429,
+  500,
+  502,
+  503,
+  504
+]);
+async function post(transport, url, signal, document) {
+  const body = await encode(JSON.stringify(document), transport.gzip);
+  const named = safeUrl(url);
+  let failure;
+  let waited = transport.backoff;
+  for (let attempt = 1;attempt <= transport.attempts; attempt++) {
+    if (attempt > 1) {
+      await transport.sleep(waited);
+      waited *= 2;
+    }
+    let reply;
+    try {
+      reply = await transport.fetch(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...body.encoded ? { "content-encoding": "gzip" } : {},
+          ...transport.headers
+        },
+        body: body.bytes,
+        signal: AbortSignal.timeout(transport.timeout)
+      });
+    } catch (thrown) {
+      failure = thrown;
+      continue;
+    }
+    if (reply.ok) {
+      await accepted(transport, signal, reply);
+      return;
+    }
+    const text = truncate(await bodyOf(reply));
+    if (!RETRYABLE.has(reply.status)) {
+      throw new OtlpRejectedError(named, signal, attempt, reply.status, text);
+    }
+    failure = new OtlpRefusedError(named, signal, attempt, reply.status, text);
+  }
+  if (failure instanceof OtlpRefusedError)
+    throw failure;
+  throw new OtlpUnreachableError(named, signal, transport.attempts, failure);
+}
+async function accepted(transport, signal, reply) {
+  if (transport.onPartialSuccess === undefined) {
+    await reply.body?.cancel().catch(() => {
+      return;
+    });
+    return;
+  }
+  report(signal, await partialSuccess(reply), transport.onPartialSuccess);
+}
+function report(signal, found, onPartialSuccess) {
+  if (found === undefined)
+    return;
+  const rejected = Number(found.rejectedLogRecords ?? found.rejectedSpans ?? 0);
+  const message = found.errorMessage ?? "";
+  if (rejected === 0 && message === "")
+    return;
+  try {
+    onPartialSuccess({ signal, rejected, message });
+  } catch {}
+}
+async function partialSuccess(reply) {
+  try {
+    const answered = await reply.json();
+    return answered?.partialSuccess;
+  } catch {
+    return;
+  }
+}
+async function bodyOf(reply) {
+  try {
+    return await reply.text();
+  } catch {
+    return "";
+  }
+}
+function truncate(text) {
+  return text.length <= BODY_LIMIT ? text : `${text.slice(0, BODY_LIMIT)}…`;
+}
+function safeUrl(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+async function encode(json, compress, gzip = AVAILABLE_GZIP) {
+  const bytes = new TextEncoder().encode(json);
+  if (!compress || bytes.byteLength < COMPRESSION_FLOOR) {
+    return { bytes, encoded: false };
+  }
+  if (typeof gzip !== "function")
+    return { bytes, encoded: false };
+  return new Promise((resolve) => {
+    gzip(bytes, (failure, result) => {
+      resolve(failure ? { bytes, encoded: false } : { bytes: result, encoded: true });
+    });
+  });
+}
+function wait(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+
+// src/export/otlp.ts
+var DEFAULT_LOGS_PATH = "/v1/logs";
+var DEFAULT_TRACES_PATH = "/v1/traces";
+function otlpExporter(options) {
+  const endpoint = options.endpoint.replace(/\/+$/, "");
+  const logsUrl = endpoint + (options.logsPath ?? DEFAULT_LOGS_PATH);
+  const tracesUrl = endpoint + (options.tracesPath ?? DEFAULT_TRACES_PATH);
+  const transport = {
+    headers: options.headers ?? {},
+    timeout: options.timeout ?? DEFAULT_TIMEOUT,
+    attempts: Math.max(options.attempts ?? DEFAULT_ATTEMPTS, 1),
+    backoff: options.backoff ?? DEFAULT_BACKOFF,
+    gzip: options.gzip ?? true,
+    ...options.onPartialSuccess === undefined ? {} : { onPartialSuccess: options.onPartialSuccess },
+    fetch: options.fetch ?? fetch,
+    sleep: options.sleep ?? wait
+  };
+  return {
+    async export(resource, batch) {
+      const logs = logsRequest(resource, batch);
+      const traces = tracesRequest(resource, batch);
+      const sent = await Promise.allSettled([
+        logs === undefined ? undefined : post(transport, logsUrl, "logs", logs),
+        traces === undefined ? undefined : post(transport, tracesUrl, "traces", traces)
+      ]);
+      throwAll(sent);
+    }
+  };
+}
+function throwAll(sent) {
+  const failures = sent.filter((one) => one.status === "rejected").map((one) => one.reason);
+  if (failures.length === 0)
+    return;
+  if (failures.length === 1)
+    throw failures[0];
+  throw new AggregateError(failures, "[telemetry] neither the logs nor the traces of this batch arrived");
+}
+export {
+  BODY_LIMIT,
+  COMPRESSION_FLOOR,
+  DEFAULT_ATTEMPTS,
+  DEFAULT_BACKOFF,
+  DEFAULT_LOGS_PATH,
+  DEFAULT_TIMEOUT,
+  DEFAULT_TRACES_PATH,
+  OtlpError,
+  OtlpRefusedError,
+  OtlpRejectedError,
+  OtlpUnreachableError,
+  RETRYABLE,
+  SPAN_SCOPE,
+  STATUS_CODE,
+  anyValue,
+  encode,
+  keyValues,
+  logsRequest,
+  nanos,
+  otlpExporter,
+  otlpResource,
+  post,
+  safeUrl,
+  tracesRequest,
+  wait
+};
+
+//# debugId=4685C21DF9219CEA64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/export/errors.ts", "../src/wire/convert.ts", "../src/export/transport.ts", "../src/export/otlp.ts"],
+  "sourcesContent": [
+    "/** Which document failed. A mixed batch is two requests, and either can fail. */\nexport type OtlpSignal = 'logs' | 'traces';\n\n/** How much of a collector's answer is kept. Enough to read; not a log flood. */\nexport const BODY_LIMIT = 500;\n\n/**\n * The shared shape. All three are thrown out of `export`, which means they\n * reach `onExportError` and nothing else: a collector being down is not a\n * reason for a request to fail.\n *\n * They are plain classes with a `name` rather than a discriminated union\n * because that is what a `catch` reads, and `instanceof` across two copies of\n * this package would answer false.\n */\nexport abstract class OtlpError extends Error {\n\t/**\n\t * The request URL — the endpoint and the path — **with any credentials\n\t * removed**. A vendor's collector URL carries its key in the userinfo or\n\t * the query string often enough that a failure must not be the thing that\n\t * writes it to a log.\n\t */\n\treadonly url: string;\n\treadonly signal: OtlpSignal;\n\t/** How many requests were made, including the one that failed. */\n\treadonly attempts: number;\n\n\tconstructor(\n\t\tmessage: string,\n\t\turl: string,\n\t\tsignal: OtlpSignal,\n\t\tattempts: number,\n\t) {\n\t\tsuper(message);\n\t\tthis.url = url;\n\t\tthis.signal = signal;\n\t\tthis.attempts = attempts;\n\t}\n}\n\n/**\n * The collector never answered: DNS, a refused connection, a timeout. Retried\n * to the end of `attempts` before this is thrown.\n */\nexport class OtlpUnreachableError extends OtlpError {\n\toverride readonly name = 'OtlpUnreachableError';\n\t/** What `fetch` threw on the last attempt. */\n\treadonly cause: unknown;\n\n\tconstructor(\n\t\turl: string,\n\t\tsignal: OtlpSignal,\n\t\tattempts: number,\n\t\tcause: unknown,\n\t) {\n\t\tsuper(\n\t\t\t`[telemetry] ${url} did not answer for ${signal} after ${attempts} attempt(s)`,\n\t\t\turl,\n\t\t\tsignal,\n\t\t\tattempts,\n\t\t);\n\t\tthis.cause = cause;\n\t}\n}\n\n/**\n * The collector answered, and kept answering, with a status worth retrying —\n * `408`, `429`, or a `5xx` it declares. The queue it was busy with is still\n * busy.\n */\nexport class OtlpRefusedError extends OtlpError {\n\toverride readonly name = 'OtlpRefusedError';\n\treadonly status: number;\n\t/** The first `BODY_LIMIT` characters of the last answer. */\n\treadonly body: string;\n\n\tconstructor(\n\t\turl: string,\n\t\tsignal: OtlpSignal,\n\t\tattempts: number,\n\t\tstatus: number,\n\t\tbody: string,\n\t) {\n\t\tsuper(\n\t\t\t`[telemetry] ${url} refused ${signal} with ${status} after ${attempts} attempt(s): ${body}`,\n\t\t\turl,\n\t\t\tsignal,\n\t\t\tattempts,\n\t\t);\n\t\tthis.status = status;\n\t\tthis.body = body;\n\t}\n}\n\n/**\n * The collector rejected the request outright — a bad path, a missing header, a\n * document it will not accept. **Not retried**: sending the same bytes again\n * gets the same answer, and the batch is lost either way.\n */\nexport class OtlpRejectedError extends OtlpError {\n\toverride readonly name = 'OtlpRejectedError';\n\treadonly status: number;\n\t/** The first `BODY_LIMIT` characters of the answer. */\n\treadonly body: string;\n\n\tconstructor(\n\t\turl: string,\n\t\tsignal: OtlpSignal,\n\t\tattempts: number,\n\t\tstatus: number,\n\t\tbody: string,\n\t) {\n\t\tsuper(\n\t\t\t`[telemetry] ${url} rejected ${signal} with ${status}: ${body}`,\n\t\t\turl,\n\t\t\tsignal,\n\t\t\tattempts,\n\t\t);\n\t\tthis.status = status;\n\t\tthis.body = body;\n\t}\n}\n",
+    "import type {\n\tAttributes,\n\tAttributeValue,\n\tErrorInfo,\n\tLogRecord,\n\tResource,\n\tSignal,\n\tSpanRecord,\n\tSpanStatus,\n} from '@nxgt/telemetry';\nimport { SEVERITY_NUMBER, SPAN_KIND_NUMBER } from '@nxgt/telemetry';\nimport type {\n\tAnyValue,\n\tExportLogsServiceRequest,\n\tExportTraceServiceRequest,\n\tKeyValue,\n\tOtlpLogRecord,\n\tOtlpResource,\n\tOtlpSpan,\n\tOtlpSpanEvent,\n\tScopeLogs,\n} from './documents';\n\n/** The instrumentation scope reported for spans. Logs report their `source`. */\nexport const SPAN_SCOPE = 'nxgt-telemetry';\n\n/**\n * `ok` maps to `1` and `error` to `2`, and **`cancelled` maps to `0`** — unset,\n * not error. A shutdown and a timeout are not failures, and a dashboard that\n * counts them as such is a dashboard nobody trusts; OTLP has no third code, so\n * the honest answer is to say nothing rather than to say \"failed\".\n */\nexport const STATUS_CODE: Readonly<Record<SpanStatus, number>> = Object.freeze({\n\tok: 1,\n\terror: 2,\n\tcancelled: 0,\n});\n\n/**\n * Epoch milliseconds to the decimal nanoseconds OTLP wants, through `BigInt`.\n *\n * A `number` would be wrong from 2001 onwards: `Date.now() * 1e6` is well past\n * `Number.MAX_SAFE_INTEGER`, so the last digits are whatever the float rounds\n * to, and two signals a microsecond apart arrive with the same timestamp.\n */\nexport function nanos(at: number): string {\n\treturn (BigInt(Math.round(at)) * 1_000_000n).toString();\n}\n\n/** A scalar, tagged the way OTLP tags it. */\nexport function anyValue(value: AttributeValue): AnyValue {\n\tif (value === null) return {};\n\tif (typeof value === 'string') return { stringValue: value };\n\tif (typeof value === 'boolean') return { boolValue: value };\n\n\tif (typeof value === 'number') {\n\t\t// A whole number is an integer to every backend that groups by it, and\n\t\t// it crosses as text so that the low bits survive.\n\t\t//\n\t\t// **Safe**, not merely whole: `Number.isInteger` is true well past the\n\t\t// safe range, and `String` switches to exponential notation at 1e21.\n\t\t// `1e21` would be sent as `\"1e+21\"`, which is not the decimal string\n\t\t// OTLP asks for; `1e20` is decimal but past `int64`; and `2 ** 60`\n\t\t// would arrive with the wrong last three digits. A collector rejects\n\t\t// the first two with a `400`, which is not retried — so one attribute\n\t\t// would lose the whole document. Past the safe range the honest answer\n\t\t// is a double, which is all the precision the value had anyway.\n\t\treturn Number.isSafeInteger(value)\n\t\t\t? { intValue: String(value) }\n\t\t\t: { doubleValue: value };\n\t}\n\n\treturn { arrayValue: { values: value.map(anyValue) } };\n}\n\nexport function keyValues(attributes: Attributes): KeyValue[] {\n\treturn Object.keys(attributes).map((key) => ({\n\t\tkey,\n\t\tvalue: anyValue(attributes[key] as AttributeValue),\n\t}));\n}\n\n/**\n * The resource, with `service.name`, `service.version` and\n * `deployment.environment.name` — the three keys every backend looks for, under\n * the names the semantic conventions give them. An attribute already carrying\n * one of those keys wins: it was set deliberately.\n */\nexport function otlpResource(resource: Resource): OtlpResource {\n\tconst declared: Record<string, AttributeValue> = {\n\t\t'service.name': resource.service,\n\t};\n\tif (resource.version !== undefined) {\n\t\tdeclared['service.version'] = resource.version;\n\t}\n\tif (resource.environment !== undefined) {\n\t\tdeclared['deployment.environment.name'] = resource.environment;\n\t}\n\n\treturn { attributes: keyValues({ ...declared, ...resource.attributes }) };\n}\n\n/**\n * The logs of a batch, **grouped by `source`** into one scope each: the logger's\n * name is the instrumentation scope, which is what lets a backend filter by the\n * component that wrote the line rather than by the service that ran it.\n *\n * `undefined` when there is nothing to send — an empty document is a request\n * worth not making.\n */\nexport function logsRequest(\n\tresource: Resource,\n\tbatch: readonly Signal[],\n): ExportLogsServiceRequest | undefined {\n\tconst bySource = new Map<string, OtlpLogRecord[]>();\n\n\tfor (const signal of batch) {\n\t\tif (signal.type !== 'log') continue;\n\t\tconst found = bySource.get(signal.source) ?? [];\n\t\tfound.push(otlpLog(signal));\n\t\tbySource.set(signal.source, found);\n\t}\n\n\tif (bySource.size === 0) return undefined;\n\n\tconst scopeLogs: ScopeLogs[] = [...bySource].map(([name, logRecords]) => ({\n\t\tscope: { name },\n\t\tlogRecords,\n\t}));\n\n\treturn { resourceLogs: [{ resource: otlpResource(resource), scopeLogs }] };\n}\n\n/**\n * The spans of a batch, in one scope named for this library. A span has no\n * `source` — it is named for the work, not for the component — so there is\n * nothing to group by.\n */\nexport function tracesRequest(\n\tresource: Resource,\n\tbatch: readonly Signal[],\n): ExportTraceServiceRequest | undefined {\n\tconst spans = batch\n\t\t.filter((signal): signal is SpanRecord => signal.type === 'span')\n\t\t.map(otlpSpan);\n\n\tif (spans.length === 0) return undefined;\n\n\treturn {\n\t\tresourceSpans: [\n\t\t\t{\n\t\t\t\tresource: otlpResource(resource),\n\t\t\t\tscopeSpans: [{ scope: { name: SPAN_SCOPE }, spans }],\n\t\t\t},\n\t\t],\n\t};\n}\n\nfunction otlpLog(log: LogRecord): OtlpLogRecord {\n\tconst at = nanos(log.at);\n\n\treturn {\n\t\ttimeUnixNano: at,\n\t\t// The same instant: this library records when the line was written, and\n\t\t// has nothing else to observe it at.\n\t\tobservedTimeUnixNano: at,\n\t\tseverityNumber: SEVERITY_NUMBER[log.severity],\n\t\tseverityText: log.severity.toUpperCase(),\n\t\t// The body is the event's name, or the message when there is no type\n\t\t// for it yet. Everything structured is an attribute.\n\t\tbody: { stringValue: log.name },\n\t\tattributes: keyValues({ ...log.attributes, ...exception(log.error) }),\n\t\t...(log.span === undefined\n\t\t\t? {}\n\t\t\t: {\n\t\t\t\t\ttraceId: log.span.traceId,\n\t\t\t\t\tspanId: log.span.spanId,\n\t\t\t\t\tflags: log.span.sampled ? 1 : 0,\n\t\t\t\t}),\n\t};\n}\n\nfunction otlpSpan(span: SpanRecord): OtlpSpan {\n\treturn {\n\t\ttraceId: span.context.traceId,\n\t\tspanId: span.context.spanId,\n\t\t...(span.parent === undefined ? {} : { parentSpanId: span.parent }),\n\t\tname: span.name,\n\t\tkind: SPAN_KIND_NUMBER[span.kind],\n\t\tstartTimeUnixNano: nanos(span.startedAt),\n\t\tendTimeUnixNano: nanos(span.endedAt),\n\t\tattributes: keyValues({ ...span.attributes, ...exception(span.error) }),\n\t\tevents: span.events.map(\n\t\t\t(happened): OtlpSpanEvent => ({\n\t\t\t\ttimeUnixNano: nanos(happened.at),\n\t\t\t\tname: happened.name,\n\t\t\t\tattributes: keyValues(happened.attributes),\n\t\t\t}),\n\t\t),\n\t\tstatus: {\n\t\t\tcode: STATUS_CODE[span.status],\n\t\t\t...(span.error?.message === undefined\n\t\t\t\t? {}\n\t\t\t\t: { message: span.error.message }),\n\t\t},\n\t};\n}\n\n/**\n * A failure travels as attributes, under the semantic convention's keys, on a\n * log and on a span alike. There is no dedicated field for it in either\n * document.\n */\nfunction exception(error: ErrorInfo | undefined): Attributes {\n\tif (error === undefined) return {};\n\n\treturn {\n\t\t'exception.type': error.type,\n\t\t...(error.message === undefined\n\t\t\t? {}\n\t\t\t: { 'exception.message': error.message }),\n\t\t...(error.stackTrace === undefined\n\t\t\t? {}\n\t\t\t: { 'exception.stacktrace': error.stackTrace }),\n\t};\n}\n",
+    "import * as zlib from 'node:zlib';\nimport type { PartialSuccess } from '../wire/documents';\nimport {\n\tBODY_LIMIT,\n\tOtlpRefusedError,\n\tOtlpRejectedError,\n\ttype OtlpSignal,\n\tOtlpUnreachableError,\n} from './errors';\n\nexport const DEFAULT_TIMEOUT = 10_000;\nexport const DEFAULT_ATTEMPTS = 3;\nexport const DEFAULT_BACKOFF = 500;\n/** Below this, compressing costs more than the bytes it saves. */\nexport const COMPRESSION_FLOOR = 1_024;\n\n/** `null` where `node:zlib` was shimmed away — a browser bundle, usually. */\nconst AVAILABLE_GZIP: typeof zlib.gzip | null =\n\t(zlib as Partial<typeof zlib>).gzip ?? null;\n\n/**\n * The statuses worth sending the same bytes again for. Everything else is the\n * collector saying the request is wrong, and a retry would only repeat it.\n */\nexport const RETRYABLE: ReadonlySet<number> = new Set([\n\t408, 429, 500, 502, 503, 504,\n]);\n\n/** What a collector accepted with reservations. */\nexport interface PartialSuccessReport {\n\treadonly signal: OtlpSignal;\n\t/** How many records the collector threw away. */\n\treadonly rejected: number;\n\treadonly message: string;\n}\n\n/** Everything `post` needs, resolved once when the exporter is built. */\nexport interface Transport {\n\treadonly headers: Readonly<Record<string, string>>;\n\treadonly timeout: number;\n\treadonly attempts: number;\n\treadonly backoff: number;\n\treadonly gzip: boolean;\n\treadonly onPartialSuccess?: (report: PartialSuccessReport) => void;\n\treadonly fetch: typeof fetch;\n\treadonly sleep: (ms: number) => Promise<void>;\n}\n\n/**\n * One document to one URL, retried to the end of `attempts`.\n *\n * The body is encoded **once**, before the loop: a retry sends the same bytes,\n * and gzipping them again each time would be work for nothing.\n */\nexport async function post(\n\ttransport: Transport,\n\turl: string,\n\tsignal: OtlpSignal,\n\tdocument: unknown,\n): Promise<void> {\n\tconst body = await encode(JSON.stringify(document), transport.gzip);\n\tconst named = safeUrl(url);\n\n\tlet failure: unknown;\n\tlet waited = transport.backoff;\n\n\tfor (let attempt = 1; attempt <= transport.attempts; attempt++) {\n\t\tif (attempt > 1) {\n\t\t\tawait transport.sleep(waited);\n\t\t\twaited *= 2;\n\t\t}\n\n\t\tlet reply: Response;\n\t\ttry {\n\t\t\treply = await transport.fetch(url, {\n\t\t\t\tmethod: 'POST',\n\t\t\t\theaders: {\n\t\t\t\t\t'content-type': 'application/json',\n\t\t\t\t\t...(body.encoded ? { 'content-encoding': 'gzip' } : {}),\n\t\t\t\t\t...transport.headers,\n\t\t\t\t},\n\t\t\t\tbody: body.bytes,\n\t\t\t\tsignal: AbortSignal.timeout(transport.timeout),\n\t\t\t});\n\t\t} catch (thrown) {\n\t\t\t// No answer at all: DNS, a refused connection, the timeout.\n\t\t\tfailure = thrown;\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (reply.ok) {\n\t\t\tawait accepted(transport, signal, reply);\n\t\t\treturn;\n\t\t}\n\n\t\tconst text = truncate(await bodyOf(reply));\n\n\t\tif (!RETRYABLE.has(reply.status)) {\n\t\t\t// The same bytes would get the same answer.\n\t\t\tthrow new OtlpRejectedError(named, signal, attempt, reply.status, text);\n\t\t}\n\n\t\tfailure = new OtlpRefusedError(named, signal, attempt, reply.status, text);\n\t}\n\n\tif (failure instanceof OtlpRefusedError) throw failure;\n\tthrow new OtlpUnreachableError(named, signal, transport.attempts, failure);\n}\n\n/**\n * The collector took the request. Its body still has to be read or cancelled:\n * an unconsumed `Response` holds its connection out of the keep-alive pool\n * until it is collected, and this is the path every successful export takes,\n * once per linger interval, for the life of the process.\n */\nasync function accepted(\n\ttransport: Transport,\n\tsignal: OtlpSignal,\n\treply: Response,\n): Promise<void> {\n\tif (transport.onPartialSuccess === undefined) {\n\t\t// Nobody asked what it said, and the ordinary answer is empty.\n\t\tawait reply.body?.cancel().catch(() => undefined);\n\t\treturn;\n\t}\n\n\treport(signal, await partialSuccess(reply), transport.onPartialSuccess);\n}\n\n/**\n * A partial success is **not retried**. The collector took the request and\n * decided about each record in it; sending the same bytes again would duplicate\n * everything it did accept.\n */\nfunction report(\n\tsignal: OtlpSignal,\n\tfound: PartialSuccess | undefined,\n\tonPartialSuccess: (report: PartialSuccessReport) => void,\n): void {\n\tif (found === undefined) return;\n\n\tconst rejected = Number(found.rejectedLogRecords ?? found.rejectedSpans ?? 0);\n\tconst message = found.errorMessage ?? '';\n\tif (rejected === 0 && message === '') return;\n\n\ttry {\n\t\tonPartialSuccess({ signal, rejected, message });\n\t} catch {\n\t\t// A reporting hook that throws must not become an export failure.\n\t}\n}\n\nasync function partialSuccess(\n\treply: Response,\n): Promise<PartialSuccess | undefined> {\n\ttry {\n\t\tconst answered = (await reply.json()) as {\n\t\t\tpartialSuccess?: PartialSuccess;\n\t\t} | null;\n\t\treturn answered?.partialSuccess;\n\t} catch {\n\t\t// An empty body is the ordinary answer, and a collector that sends\n\t\t// something else has still accepted the batch.\n\t\treturn undefined;\n\t}\n}\n\nasync function bodyOf(reply: Response): Promise<string> {\n\ttry {\n\t\treturn await reply.text();\n\t} catch {\n\t\treturn '';\n\t}\n}\n\nfunction truncate(text: string): string {\n\treturn text.length <= BODY_LIMIT ? text : `${text.slice(0, BODY_LIMIT)}…`;\n}\n\n/**\n * The URL as it may be repeated in an error message and read by whatever\n * `onExportError` logs to — **without its credentials**. A collector URL of the\n * shape `https://user:token@otlp.vendor.example/v1/logs` and one with the key\n * in the query string are both things vendors hand out, and a failure is not a\n * reason to put either in a log line.\n */\nexport function safeUrl(url: string): string {\n\ttry {\n\t\tconst parsed = new URL(url);\n\t\tparsed.username = '';\n\t\tparsed.password = '';\n\t\tparsed.search = '';\n\t\tparsed.hash = '';\n\t\treturn parsed.toString();\n\t} catch {\n\t\t// Not a URL this runtime can parse; `fetch` will say so in its own way.\n\t\treturn url;\n\t}\n}\n\n/**\n * Gzip when it is worth it, and only where `node:zlib` exists. A bundle for the\n * browser that shims the builtin away still exports — uncompressed, which every\n * collector accepts — rather than failing to load.\n */\nexport async function encode(\n\tjson: string,\n\tcompress: boolean,\n\t// `null` is \"there is no gzip here\", which is what a bundler that shims\n\t// `node:zlib` to an empty module leaves behind, whatever the types say. It\n\t// is a parameter so a spec can reach that branch without mocking a builtin.\n\tgzip: typeof zlib.gzip | null = AVAILABLE_GZIP,\n): Promise<{ bytes: Uint8Array<ArrayBuffer>; encoded: boolean }> {\n\tconst bytes = new TextEncoder().encode(json);\n\tif (!compress || bytes.byteLength < COMPRESSION_FLOOR) {\n\t\treturn { bytes, encoded: false };\n\t}\n\n\tif (typeof gzip !== 'function') return { bytes, encoded: false };\n\n\treturn new Promise((resolve) => {\n\t\tgzip(bytes, (failure, result) => {\n\t\t\tresolve(\n\t\t\t\tfailure\n\t\t\t\t\t? { bytes, encoded: false }\n\t\t\t\t\t: // `zlib` answers a `Buffer`, whose buffer is typed as\n\t\t\t\t\t\t// `ArrayBufferLike` — which `BodyInit` excludes because it\n\t\t\t\t\t\t// admits a `SharedArrayBuffer`. This one never is.\n\t\t\t\t\t\t{ bytes: result as Uint8Array<ArrayBuffer>, encoded: true },\n\t\t\t);\n\t\t});\n\t});\n}\n\nexport function wait(ms: number): Promise<void> {\n\treturn new Promise((resolve) => {\n\t\tconst timer = setTimeout(resolve, ms);\n\t\t// A retry in flight must not be the reason a process will not exit.\n\t\ttimer.unref?.();\n\t});\n}\n",
+    "import type { Exporter, Resource, Signal } from '@nxgt/telemetry';\nimport { logsRequest, tracesRequest } from '../wire/convert';\nimport {\n\tDEFAULT_ATTEMPTS,\n\tDEFAULT_BACKOFF,\n\tDEFAULT_TIMEOUT,\n\ttype PartialSuccessReport,\n\tpost,\n\ttype Transport,\n\twait,\n} from './transport';\n\nexport const DEFAULT_LOGS_PATH = '/v1/logs';\nexport const DEFAULT_TRACES_PATH = '/v1/traces';\n\nexport interface OtlpExporterOptions {\n\t/** The collector's base URL, e.g. `http://localhost:4318`. */\n\treadonly endpoint: string;\n\t/** Appended to `endpoint`. Default `/v1/logs`. */\n\treadonly logsPath?: string;\n\t/** Appended to `endpoint`. Default `/v1/traces`. */\n\treadonly tracesPath?: string;\n\t/** Sent on every request — an API key, a tenant. */\n\treadonly headers?: Readonly<Record<string, string>>;\n\t/** Per attempt, in milliseconds. Default 10s. */\n\treadonly timeout?: number;\n\t/** How many requests one document gets. Default 3. `1` disables retrying. */\n\treadonly attempts?: number;\n\t/** The first wait between attempts, doubled each time. Default 500ms. */\n\treadonly backoff?: number;\n\t/** Gzip a document over 1 KiB. Default true. */\n\treadonly gzip?: boolean;\n\t/** Called when the collector accepted the request but not every record. */\n\treadonly onPartialSuccess?: (report: PartialSuccessReport) => void;\n\t/** For specs, and for an application that routes its own traffic. */\n\treadonly fetch?: typeof fetch;\n\t/** For specs. Default a `setTimeout` that does not hold the process open. */\n\treadonly sleep?: (ms: number) => Promise<void>;\n}\n\n/**\n * Logs and traces to an OpenTelemetry collector, as OTLP/HTTP JSON.\n *\n * ```ts\n * otlpExporter({ endpoint: 'http://localhost:4318', headers: { 'x-api-key': key } })\n * ```\n *\n * There is no OpenTelemetry SDK behind this. OTLP is a wire format, and the\n * whole of it that a collector needs is two JSON documents over `fetch` — which\n * is what lets this package have one dependency and no transitive tree, and\n * what keeps the context in `AsyncLocalStorage` instead of in the Java SDK's\n * thread-local shape.\n *\n * A mixed batch is **two requests**, one per document, sent together: logs\n * failing must not cost the traces of the same batch. Both are attempted, and\n * both failures are thrown — as an `AggregateError` when there are two —\n * which means they reach `onExportError` and nothing else.\n */\nexport function otlpExporter(options: OtlpExporterOptions): Exporter {\n\tconst endpoint = options.endpoint.replace(/\\/+$/, '');\n\tconst logsUrl = endpoint + (options.logsPath ?? DEFAULT_LOGS_PATH);\n\tconst tracesUrl = endpoint + (options.tracesPath ?? DEFAULT_TRACES_PATH);\n\n\tconst transport: Transport = {\n\t\theaders: options.headers ?? {},\n\t\ttimeout: options.timeout ?? DEFAULT_TIMEOUT,\n\t\tattempts: Math.max(options.attempts ?? DEFAULT_ATTEMPTS, 1),\n\t\tbackoff: options.backoff ?? DEFAULT_BACKOFF,\n\t\tgzip: options.gzip ?? true,\n\t\t...(options.onPartialSuccess === undefined\n\t\t\t? {}\n\t\t\t: { onPartialSuccess: options.onPartialSuccess }),\n\t\tfetch: options.fetch ?? fetch,\n\t\tsleep: options.sleep ?? wait,\n\t};\n\n\treturn {\n\t\tasync export(resource: Resource, batch: readonly Signal[]): Promise<void> {\n\t\t\tconst logs = logsRequest(resource, batch);\n\t\t\tconst traces = tracesRequest(resource, batch);\n\n\t\t\tconst sent = await Promise.allSettled([\n\t\t\t\tlogs === undefined ? undefined : post(transport, logsUrl, 'logs', logs),\n\t\t\t\ttraces === undefined\n\t\t\t\t\t? undefined\n\t\t\t\t\t: post(transport, tracesUrl, 'traces', traces),\n\t\t\t]);\n\n\t\t\tthrowAll(sent);\n\t\t},\n\t};\n}\n\n/**\n * The two documents go to two paths and can fail for unrelated reasons — a\n * `400` on one and a refused connection on the other is not one outage. Losing\n * the second is losing the half of the story that says the collector is not\n * simply down, so both are reported.\n */\nfunction throwAll(sent: readonly PromiseSettledResult<unknown>[]): void {\n\tconst failures = sent\n\t\t.filter((one) => one.status === 'rejected')\n\t\t.map((one) => one.reason as unknown);\n\n\tif (failures.length === 0) return;\n\tif (failures.length === 1) throw failures[0];\n\n\tthrow new AggregateError(\n\t\tfailures,\n\t\t'[telemetry] neither the logs nor the traces of this batch arrived',\n\t);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "4685C21DF9219CEA64756E2164756E21",
+  "names": []
+}

package/dist/wire/convert.d.ts

@@ -0,0 +1,45 @@
+import type { Attributes, AttributeValue, Resource, Signal, SpanStatus } from '@nxgt/telemetry';
+import type { AnyValue, ExportLogsServiceRequest, ExportTraceServiceRequest, KeyValue, OtlpResource } from './documents';
+/** The instrumentation scope reported for spans. Logs report their `source`. */
+export declare const SPAN_SCOPE = "nxgt-telemetry";
+/**
+ * `ok` maps to `1` and `error` to `2`, and **`cancelled` maps to `0`** — unset,
+ * not error. A shutdown and a timeout are not failures, and a dashboard that
+ * counts them as such is a dashboard nobody trusts; OTLP has no third code, so
+ * the honest answer is to say nothing rather than to say "failed".
+ */
+export declare const STATUS_CODE: Readonly<Record<SpanStatus, number>>;
+/**
+ * Epoch milliseconds to the decimal nanoseconds OTLP wants, through `BigInt`.
+ *
+ * A `number` would be wrong from 2001 onwards: `Date.now() * 1e6` is well past
+ * `Number.MAX_SAFE_INTEGER`, so the last digits are whatever the float rounds
+ * to, and two signals a microsecond apart arrive with the same timestamp.
+ */
+export declare function nanos(at: number): string;
+/** A scalar, tagged the way OTLP tags it. */
+export declare function anyValue(value: AttributeValue): AnyValue;
+export declare function keyValues(attributes: Attributes): KeyValue[];
+/**
+ * The resource, with `service.name`, `service.version` and
+ * `deployment.environment.name` — the three keys every backend looks for, under
+ * the names the semantic conventions give them. An attribute already carrying
+ * one of those keys wins: it was set deliberately.
+ */
+export declare function otlpResource(resource: Resource): OtlpResource;
+/**
+ * The logs of a batch, **grouped by `source`** into one scope each: the logger's
+ * name is the instrumentation scope, which is what lets a backend filter by the
+ * component that wrote the line rather than by the service that ran it.
+ *
+ * `undefined` when there is nothing to send — an empty document is a request
+ * worth not making.
+ */
+export declare function logsRequest(resource: Resource, batch: readonly Signal[]): ExportLogsServiceRequest | undefined;
+/**
+ * The spans of a batch, in one scope named for this library. A span has no
+ * `source` — it is named for the work, not for the component — so there is
+ * nothing to group by.
+ */
+export declare function tracesRequest(resource: Resource, batch: readonly Signal[]): ExportTraceServiceRequest | undefined;
+//# sourceMappingURL=convert.d.ts.map

package/dist/wire/convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/wire/convert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,UAAU,EACV,cAAc,EAGd,QAAQ,EACR,MAAM,EAEN,UAAU,EACV,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EACX,QAAQ,EACR,wBAAwB,EACxB,yBAAyB,EACzB,QAAQ,EAER,YAAY,EAIZ,MAAM,aAAa,CAAC;AAErB,gFAAgF;AAChF,eAAO,MAAM,UAAU,mBAAmB,CAAC;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAI3D,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAExC;AAED,6CAA6C;AAC7C,wBAAgB,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,QAAQ,CAuBxD;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,UAAU,GAAG,QAAQ,EAAE,CAK5D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,CAY7D;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAC1B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,SAAS,MAAM,EAAE,GACtB,wBAAwB,GAAG,SAAS,CAkBtC;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC5B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,SAAS,MAAM,EAAE,GACtB,yBAAyB,GAAG,SAAS,CAevC"}

package/dist/wire/documents.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The OTLP/HTTP **JSON** documents, as types.
+ *
+ * These are hand-written rather than generated from the protobufs, and that is
+ * the point of this package: OTLP is a wire format, not a library. The whole
+ * surface a collector needs is the two request documents below, and writing
+ * them by hand costs less than the SDK's dependency tree.
+ *
+ * Two places where proto3 JSON and OTLP JSON differ, and where an
+ * implementation that guesses gets it wrong:
+ *
+ * - **ids are lowercase hex, not base64.** Proto3 JSON would encode a `bytes`
+ *   field as base64; the OTLP specification overrides that for `trace_id`,
+ *   `span_id` and `parent_span_id`.
+ * - **64-bit integers are strings.** `timeUnixNano` and an integer attribute
+ *   both cross the wire as text, because a JSON number is a double and
+ *   nanoseconds do not fit in one.
+ */
+/** A value, tagged by which of the fields is set. An empty object is unset. */
+export interface AnyValue {
+    readonly stringValue?: string;
+    readonly boolValue?: boolean;
+    /** Decimal text: a JSON number would lose the low bits. */
+    readonly intValue?: string;
+    readonly doubleValue?: number;
+    readonly arrayValue?: {
+        readonly values: readonly AnyValue[];
+    };
+}
+export interface KeyValue {
+    readonly key: string;
+    readonly value: AnyValue;
+}
+export interface OtlpResource {
+    readonly attributes: readonly KeyValue[];
+}
+/** Which library produced the signal. `source` for logs, this package for spans. */
+export interface InstrumentationScope {
+    readonly name: string;
+    readonly version?: string;
+}
+export interface OtlpLogRecord {
+    readonly timeUnixNano: string;
+    readonly observedTimeUnixNano: string;
+    readonly severityNumber: number;
+    readonly severityText: string;
+    readonly body: AnyValue;
+    readonly attributes: readonly KeyValue[];
+    readonly traceId?: string;
+    readonly spanId?: string;
+    /** The W3C trace flags, in the low eight bits: `1` when sampled. */
+    readonly flags?: number;
+}
+export interface ScopeLogs {
+    readonly scope: InstrumentationScope;
+    readonly logRecords: readonly OtlpLogRecord[];
+}
+export interface ResourceLogs {
+    readonly resource: OtlpResource;
+    readonly scopeLogs: readonly ScopeLogs[];
+}
+export interface ExportLogsServiceRequest {
+    readonly resourceLogs: readonly ResourceLogs[];
+}
+export interface OtlpSpanEvent {
+    readonly timeUnixNano: string;
+    readonly name: string;
+    readonly attributes: readonly KeyValue[];
+}
+export interface OtlpStatus {
+    /** `0` unset, `1` ok, `2` error. */
+    readonly code: number;
+    readonly message?: string;
+}
+export interface OtlpSpan {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId?: string;
+    readonly name: string;
+    /** `1` internal … `5` consumer. */
+    readonly kind: number;
+    readonly startTimeUnixNano: string;
+    readonly endTimeUnixNano: string;
+    readonly attributes: readonly KeyValue[];
+    readonly events: readonly OtlpSpanEvent[];
+    readonly status: OtlpStatus;
+}
+export interface ScopeSpans {
+    readonly scope: InstrumentationScope;
+    readonly spans: readonly OtlpSpan[];
+}
+export interface ResourceSpans {
+    readonly resource: OtlpResource;
+    readonly scopeSpans: readonly ScopeSpans[];
+}
+export interface ExportTraceServiceRequest {
+    readonly resourceSpans: readonly ResourceSpans[];
+}
+/**
+ * What a collector answers when it accepted the request but not everything in
+ * it — a rejected record, a quota, a bad attribute. The counts are strings for
+ * the same reason `timeUnixNano` is.
+ */
+export interface PartialSuccess {
+    readonly rejectedLogRecords?: string;
+    readonly rejectedSpans?: string;
+    readonly errorMessage?: string;
+}
+//# sourceMappingURL=documents.d.ts.map

package/dist/wire/documents.d.ts.map

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

package/package.json

@@ -0,0 +1,61 @@
+{
+	"name": "@nxgt/telemetry-otlp",
+	"version": "0.2.0",
+	"description": "An OTLP/HTTP JSON exporter for @nxgt/telemetry: logs and traces to any OpenTelemetry collector, over fetch, with no OpenTelemetry SDK",
+	"license": "MIT",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist",
+		"README.md",
+		"package.json",
+		"LICENSE"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"keywords": [
+		"otlp",
+		"opentelemetry",
+		"collector",
+		"telemetry",
+		"observability",
+		"tracing",
+		"logging",
+		"typescript"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/softistx/nxgt-telemetry.git",
+		"directory": "packages/telemetry-otlp"
+	},
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org",
+		"access": "public"
+	},
+	"scripts": {
+		"build": "bun run ../../build.ts",
+		"test": "bun test src",
+		"typecheck": "tsc --noEmit"
+	},
+	"nxgt": {
+		"entrypoints": [
+			"src/index.ts"
+		]
+	},
+	"dependencies": {
+		"@nxgt/telemetry": "^0.1.0"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.4.2"
+	},
+	"peerDependencies": {
+		"typescript": "^6.0.3"
+	}
+}