@heystack/otel 0.0.1 → 0.1.0

package/README.md

@@ -1,15 +1,59 @@
 # @heystack/otel
 
-One-call OpenTelemetry tracing that exports to Heystack.
+Runtime-aware OpenTelemetry tracing that exports to Heystack. One import per runtime, so the `.` entry stays safe to load anywhere (including Edge/Workers) without dragging in the Node SDK.
 
 ```bash
 npm install @heystack/otel
 ```
 
+Always read your key from the environment — never paste it into source:
+
+```bash
+# .env
+HEYSTACK_API_KEY=sk_live_…
+```
+
+## Runtime matrix
+
+| Runtime | Import | Notes |
+| --- | --- | --- |
+| Node / Express / Fastify / workers (long-running) | `@heystack/otel/node` | Auto-instrumentations + graceful shutdown. |
+| Next.js (`instrumentation.ts`) | `@heystack/otel/next` | Runtime-guarded; no-op on Edge. |
+| Cloudflare Workers / Edge | `@heystack/otel/workers` | Coming soon — the Node SDK can't run on Workers/Edge. |
+| Anywhere (pure helpers) | `@heystack/otel` | `buildExporterConfig`, types. No Node SDK loaded. |
+
+## Node / Express / etc.
+
 At the very top of your app's entry file:
+
+```ts
+import { initHeystack } from "@heystack/otel/node";
+
+initHeystack({ apiKey: process.env.HEYSTACK_API_KEY, service: "my-app" });
+```
+
+This enables auto-instrumentations (HTTP, Express, etc.) so you get spans without manual wiring.
+
+## Next.js
+
+In `instrumentation.ts` at the project root:
+
 ```ts
-import { initHeystack } from "@heystack/otel";
-initHeystack({ apiKey: process.env.HEYSTACK_KEY!, service: "my-app" });
+export async function register() {
+  const { registerHeystack } = await import("@heystack/otel/next");
+  await registerHeystack({ service: "my-app" });
+}
 ```
 
+`apiKey` defaults to `process.env.HEYSTACK_API_KEY`. `registerHeystack` only initialises on the Node.js runtime — on the Edge runtime it's a no-op, so it's safe to call unconditionally.
+
+## Workers / Edge
+
+Coming in `@heystack/otel/workers` — the Node SDK can't run on Workers/Edge, so a dedicated, fetch-based entry handles those runtimes.
+
+## Verify it's working
+
+- Pass `debug: true` to `initHeystack` to print OTel diagnostic/export logs to the console.
+- Short-lived processes: `initHeystack` registers `SIGTERM`/`SIGINT` handlers automatically, so the SDK flushes and shuts down before exit and you don't lose the last batch.
+
 Then run your app and make a request — traces appear in your Heystack dashboard within seconds.

package/dist/core.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_ENDPOINT = "https://ingest.heystack.dev";
+export interface HeystackOptions {
+    /** Your Heystack ingest key (sk_live_...). Prefer process.env.HEYSTACK_API_KEY. */
+    apiKey: string;
+    /** OTel service.name this app reports as. */
+    service: string;
+    /** Override the ingest endpoint (defaults to Heystack production). */
+    endpoint?: string;
+}
+export interface ExporterConfig {
+    url: string;
+    headers: {
+        Authorization: string;
+    };
+}
+/** Pure: derive the OTLP/HTTP traces URL + auth header. Works in any runtime. */
+export declare function buildExporterConfig(o: HeystackOptions): ExporterConfig;

package/dist/core.js

@@ -0,0 +1,6 @@
+export const DEFAULT_ENDPOINT = "https://ingest.heystack.dev";
+/** Pure: derive the OTLP/HTTP traces URL + auth header. Works in any runtime. */
+export function buildExporterConfig(o) {
+    const base = (o.endpoint ?? DEFAULT_ENDPOINT).replace(/\/+$/, "");
+    return { url: `${base}/v1/traces`, headers: { Authorization: `Bearer ${o.apiKey}` } };
+}

package/dist/next.d.ts

@@ -0,0 +1,10 @@
+import type { HeystackOptions } from "./core.js";
+/**
+ * Call from Next.js instrumentation.ts:
+ *   export function register() { registerHeystack({ service: "my-app" }); }
+ * apiKey defaults to process.env.HEYSTACK_API_KEY. Only initialises on the Node.js
+ * runtime — on Edge it's a no-op (the Node SDK can't run there).
+ */
+export declare function registerHeystack(o: Partial<HeystackOptions> & {
+    service: string;
+}): Promise<void>;

package/dist/next.js

@@ -0,0 +1,23 @@
+/**
+ * Call from Next.js instrumentation.ts:
+ *   export function register() { registerHeystack({ service: "my-app" }); }
+ * apiKey defaults to process.env.HEYSTACK_API_KEY. Only initialises on the Node.js
+ * runtime — on Edge it's a no-op (the Node SDK can't run there).
+ */
+export async function registerHeystack(o) {
+    // Next sets NEXT_RUNTIME to "nodejs" | "edge"
+    if (process.env.NEXT_RUNTIME !== "nodejs")
+        return;
+    const apiKey = o.apiKey ?? process.env.HEYSTACK_API_KEY;
+    if (!apiKey) {
+        console.warn("[heystack] HEYSTACK_API_KEY not set — tracing disabled");
+        return;
+    }
+    const { initHeystack } = await import("./node.js");
+    initHeystack({
+        apiKey,
+        service: o.service,
+        endpoint: o.endpoint,
+        debug: o.debug,
+    });
+}

package/dist/node.d.ts

@@ -0,0 +1,12 @@
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { type HeystackOptions } from "./core.js";
+export interface NodeOptions extends HeystackOptions {
+    /** Enable OTel diagnostic logging to console to confirm export. */
+    debug?: boolean;
+    /** Set false to skip auto-instrumentations (you'll then only get framework/manual spans). Default true. */
+    autoInstrument?: boolean;
+}
+/** Initialise Heystack tracing on a Node runtime. Call once, as early as possible. Returns the started SDK. */
+export declare function initHeystack(o: NodeOptions): NodeSDK;
+/** Flush + shutdown the SDK on SIGTERM/SIGINT so short-lived processes don't lose the last batch. */
+export declare function shutdownOnSignals(sdk: NodeSDK): void;

package/dist/node.js

@@ -0,0 +1,30 @@
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { diag, DiagConsoleLogger, DiagLogLevel } from "@opentelemetry/api";
+import { buildExporterConfig } from "./core.js";
+/** Initialise Heystack tracing on a Node runtime. Call once, as early as possible. Returns the started SDK. */
+export function initHeystack(o) {
+    if (o.debug)
+        diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG);
+    const cfg = buildExporterConfig(o);
+    const sdk = new NodeSDK({
+        serviceName: o.service,
+        traceExporter: new OTLPTraceExporter({ url: cfg.url, headers: cfg.headers }),
+        instrumentations: o.autoInstrument === false ? [] : [getNodeAutoInstrumentations()],
+    });
+    sdk.start();
+    shutdownOnSignals(sdk);
+    return sdk;
+}
+/** Flush + shutdown the SDK on SIGTERM/SIGINT so short-lived processes don't lose the last batch. */
+export function shutdownOnSignals(sdk) {
+    const stop = () => {
+        sdk
+            .shutdown()
+            .catch(() => { })
+            .finally(() => process.exit(0));
+    };
+    process.once("SIGTERM", stop);
+    process.once("SIGINT", stop);
+}

package/dist/workers.d.ts

@@ -0,0 +1,106 @@
+import { type Span } from "@opentelemetry/api";
+import { BasicTracerProvider, type ReadableSpan, type SpanExporter } from "@opentelemetry/sdk-trace-base";
+import { type HeystackOptions } from "./core.js";
+declare const ExportResultCode: {
+    readonly SUCCESS: 0;
+    readonly FAILED: 1;
+};
+interface ExportResult {
+    code: (typeof ExportResultCode)[keyof typeof ExportResultCode];
+    error?: Error;
+}
+interface OtlpAnyValue {
+    stringValue?: string;
+    intValue?: string;
+    doubleValue?: number;
+    boolValue?: boolean;
+    arrayValue?: {
+        values: OtlpAnyValue[];
+    };
+}
+interface OtlpKeyValue {
+    key: string;
+    value: OtlpAnyValue;
+}
+interface OtlpSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId: string;
+    name: string;
+    kind: number;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes: OtlpKeyValue[];
+    status: {
+        code: number;
+        message?: string;
+    };
+}
+interface OtlpTracesPayload {
+    resourceSpans: {
+        resource: {
+            attributes: OtlpKeyValue[];
+        };
+        scopeSpans: {
+            spans: OtlpSpan[];
+        }[];
+    }[];
+}
+/**
+ * Serialize a batch of ended spans into a single OTLP/JSON traces payload.
+ *
+ * All spans in a SimpleSpanProcessor batch share the same per-request provider,
+ * hence the same resource, so we emit a single resourceSpans entry.
+ */
+export declare function serializeSpans(spans: ReadableSpan[]): OtlpTracesPayload;
+/**
+ * A WinterCG-compatible OTLP/JSON span exporter. POSTs ended spans to the
+ * Heystack ingest using the platform `fetch` — no Node built-ins.
+ */
+export declare class HeystackSpanExporter implements SpanExporter {
+    private readonly url;
+    private readonly headers;
+    private shutdownState;
+    constructor(options: HeystackOptions);
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+export interface WorkersConfig {
+    service: string;
+    /** Defaults to env.HEYSTACK_API_KEY at request time if omitted. */
+    apiKey?: string;
+    endpoint?: string;
+}
+/**
+ * Build a `BasicTracerProvider` wired to a `HeystackSpanExporter` via a
+ * `SimpleSpanProcessor`. Exposed for advanced users who want to add manual
+ * spans; for typical use prefer {@link instrument}.
+ *
+ * On Workers each request should get its own short-lived provider so its spans
+ * can be flushed via `ctx.waitUntil(provider.forceFlush())`.
+ */
+export declare function createTracerProvider(config: HeystackOptions): BasicTracerProvider;
+/** Reset the once-only no-key warning. Internal/testing helper. */
+export declare function __resetWarnings(): void;
+interface FetchHandler<E> {
+    fetch: (req: Request, env: E, ctx: ExecutionContext) => Promise<Response> | Response;
+}
+/**
+ * Wrap a Worker's default export so every request is auto-traced with a SERVER
+ * span. The export is flushed via `ctx.waitUntil` so it completes after the
+ * response is returned.
+ *
+ *   import { instrument } from "@heystack/otel/workers";
+ *   export default instrument(
+ *     { async fetch(req, env, ctx) { return new Response("ok"); } },
+ *     { service: "my-worker" },
+ *   );
+ *
+ * If no API key is available (neither `config.apiKey` nor
+ * `env.HEYSTACK_API_KEY`), the handler runs untraced.
+ */
+export declare function instrument<E = unknown>(handler: FetchHandler<E>, config: WorkersConfig): {
+    fetch: (req: Request, env: E, ctx: ExecutionContext) => Promise<Response>;
+};
+export type { Span };

package/dist/workers.js

@@ -0,0 +1,255 @@
+/// <reference types="@cloudflare/workers-types" />
+//
+// Native Cloudflare Workers / Vercel Edge tracing path for Heystack.
+//
+// Unlike `@heystack/otel/node`, this entry contains NO Node built-ins. It uses
+// only `@opentelemetry/api`, `@opentelemetry/sdk-trace-base`,
+// `@opentelemetry/resources` and the platform `fetch` — all WinterCG-safe — and
+// ships its own OTLP/JSON-over-fetch span exporter so it runs on Workers/Edge
+// where the Node SDK cannot.
+import { context, trace, SpanKind, SpanStatusCode, } from "@opentelemetry/api";
+import { Resource } from "@opentelemetry/resources";
+import { BasicTracerProvider, SimpleSpanProcessor, } from "@opentelemetry/sdk-trace-base";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import { buildExporterConfig } from "./core.js";
+// `ExportResult` / `ExportResultCode` mirror `@opentelemetry/core`. We define
+// them inline (structurally identical) rather than import them: core is only a
+// transitive dep of sdk-trace-base and isn't reliably resolvable, and keeping it
+// out guarantees no extra (potentially node-platform) code in the bundle.
+const ExportResultCode = { SUCCESS: 0, FAILED: 1 };
+/** Convert an OTel HrTime `[seconds, nanos]` tuple to a nanosecond string. */
+function hrTimeToUnixNano(time) {
+    // BigInt math keeps full nanosecond precision without float rounding.
+    return (BigInt(time[0]) * 1000000000n + BigInt(time[1])).toString();
+}
+/** Map a single attribute value to the OTLP/JSON tagged-union form. */
+function toAnyValue(value) {
+    if (typeof value === "string")
+        return { stringValue: value };
+    if (typeof value === "boolean")
+        return { boolValue: value };
+    if (typeof value === "number") {
+        // OTLP distinguishes int from double; Number.isInteger picks the int tag.
+        return Number.isInteger(value)
+            ? { intValue: String(value) }
+            : { doubleValue: value };
+    }
+    if (Array.isArray(value)) {
+        return { arrayValue: { values: value.map(toAnyValue) } };
+    }
+    // Fallback: stringify anything else (objects, bigint, etc.).
+    return { stringValue: String(value) };
+}
+function toKeyValues(attrs) {
+    const out = [];
+    if (!attrs)
+        return out;
+    for (const key of Object.keys(attrs)) {
+        const v = attrs[key];
+        if (v === undefined || v === null)
+            continue;
+        out.push({ key, value: toAnyValue(v) });
+    }
+    return out;
+}
+/**
+ * Map the OTel API `SpanKind` enum to the OTLP wire encoding.
+ *
+ * The API enum is INTERNAL=0, SERVER=1, CLIENT=2, PRODUCER=3, CONSUMER=4, but
+ * the OTLP/JSON wire format (and Heystack's schema `SPAN_KIND` map) is
+ * UNSPECIFIED=0, INTERNAL=1, SERVER=2, CLIENT=3, PRODUCER=4, CONSUMER=5 — i.e.
+ * shifted by one. Without this shift, SERVER spans would be ingested as
+ * INTERNAL.
+ */
+function toOtlpKind(kind) {
+    return kind + 1;
+}
+function toStatus(status) {
+    // SpanStatusCode is the int enum (UNSET=0, OK=1, ERROR=2) the schema expects.
+    const out = { code: status.code };
+    if (status.message)
+        out.message = status.message;
+    return out;
+}
+function readableSpanToOtlp(span) {
+    const ctx = span.spanContext();
+    return {
+        traceId: ctx.traceId,
+        spanId: ctx.spanId,
+        parentSpanId: span.parentSpanId ?? "",
+        name: span.name,
+        kind: toOtlpKind(span.kind),
+        startTimeUnixNano: hrTimeToUnixNano(span.startTime),
+        endTimeUnixNano: hrTimeToUnixNano(span.endTime),
+        attributes: toKeyValues(span.attributes),
+        status: toStatus(span.status),
+    };
+}
+/**
+ * Serialize a batch of ended spans into a single OTLP/JSON traces payload.
+ *
+ * All spans in a SimpleSpanProcessor batch share the same per-request provider,
+ * hence the same resource, so we emit a single resourceSpans entry.
+ */
+export function serializeSpans(spans) {
+    const resourceAttrs = spans[0]
+        ? spans[0].resource.attributes
+        : {};
+    return {
+        resourceSpans: [
+            {
+                resource: { attributes: toKeyValues(resourceAttrs) },
+                scopeSpans: [{ spans: spans.map(readableSpanToOtlp) }],
+            },
+        ],
+    };
+}
+// ---------------------------------------------------------------------------
+// Exporter
+// ---------------------------------------------------------------------------
+/**
+ * A WinterCG-compatible OTLP/JSON span exporter. POSTs ended spans to the
+ * Heystack ingest using the platform `fetch` — no Node built-ins.
+ */
+export class HeystackSpanExporter {
+    url;
+    headers;
+    shutdownState = false;
+    constructor(options) {
+        const cfg = buildExporterConfig(options);
+        this.url = cfg.url;
+        this.headers = {
+            ...cfg.headers,
+            "content-type": "application/json",
+        };
+    }
+    export(spans, resultCallback) {
+        if (this.shutdownState) {
+            resultCallback({
+                code: ExportResultCode.FAILED,
+                error: new Error("HeystackSpanExporter has been shut down"),
+            });
+            return;
+        }
+        if (spans.length === 0) {
+            resultCallback({ code: ExportResultCode.SUCCESS });
+            return;
+        }
+        const body = JSON.stringify(serializeSpans(spans));
+        fetch(this.url, { method: "POST", headers: this.headers, body })
+            .then((res) => {
+            if (res.ok) {
+                resultCallback({ code: ExportResultCode.SUCCESS });
+            }
+            else {
+                resultCallback({
+                    code: ExportResultCode.FAILED,
+                    error: new Error(`Heystack ingest responded ${res.status} ${res.statusText}`),
+                });
+            }
+        })
+            .catch((error) => {
+            resultCallback({
+                code: ExportResultCode.FAILED,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        });
+    }
+    shutdown() {
+        this.shutdownState = true;
+        return Promise.resolve();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+}
+/**
+ * Build a `BasicTracerProvider` wired to a `HeystackSpanExporter` via a
+ * `SimpleSpanProcessor`. Exposed for advanced users who want to add manual
+ * spans; for typical use prefer {@link instrument}.
+ *
+ * On Workers each request should get its own short-lived provider so its spans
+ * can be flushed via `ctx.waitUntil(provider.forceFlush())`.
+ */
+export function createTracerProvider(config) {
+    const exporter = new HeystackSpanExporter(config);
+    return new BasicTracerProvider({
+        resource: new Resource({ [ATTR_SERVICE_NAME]: config.service }),
+        spanProcessors: [new SimpleSpanProcessor(exporter)],
+    });
+}
+let warnedNoKey = false;
+function warnOnceNoKey() {
+    if (warnedNoKey)
+        return;
+    warnedNoKey = true;
+    console.warn("[heystack] HEYSTACK_API_KEY not set — Workers tracing disabled, handler runs untraced.");
+}
+/** Reset the once-only no-key warning. Internal/testing helper. */
+export function __resetWarnings() {
+    warnedNoKey = false;
+}
+/**
+ * Wrap a Worker's default export so every request is auto-traced with a SERVER
+ * span. The export is flushed via `ctx.waitUntil` so it completes after the
+ * response is returned.
+ *
+ *   import { instrument } from "@heystack/otel/workers";
+ *   export default instrument(
+ *     { async fetch(req, env, ctx) { return new Response("ok"); } },
+ *     { service: "my-worker" },
+ *   );
+ *
+ * If no API key is available (neither `config.apiKey` nor
+ * `env.HEYSTACK_API_KEY`), the handler runs untraced.
+ */
+export function instrument(handler, config) {
+    return {
+        async fetch(req, env, ctx) {
+            const apiKey = config.apiKey ?? env?.HEYSTACK_API_KEY;
+            // No key → run untraced (warn once).
+            if (!apiKey) {
+                warnOnceNoKey();
+                return handler.fetch(req, env, ctx);
+            }
+            const provider = createTracerProvider({
+                apiKey,
+                service: config.service,
+                endpoint: config.endpoint,
+            });
+            const tracer = provider.getTracer("@heystack/otel/workers");
+            const url = new URL(req.url);
+            const span = tracer.startSpan(`${req.method} ${url.pathname}`, {
+                kind: SpanKind.SERVER,
+                attributes: {
+                    "http.request.method": req.method,
+                    "url.full": req.url,
+                    "url.path": url.pathname,
+                    "server.address": url.host,
+                },
+            });
+            const flush = () => ctx.waitUntil(provider.forceFlush());
+            try {
+                const response = await context.with(trace.setSpan(context.active(), span), () => handler.fetch(req, env, ctx));
+                span.setAttribute("http.response.status_code", response.status);
+                span.setStatus({
+                    code: response.status >= 500 ? SpanStatusCode.ERROR : SpanStatusCode.UNSET,
+                });
+                span.end();
+                flush();
+                return response;
+            }
+            catch (error) {
+                if (error instanceof Error)
+                    span.recordException(error);
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+                span.end();
+                flush();
+                throw error;
+            }
+        },
+    };
+}

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "@heystack/otel",
-  "version": "0.0.1",
-  "description": "One-call OpenTelemetry tracing that exports to Heystack.",
+  "version": "0.1.0",
+  "description": "Runtime-aware OpenTelemetry tracing that exports to Heystack (Node, Next.js, Workers).",
   "license": "MIT",
   "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": { ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" } },
+  "main": "./dist/core.js",
+  "types": "./dist/core.d.ts",
+  "exports": {
+    ".": { "types": "./dist/core.d.ts", "import": "./dist/core.js" },
+    "./node": { "types": "./dist/node.d.ts", "import": "./dist/node.js" },
+    "./next": { "types": "./dist/next.d.ts", "import": "./dist/next.js" },
+    "./workers": { "types": "./dist/workers.d.ts", "import": "./dist/workers.js" }
+  },
   "files": ["dist", "README.md"],
   "publishConfig": { "access": "public" },
   "scripts": {
@@ -16,14 +21,18 @@
     "prepublishOnly": "pnpm build"
   },
   "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/sdk-node": "^0.57.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.57.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.55.0",
+    "@opentelemetry/sdk-trace-base": "^1.30.0",
     "@opentelemetry/resources": "^1.30.0",
     "@opentelemetry/semantic-conventions": "^1.30.0"
   },
   "devDependencies": {
     "vitest": "^2.1.0",
     "typescript": "^5.7.0",
-    "@types/node": "^22.0.0"
+    "@types/node": "^22.0.0",
+    "@cloudflare/workers-types": "^4"
   }
 }

package/dist/index.d.ts

@@ -1,22 +0,0 @@
-import { NodeSDK } from "@opentelemetry/sdk-node";
-export interface HeystackOptions {
-    /** Your Heystack ingest key (sk_live_...). */
-    apiKey: string;
-    /** The OTel service.name this app reports as (must match the app's service in Heystack). */
-    service: string;
-    /** Override the ingest endpoint (defaults to Heystack production). */
-    endpoint?: string;
-}
-export interface ExporterConfig {
-    url: string;
-    headers: {
-        Authorization: string;
-    };
-}
-/** Pure: derive the OTLP/HTTP exporter URL + auth header. Unit-tested. */
-export declare function buildExporterConfig(o: HeystackOptions): ExporterConfig;
-/**
- * Initialise Heystack OpenTelemetry tracing. Call once, as early as possible in
- * your app's entry point. Returns the started NodeSDK.
- */
-export declare function initHeystack(o: HeystackOptions): NodeSDK;

package/dist/index.js

@@ -1,21 +0,0 @@
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-const DEFAULT_ENDPOINT = "https://ingest.heystack.dev";
-/** Pure: derive the OTLP/HTTP exporter URL + auth header. Unit-tested. */
-export function buildExporterConfig(o) {
-    const base = (o.endpoint ?? DEFAULT_ENDPOINT).replace(/\/+$/, "");
-    return { url: `${base}/v1/traces`, headers: { Authorization: `Bearer ${o.apiKey}` } };
-}
-/**
- * Initialise Heystack OpenTelemetry tracing. Call once, as early as possible in
- * your app's entry point. Returns the started NodeSDK.
- */
-export function initHeystack(o) {
-    const cfg = buildExporterConfig(o);
-    const sdk = new NodeSDK({
-        serviceName: o.service,
-        traceExporter: new OTLPTraceExporter({ url: cfg.url, headers: cfg.headers }),
-    });
-    sdk.start();
-    return sdk;
-}