@lntrn/otel 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 0.1.0
+
+First release (LAN-365).
+- **`node --import @lntrn/otel/register`** starts a stock `NodeSDK` from
+  `LNTRN_*` / `OTEL_*`:
+  - it registers the ES module hook;
+  - it loads `@opentelemetry/auto-instrumentations-node` when installed;
+  - it flushes on exit and on `SIGTERM`/`SIGINT`.
+- **`setup(options)`** does the same from code. Targets:
+  - Lantern's edge, with Basic auth from an edge credential;
+  - the client ingest, with a device token through `@lntrn/device/otel`'s
+    `TokenCache`;
+  - an in-cluster gateway;
+  - plain `OTEL_EXPORTER_OTLP_*`.
+- **`lanternDetector()`** sets `service.namespace` and
+  `deployment.environment.name` from `LNTRN_NAMESPACE` / `LNTRN_ENVIRONMENT`.

package/README.md

@@ -1,3 +1,122 @@
-# Temporary Holding Version
+# @lntrn/otel
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Lantern's add-on for the OpenTelemetry Node SDK.
+
+## Already on OpenTelemetry? Add this
+
+```bash
+npm install @lntrn/otel @opentelemetry/api @opentelemetry/auto-instrumentations-node
+```
+
+```bash
+export OTEL_SERVICE_NAME=checkout-api
+export LNTRN_EDGE_USER=<org>.<id> LNTRN_EDGE_PASSWORD=…        # an edge credential
+export LNTRN_NAMESPACE=checkout LNTRN_ENVIRONMENT=prod
+node --import @lntrn/otel/register server.js
+```
+
+That replaces your `instrumentation.mjs`. `@lntrn/otel/register` starts a
+stock `NodeSDK` before the app loads:
+- the stock OTLP/HTTP protobuf exporters for traces, metrics and logs;
+- `@opentelemetry/auto-instrumentations-node` when it is installed, with
+  `fs` off;
+- OpenTelemetry's ES module hook, so ESM libraries (pino, express, …) are
+  instrumented too;
+- a flush before the process exits, when the event loop empties and on
+  `SIGTERM`/`SIGINT`.
+
+Your code keeps using `@opentelemetry/api` as before.
+
+In a container: `CMD ["node", "--import", "@lntrn/otel/register", "server.js"]`,
+or `NODE_OPTIONS="--import @lntrn/otel/register"`.
+
+Already starting `NodeSDK` yourself? Call `setup()` instead, with the same
+options plus your own:
+
+```js
+// instrumentation.mjs, loaded with --import
+import { register } from "node:module";
+import { setup } from "@lntrn/otel";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+
+register("@opentelemetry/instrumentation/hook.mjs", import.meta.url);
+const lantern = setup({
+  serviceName: "checkout-api",
+  instrumentations: [getNodeAutoInstrumentations()],
+  sdk: { /* sampler, views, … anything else NodeSDK takes */ },
+});
+process.once("SIGTERM", () => lantern.shutdown().finally(() => process.exit(0)));
+```
+
+Requires Node 22.15 or newer, as `@opentelemetry/sdk-node` 0.300 does.
+Tested with `sdk-node` 0.300.0 and `@opentelemetry/api` 1.10.0.
+
+## Targets
+
+`setup()` picks the first one configured, unless `target` (or `LNTRN_TARGET`)
+names one:
+
+| Target | When | Sends to | Auth |
+|---|---|---|---|
+| `edge` | `LNTRN_EDGE_USER` + `LNTRN_EDGE_PASSWORD` | `https://otlp.lntrn.dev` | HTTP Basic, the edge credential |
+| `device` | `token` or `LNTRN_DEVICE_TOKEN` | `https://in.lntrn.dev` | `Bearer <device token>` |
+| `gateway` | `LNTRN_ENDPOINT` with no credential | that endpoint, e.g. an in-cluster collector | none |
+| `otel` | `OTEL_EXPORTER_OTLP_ENDPOINT` (or a signal's own) | wherever `OTEL_EXPORTER_OTLP_*` say: plain `NodeSDK` | `OTEL_EXPORTER_OTLP_HEADERS` |
+| `none` | nothing configured, or `OTEL_SDK_DISABLED=true` | nowhere. Spans still get ids, so log lines still carry them | |
+
+Details:
+- `LNTRN_ENDPOINT` (`endpoint`) replaces the edge's or the ingest's address,
+  e.g. `https://forwarder.otlp.lntrn.dev`.
+- The paths `/v1/traces`, `/v1/metrics` and `/v1/logs` are appended.
+- Lantern's endpoints are OTLP/HTTP only. There is no gRPC.
+
+### Node processes on devices
+
+A process running on hardware you don't control can't hold an edge credential.
+Examples: an emulation node, a kiosk, a desktop app's main process. It sends
+to the client ingest with a device token instead:
+
+```js
+import { setup } from "@lntrn/otel";
+
+setup({
+  serviceName: "emulation-node",
+  // Called only when the cached token is due for renewal: a minute before exp.
+  token: () => fetchTokenFromYourBackend(),   // or mintToken({...}) from @lntrn/device/server, where the key lives
+});
+```
+
+The token cache is `@lntrn/device/otel`'s `TokenCache`, the same one the JS
+device add-on uses. Concurrent exports share one fetch, and a failed fetch
+keeps the old token while it is still valid. The ingest files the records
+under the token's project.
+
+## Resource
+
+| Attribute | From |
+|---|---|
+| `service.name` | `serviceName`; `OTEL_SERVICE_NAME` wins |
+| `service.version` | `serviceVersion` |
+| `service.namespace` | `namespace` or `LNTRN_NAMESPACE` |
+| `deployment.environment.name` | `environment` or `LNTRN_ENVIRONMENT` |
+| anything | `attributes`; `OTEL_RESOURCE_ATTRIBUTES` wins |
+
+`lanternDetector()` is the namespace/environment part as a `ResourceDetector`,
+for a `NodeSDK` you configure entirely yourself.
+
+## Turning a signal off
+
+`OTEL_TRACES_EXPORTER`, `OTEL_METRICS_EXPORTER` or `OTEL_LOGS_EXPORTER` set to
+`none` (or `disableTraces`/`disableMetrics`/`disableLogs`) leaves that signal
+without an exporter. In Kubernetes, with Lantern's agent collecting container
+output, set `OTEL_LOGS_EXPORTER=none`. pino's OpenTelemetry instrumentation
+still writes `trace_id` and `span_id` into every stdout line.
+
+`LNTRN_INSTRUMENTATIONS=none` stops `register` from loading the
+auto-instrumentations.
+
+## Releasing
+
+Bump `"version"` in `package.json`, add the CHANGELOG entry, and merge to
+main. CI (`.xeonr-ci.yaml`, app `lntrn-otel-node`) tests, builds and publishes
+any version the registry hasn't got, and tags it `node-vX.Y.Z`.

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * `@lntrn/otel`: Lantern's add-on for the OpenTelemetry Node SDK.
+ *
+ * It does not replace the SDK. `setup()` starts a stock `NodeSDK` with the
+ * stock OTLP/HTTP protobuf exporters and adds only what Lantern needs: where
+ * to send, how to authenticate, and the resource attributes Lantern groups
+ * by. Most services don't call it at all; they start with
+ * `node --import @lntrn/otel/register app.js` and configure it with `LNTRN_*`
+ * variables.
+ */
+import { NodeSDK, type NodeSDKConfiguration } from "@opentelemetry/sdk-node";
+import { type ResourceDetector } from "@opentelemetry/resources";
+import type { Attributes } from "@opentelemetry/api";
+import { type Target, type TargetOptions } from "./target.ts";
+export { EDGE_URL, INGEST_URL, resolveTarget } from "./target.ts";
+export type { ResolvedTarget, Target, TargetOptions } from "./target.ts";
+export { TokenCache, deviceTokenHeaders } from "@lntrn/device/otel";
+export interface LanternOptions extends TargetOptions {
+    /** `service.name`. `OTEL_SERVICE_NAME`, when set, wins, as in every SDK. */
+    serviceName?: string;
+    /** `service.version`: the release, from your CI. */
+    serviceVersion?: string;
+    /** `service.namespace` (`LNTRN_NAMESPACE`). */
+    namespace?: string;
+    /** `deployment.environment.name` (`LNTRN_ENVIRONMENT`). */
+    environment?: string;
+    /** More resource attributes. `OTEL_RESOURCE_ATTRIBUTES` wins over these and the fields above. */
+    attributes?: Attributes;
+    /**
+     * Leave a signal without an exporter. `OTEL_TRACES_EXPORTER`,
+     * `OTEL_METRICS_EXPORTER` or `OTEL_LOGS_EXPORTER` set to `none` does the
+     * same: in Kubernetes, with Lantern's agent collecting stdout, set
+     * `OTEL_LOGS_EXPORTER=none` and keep logging to stdout.
+     */
+    disableTraces?: boolean;
+    disableMetrics?: boolean;
+    disableLogs?: boolean;
+    /** How often metrics are exported, in ms. Default `OTEL_METRIC_EXPORT_INTERVAL`, then 30000. */
+    metricInterval?: number;
+    /** Instrumentations to register, e.g. `getNodeAutoInstrumentations()`. */
+    instrumentations?: NodeSDKConfiguration["instrumentations"];
+    /**
+     * Anything else for `NodeSDK` (sampler, views, propagator, …). It is
+     * applied last, so it can override the exporters this add-on builds.
+     */
+    sdk?: Partial<NodeSDKConfiguration>;
+}
+/** What `setup()` started. */
+export interface Lantern {
+    target: Target;
+    sdk: NodeSDK;
+    /** Flushes and stops every provider. Safe to call more than once. */
+    shutdown(): Promise<void>;
+}
+/**
+ * Starts a stock `NodeSDK` that sends to Lantern, and registers it as the
+ * global OpenTelemetry. Call it before the code it instruments is imported
+ * (which `@lntrn/otel/register` does for you), and `shutdown()` before the
+ * process exits, or the last batch is lost.
+ */
+export declare function setup(options?: LanternOptions, env?: Record<string, string | undefined>): Lantern;
+/**
+ * A resource detector for `service.namespace` and
+ * `deployment.environment.name`, from the given values or `LNTRN_NAMESPACE`
+ * and `LNTRN_ENVIRONMENT`. For a `NodeSDK` you configure yourself:
+ *
+ * ```ts
+ * new NodeSDK({ resourceDetectors: [lanternDetector(), envDetector, processDetector, hostDetector] });
+ * ```
+ *
+ * Put `envDetector` after it, so `OTEL_RESOURCE_ATTRIBUTES` still wins.
+ */
+export declare function lanternDetector(o?: {
+    namespace?: string;
+    environment?: string;
+}, env?: Record<string, string | undefined>): ResourceDetector;

package/dist/index.js

@@ -0,0 +1,102 @@
+/**
+ * `@lntrn/otel`: Lantern's add-on for the OpenTelemetry Node SDK.
+ *
+ * It does not replace the SDK. `setup()` starts a stock `NodeSDK` with the
+ * stock OTLP/HTTP protobuf exporters and adds only what Lantern needs: where
+ * to send, how to authenticate, and the resource attributes Lantern groups
+ * by. Most services don't call it at all; they start with
+ * `node --import @lntrn/otel/register app.js` and configure it with `LNTRN_*`
+ * variables.
+ */
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
+import { BatchSpanProcessor, NoopSpanProcessor } from "@opentelemetry/sdk-trace";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { defaultResource, resourceFromAttributes } from "@opentelemetry/resources";
+import { resolveTarget } from "./target.js";
+export { EDGE_URL, INGEST_URL, resolveTarget } from "./target.js";
+export { TokenCache, deviceTokenHeaders } from "@lntrn/device/otel";
+/**
+ * Starts a stock `NodeSDK` that sends to Lantern, and registers it as the
+ * global OpenTelemetry. Call it before the code it instruments is imported
+ * (which `@lntrn/otel/register` does for you), and `shutdown()` before the
+ * process exits, or the last batch is lost.
+ */
+export function setup(options = {}, env = process.env) {
+    const resolved = resolveTarget(options, env);
+    const config = {
+        resource: defaultResource().merge(resourceFromAttributes(resourceAttributes(options, env))),
+        instrumentations: options.instrumentations ?? [],
+    };
+    if (resolved.target === "none") {
+        // Providers with nothing behind them: spans still get ids, so logs
+        // still carry them, and nothing is sent anywhere.
+        config.spanProcessors = [new NoopSpanProcessor()];
+        config.metricReaders = [];
+        config.logRecordProcessors = [];
+    }
+    else if (resolved.url) {
+        const { url, headers } = resolved;
+        const off = (flag, name) => flag || env[name]?.trim().toLowerCase() === "none";
+        config.spanProcessors = off(options.disableTraces, "OTEL_TRACES_EXPORTER")
+            ? [new NoopSpanProcessor()]
+            : [new BatchSpanProcessor({ exporter: new OTLPTraceExporter({ url: `${url}/v1/traces`, headers }) })];
+        config.metricReaders = off(options.disableMetrics, "OTEL_METRICS_EXPORTER")
+            ? []
+            : [
+                new PeriodicExportingMetricReader({
+                    exporter: new OTLPMetricExporter({ url: `${url}/v1/metrics`, headers }),
+                    exportIntervalMillis: options.metricInterval ?? (Number(env.OTEL_METRIC_EXPORT_INTERVAL) || 30_000),
+                }),
+            ];
+        config.logRecordProcessors = off(options.disableLogs, "OTEL_LOGS_EXPORTER")
+            ? []
+            : [new BatchLogRecordProcessor({ exporter: new OTLPLogExporter({ url: `${url}/v1/logs`, headers }) })];
+    }
+    // target "otel": no exporters given, so NodeSDK builds them from OTEL_*.
+    const sdk = new NodeSDK({ ...config, ...options.sdk });
+    sdk.start();
+    let stopped;
+    return {
+        target: resolved.target,
+        sdk,
+        shutdown: () => (stopped ??= sdk.shutdown().catch(() => { })),
+    };
+}
+/**
+ * A resource detector for `service.namespace` and
+ * `deployment.environment.name`, from the given values or `LNTRN_NAMESPACE`
+ * and `LNTRN_ENVIRONMENT`. For a `NodeSDK` you configure yourself:
+ *
+ * ```ts
+ * new NodeSDK({ resourceDetectors: [lanternDetector(), envDetector, processDetector, hostDetector] });
+ * ```
+ *
+ * Put `envDetector` after it, so `OTEL_RESOURCE_ATTRIBUTES` still wins.
+ */
+export function lanternDetector(o = {}, env = process.env) {
+    return {
+        detect: () => {
+            const attributes = {};
+            const ns = o.namespace || env.LNTRN_NAMESPACE;
+            const environment = o.environment || env.LNTRN_ENVIRONMENT;
+            if (ns)
+                attributes["service.namespace"] = ns;
+            if (environment)
+                attributes["deployment.environment.name"] = environment;
+            return { attributes };
+        },
+    };
+}
+function resourceAttributes(o, env) {
+    const attrs = { ...o.attributes };
+    if (o.serviceName)
+        attrs["service.name"] = o.serviceName;
+    if (o.serviceVersion)
+        attrs["service.version"] = o.serviceVersion;
+    Object.assign(attrs, lanternDetector(o, env).detect().attributes);
+    return attrs;
+}

package/dist/register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/register.js

@@ -0,0 +1,52 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * `node --import @lntrn/otel/register app.js`
+ *
+ * Starts the SDK from the environment before the app loads:
+ * - registers OpenTelemetry's ES module hook, so instrumentations can patch
+ *   ES modules (pino, express, …) as they are imported;
+ * - turns on `@opentelemetry/auto-instrumentations-node` when it is
+ *   installed (the fs instrumentation stays off: noisy and rarely useful).
+ *   `LNTRN_INSTRUMENTATIONS=none` skips it;
+ * - calls `setup()`, which reads `LNTRN_*` and `OTEL_*`;
+ * - flushes before the process exits: when the event loop empties, and on
+ *   SIGTERM or SIGINT. A signal the app also handles is left to the app;
+ *   one it doesn't is re-raised after the flush, so the exit code is the
+ *   usual one.
+ */
+import { register } from "node:module";
+import { setup } from "./index.js";
+register("@opentelemetry/instrumentation/hook.mjs", import.meta.url);
+// An optional peer dependency: named through a variable so the build does not
+// need it installed to typecheck.
+const AUTO = "@opentelemetry/auto-instrumentations-node";
+const instrumentations = [];
+if (process.env.LNTRN_INSTRUMENTATIONS?.trim().toLowerCase() !== "none") {
+    try {
+        const { getNodeAutoInstrumentations } = (await import(__rewriteRelativeImportExtension(AUTO)));
+        instrumentations.push(getNodeAutoInstrumentations({ "@opentelemetry/instrumentation-fs": { enabled: false } }));
+    }
+    catch (err) {
+        // Not installed is fine: the app's own spans and logs still go out.
+        if (err.code !== "ERR_MODULE_NOT_FOUND")
+            throw err;
+    }
+}
+const lantern = setup({ instrumentations: instrumentations });
+process.once("beforeExit", () => void lantern.shutdown());
+for (const signal of ["SIGTERM", "SIGINT"]) {
+    process.once(signal, () => {
+        const appHandles = process.listenerCount(signal) > 0;
+        void lantern.shutdown().finally(() => {
+            if (!appHandles)
+                process.kill(process.pid, signal);
+        });
+    });
+}

package/dist/target.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Where to send, and how to authenticate: the part of the add-on with no
+ * OpenTelemetry in it, so it can be tested on its own.
+ */
+import { TokenCache, type TokenSource } from "@lntrn/device/otel";
+/** Lantern's OTLP edge, for servers: HTTP Basic with an edge credential. */
+export declare const EDGE_URL = "https://otlp.lntrn.dev";
+/** Lantern's client ingest, for devices: a device token as the bearer. */
+export declare const INGEST_URL = "https://in.lntrn.dev";
+/**
+ * - `edge`: the organisation's OTLP edge, with an edge credential.
+ * - `device`: the client ingest, with a device token.
+ * - `gateway`: an in-cluster collector at `endpoint`, with no credential.
+ * - `otel`: whatever the standard `OTEL_EXPORTER_OTLP_*` variables say.
+ * - `none`: nothing is sent; spans still get ids.
+ */
+export type Target = "edge" | "device" | "gateway" | "otel" | "none";
+export interface TargetOptions {
+    /** Default: `LNTRN_TARGET`, then the first configured target in the order above. */
+    target?: Target;
+    /** Replaces the target's base URL (`LNTRN_ENDPOINT`). `/v1/<signal>` is appended. */
+    endpoint?: string;
+    /** An edge credential (`LNTRN_EDGE_USER`, `LNTRN_EDGE_PASSWORD`). */
+    edgeUser?: string;
+    edgePassword?: string;
+    /**
+     * Device tokens for the `device` target: a token, a function returning
+     * one (your backend, or `mintToken` from `@lntrn/device/server`), or a
+     * `TokenCache`. Default `LNTRN_DEVICE_TOKEN`.
+     */
+    token?: TokenSource | TokenCache;
+    /** Told when no device token can be had; the export then goes without one. */
+    onTokenError?: (err: Error) => void;
+}
+/** A resolved target: the base URL and the headers factory for its exporters. */
+export interface ResolvedTarget {
+    target: Target;
+    /** Undefined for `otel` and `none`, which build no exporters of their own. */
+    url?: string;
+    headers?: Record<string, string> | (() => Promise<Record<string, string>>);
+}
+type Env = Record<string, string | undefined>;
+export declare function resolveTarget(o: TargetOptions, env?: Env): ResolvedTarget;
+export {};

package/dist/target.js

@@ -0,0 +1,68 @@
+/**
+ * Where to send, and how to authenticate: the part of the add-on with no
+ * OpenTelemetry in it, so it can be tested on its own.
+ */
+import { TokenCache, deviceTokenHeaders } from "@lntrn/device/otel";
+/** Lantern's OTLP edge, for servers: HTTP Basic with an edge credential. */
+export const EDGE_URL = "https://otlp.lntrn.dev";
+/** Lantern's client ingest, for devices: a device token as the bearer. */
+export const INGEST_URL = "https://in.lntrn.dev";
+const TARGETS = new Set(["edge", "device", "gateway", "otel", "none"]);
+export function resolveTarget(o, env = process.env) {
+    let target = o.target ?? (env.LNTRN_TARGET || undefined)?.toLowerCase();
+    if (env.OTEL_SDK_DISABLED?.trim().toLowerCase() === "true")
+        target = "none";
+    const base = o.endpoint || env.LNTRN_ENDPOINT || undefined;
+    const user = o.edgeUser || env.LNTRN_EDGE_USER || undefined;
+    const pass = o.edgePassword || env.LNTRN_EDGE_PASSWORD || undefined;
+    const token = o.token ?? (env.LNTRN_DEVICE_TOKEN || undefined);
+    if (target === undefined) {
+        if (user || pass)
+            target = "edge";
+        else if (token)
+            target = "device";
+        else if (base)
+            target = "gateway";
+        else if (otelEndpointSet(env))
+            target = "otel";
+        else
+            target = "none";
+    }
+    if (!TARGETS.has(target)) {
+        throw new Error(`lntrn: unknown target "${target}" (want edge, device, gateway, otel or none)`);
+    }
+    const trim = (u) => u.replace(/\/+$/, "");
+    switch (target) {
+        case "edge":
+            if (!user || !pass) {
+                throw new Error("lntrn: the edge target needs both an edge user and password (LNTRN_EDGE_USER, LNTRN_EDGE_PASSWORD)");
+            }
+            return {
+                target,
+                url: trim(base ?? EDGE_URL),
+                headers: { Authorization: `Basic ${Buffer.from(`${user}:${pass}`).toString("base64")}` },
+            };
+        case "device":
+            if (!token)
+                throw new Error("lntrn: the device target needs a token (options.token or LNTRN_DEVICE_TOKEN)");
+            return {
+                target,
+                url: trim(base ?? INGEST_URL),
+                headers: deviceTokenHeaders(token, { onError: o.onTokenError }),
+            };
+        case "gateway":
+            if (!base)
+                throw new Error("lntrn: the gateway target needs an endpoint (options.endpoint or LNTRN_ENDPOINT)");
+            return { target, url: trim(base) };
+        default:
+            return { target };
+    }
+}
+function otelEndpointSet(env) {
+    return [
+        "OTEL_EXPORTER_OTLP_ENDPOINT",
+        "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
+        "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
+        "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT",
+    ].some((k) => !!env[k]);
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@lntrn/otel",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Lantern's add-on for the OpenTelemetry Node SDK: node --import @lntrn/otel/register sends traces, metrics and logs to Lantern's edge or client ingest through the stock NodeSDK and OTLP exporters.",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.15"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.prod.wtf/xeonr/lantern/otel.git",
+    "directory": "node"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "default": "./dist/register.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@lntrn/device": "^1.3.0",
+    "@opentelemetry/exporter-logs-otlp-proto": "^0.300.0",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.300.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.300.0",
+    "@opentelemetry/instrumentation": "^0.300.0",
+    "@opentelemetry/resources": "^3.0.0",
+    "@opentelemetry/sdk-logs": "^3.0.0",
+    "@opentelemetry/sdk-metrics": "^3.0.0",
+    "@opentelemetry/sdk-node": "^0.300.0",
+    "@opentelemetry/sdk-trace": "^3.0.0"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.10.0 <1.11.0",
+    "@opentelemetry/auto-instrumentations-node": ">=0.82.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/auto-instrumentations-node": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "1.10.0",
+    "@types/node": "^22.15.0",
+    "typescript": "^5.9.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && node scripts/check-dist.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --experimental-transform-types --no-warnings --test 'src/**/*.test.ts'"
+  }
 }