autotel-tanstack 1.13.24 → 1.13.26

package/dist/auto.d.ts

@@ -1,46 +1,42 @@
+export { i as instrument } from './instrument-DRR7VL63.js';
 export { functionTracingMiddleware, tracingMiddleware } from './middleware.js';
 export { traceServerFn } from './server-functions.js';
 export { traceBeforeLoad, traceLoader } from './loaders.js';
+import 'autotel';
 import './types-m5OjZJ-4.js';
 import '@opentelemetry/api';
 import '@tanstack/react-router';
 
 /**
- * Zero-config auto-instrumentation for TanStack Start
+ * Zero-config auto-instrumentation for TanStack Start.
  *
- * Import this module to automatically instrument TanStack Start applications
- * with OpenTelemetry tracing. Configuration is read from environment variables.
+ * Importing this module configures OpenTelemetry tracing from environment
+ * variables — it is simply `instrument()` with no options. For subscribers,
+ * structured logs, canonical log lines, or an explicit endpoint, call
+ * `instrument(options)` from `autotel-tanstack` directly (see ./instrument).
  *
- * Environment Variables:
+ * Environment Variables (resolved by autotel core):
  * - OTEL_SERVICE_NAME: Service name (default: 'tanstack-start')
  * - OTEL_EXPORTER_OTLP_ENDPOINT: OTLP collector URL
- * - OTEL_EXPORTER_OTLP_HEADERS: Authentication headers (key=value,key=value)
- * - AUTOTEL_DEBUG: Set to 'true' or 'pretty' to log spans to the server console
+ * - OTEL_EXPORTER_OTLP_HEADERS: Auth headers (key=value,key=value)
+ * - AUTOTEL_DEBUG: 'true' | 'pretty' to log spans to the server console
  *
  * @example
  * ```typescript
  * // app/start.ts
  * import 'autotel-tanstack/auto';
  * import { createStart } from '@tanstack/react-start';
- *
- * // Tracing is automatically configured!
  * export const startInstance = createStart(() => ({}));
  * ```
  *
  * @module
  */
 
-/**
- * Check if auto-instrumentation is active
- */
+/** Check if auto-instrumentation is active. */
 declare function isAutoInstrumentationActive(): boolean;
-/**
- * Get the configured service name
- */
+/** The configured service name. */
 declare function getServiceName(): string;
-/**
- * Get the configured endpoint
- */
+/** The configured OTLP endpoint, if any. */
 declare function getEndpoint(): string | undefined;
 
 export { getEndpoint, getServiceName, isAutoInstrumentationActive };

package/dist/auto.js

@@ -1,3 +1,5 @@
+import { instrument } from './chunk-7OXOAS64.js';
+export { instrument } from './chunk-7OXOAS64.js';
 export { functionTracingMiddleware, tracingMiddleware } from './chunk-LRA2UVVS.js';
 export { traceServerFn } from './chunk-ESU66L3L.js';
 export { traceBeforeLoad, traceLoader } from './chunk-KPXGFKPU.js';
@@ -6,62 +8,23 @@ import './chunk-CCME55EK.js';
 import './chunk-I4LX3LOG.js';
 import './chunk-NTY64BKS.js';
 import './chunk-EGRHWZRV.js';
-import { init } from 'autotel';
-import { InMemorySpanExporter } from 'autotel/exporters';
-import { SimpleSpanProcessor } from 'autotel/processors';
 
-var service = process.env.OTEL_SERVICE_NAME || "tanstack-start";
-var endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-var headers;
-if (process.env.OTEL_EXPORTER_OTLP_HEADERS) {
-  headers = {};
-  const pairs = process.env.OTEL_EXPORTER_OTLP_HEADERS.split(",");
-  for (const pair of pairs) {
-    const [key, value] = pair.split("=");
-    if (key && value) {
-      headers[key.trim()] = value.trim();
-    }
-  }
-}
-function resolveDebug() {
-  const env = process.env.AUTOTEL_DEBUG;
-  if (env === "pretty") return "pretty";
-  if (env === "true" || env === "1") return true;
-  if (env === "false" || env === "0") return false;
-  if (!endpoint && process.env.NODE_ENV === "development") return "pretty";
-  return false;
-}
-if (process.env.E2E === "1") {
-  const e2eExporter = new InMemorySpanExporter();
-  const e2eProcessor = new SimpleSpanProcessor(e2eExporter);
-  globalThis.__testSpanExporter = e2eExporter;
-  init({
-    service,
-    spanProcessors: [e2eProcessor]
-  });
-} else {
-  init({
-    service,
-    endpoint,
-    headers,
-    debug: resolveDebug()
-  });
-}
+// src/auto.ts
+instrument();
 if (process.env.NODE_ENV === "development" || process.env.AUTOTEL_DEBUG) {
-  console.log("[autotel-tanstack] Auto-initialized with:", {
-    service,
-    endpoint: process.env.E2E === "1" ? "(E2E: in-memory)" : endpoint || "(not configured)",
-    hasHeaders: !!headers
+  console.log("[autotel-tanstack] Auto-initialized", {
+    service: process.env.OTEL_SERVICE_NAME || "tanstack-start",
+    endpoint: process.env.E2E === "1" ? "(E2E: in-memory)" : process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "(not configured)"
   });
 }
 function isAutoInstrumentationActive() {
   return true;
 }
 function getServiceName() {
-  return service;
+  return process.env.OTEL_SERVICE_NAME || "tanstack-start";
 }
 function getEndpoint() {
-  return endpoint;
+  return process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
 }
 
 export { getEndpoint, getServiceName, isAutoInstrumentationActive };

package/dist/auto.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/auto.ts"],"names":[],"mappings":";;;;;;;;;;;;AA8BA,IAAM,OAAA,GAAU,OAAA,CAAQ,GAAA,CAAI,iBAAA,IAAqB,gBAAA;AAGjD,IAAM,QAAA,GAAW,QAAQ,GAAA,CAAI,2BAAA;AAG7B,IAAI,OAAA;AACJ,IAAI,OAAA,CAAQ,IAAI,0BAAA,EAA4B;AAC1C,EAAA,OAAA,GAAU,EAAC;AACX,EAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,GAAA,CAAI,0BAAA,CAA2B,MAAM,GAAG,CAAA;AAC9D,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,MAAM,CAAC,GAAA,EAAK,KAAK,CAAA,GAAI,IAAA,CAAK,MAAM,GAAG,CAAA;AACnC,IAAA,IAAI,OAAO,KAAA,EAAO;AAChB,MAAA,OAAA,CAAQ,GAAA,CAAI,IAAA,EAAM,CAAA,GAAI,MAAM,IAAA,EAAK;AAAA,IACnC;AAAA,EACF;AACF;AAIA,SAAS,YAAA,GAAmC;AAC1C,EAAA,MAAM,GAAA,GAAM,QAAQ,GAAA,CAAI,aAAA;AACxB,EAAA,IAAI,GAAA,KAAQ,UAAU,OAAO,QAAA;AAC7B,EAAA,IAAI,GAAA,KAAQ,MAAA,IAAU,GAAA,KAAQ,GAAA,EAAK,OAAO,IAAA;AAC1C,EAAA,IAAI,GAAA,KAAQ,OAAA,IAAW,GAAA,KAAQ,GAAA,EAAK,OAAO,KAAA;AAC3C,EAAA,IAAI,CAAC,QAAA,IAAY,OAAA,CAAQ,GAAA,CAAI,QAAA,KAAa,eAAe,OAAO,QAAA;AAChE,EAAA,OAAO,KAAA;AACT;AAMA,IAAI,OAAA,CAAQ,GAAA,CAAI,GAAA,KAAQ,GAAA,EAAK;AAC3B,EAAA,MAAM,WAAA,GAAc,IAAI,oBAAA,EAAqB;AAC7C,EAAA,MAAM,YAAA,GAAe,IAAI,mBAAA,CAAoB,WAAW,CAAA;AACxD,EAAC,WAAuC,kBAAA,GAAqB,WAAA;AAE7D,EAAA,IAAA,CAAK;AAAA,IACH,OAAA;AAAA,IACA,cAAA,EAAgB,CAAC,YAAY;AAAA,GAC9B,CAAA;AACH,CAAA,MAAO;AAEL,EAAA,IAAA,CAAK;AAAA,IACH,OAAA;AAAA,IACA,QAAA;AAAA,IACA,OAAA;AAAA,IACA,OAAO,YAAA;AAAa,GACrB,CAAA;AACH;AAGA,IAAI,QAAQ,GAAA,CAAI,QAAA,KAAa,aAAA,IAAiB,OAAA,CAAQ,IAAI,aAAA,EAAe;AACvE,EAAA,OAAA,CAAQ,IAAI,2CAAA,EAA6C;AAAA,IACvD,OAAA;AAAA,IACA,UACE,OAAA,CAAQ,GAAA,CAAI,GAAA,KAAQ,GAAA,GAChB,qBACA,QAAA,IAAY,kBAAA;AAAA,IAClB,UAAA,EAAY,CAAC,CAAC;AAAA,GACf,CAAA;AACH;AAUO,SAAS,2BAAA,GAAuC;AACrD,EAAA,OAAO,IAAA;AACT;AAKO,SAAS,cAAA,GAAyB;AACvC,EAAA,OAAO,OAAA;AACT;AAKO,SAAS,WAAA,GAAkC;AAChD,EAAA,OAAO,QAAA;AACT","file":"auto.js","sourcesContent":["/**\n * Zero-config auto-instrumentation for TanStack Start\n *\n * Import this module to automatically instrument TanStack Start applications\n * with OpenTelemetry tracing. Configuration is read from environment variables.\n *\n * Environment Variables:\n * - OTEL_SERVICE_NAME: Service name (default: 'tanstack-start')\n * - OTEL_EXPORTER_OTLP_ENDPOINT: OTLP collector URL\n * - OTEL_EXPORTER_OTLP_HEADERS: Authentication headers (key=value,key=value)\n * - AUTOTEL_DEBUG: Set to 'true' or 'pretty' to log spans to the server console\n *\n * @example\n * ```typescript\n * // app/start.ts\n * import 'autotel-tanstack/auto';\n * import { createStart } from '@tanstack/react-start';\n *\n * // Tracing is automatically configured!\n * export const startInstance = createStart(() => ({}));\n * ```\n *\n * @module\n */\n\nimport { init } from 'autotel';\nimport { InMemorySpanExporter } from 'autotel/exporters';\nimport { SimpleSpanProcessor } from 'autotel/processors';\n\n// Parse service name\nconst service = process.env.OTEL_SERVICE_NAME || 'tanstack-start';\n\n// Parse endpoint\nconst endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;\n\n// Parse headers\nlet headers: Record<string, string> | undefined;\nif (process.env.OTEL_EXPORTER_OTLP_HEADERS) {\n  headers = {};\n  const pairs = process.env.OTEL_EXPORTER_OTLP_HEADERS.split(',');\n  for (const pair of pairs) {\n    const [key, value] = pair.split('=');\n    if (key && value) {\n      headers[key.trim()] = value.trim();\n    }\n  }\n}\n\n// Debug: span output to server console. AUTOTEL_DEBUG=pretty | true, or default\n// to pretty in dev when no OTLP endpoint is set so you see spans immediately.\nfunction resolveDebug(): boolean | 'pretty' {\n  const env = process.env.AUTOTEL_DEBUG;\n  if (env === 'pretty') return 'pretty';\n  if (env === 'true' || env === '1') return true;\n  if (env === 'false' || env === '0') return false;\n  if (!endpoint && process.env.NODE_ENV === 'development') return 'pretty';\n  return false;\n}\n\n// E2E mode: use InMemorySpanExporter so tests can capture and assert on spans.\n// When E2E=1, skip the normal OTLP path and use in-memory storage instead.\n// Note: combined E2E + OTLP (two processors) is handled at integration level\n// because constructing an OTLP processor requires deps not available here.\nif (process.env.E2E === '1') {\n  const e2eExporter = new InMemorySpanExporter();\n  const e2eProcessor = new SimpleSpanProcessor(e2eExporter);\n  (globalThis as Record<string, unknown>).__testSpanExporter = e2eExporter;\n\n  init({\n    service,\n    spanProcessors: [e2eProcessor],\n  });\n} else {\n  // Initialize autotel (production path — unchanged)\n  init({\n    service,\n    endpoint,\n    headers,\n    debug: resolveDebug(),\n  });\n}\n\n// Log initialization (only in development)\nif (process.env.NODE_ENV === 'development' || process.env.AUTOTEL_DEBUG) {\n  console.log('[autotel-tanstack] Auto-initialized with:', {\n    service,\n    endpoint:\n      process.env.E2E === '1'\n        ? '(E2E: in-memory)'\n        : endpoint || '(not configured)',\n    hasHeaders: !!headers,\n  });\n}\n\n// Re-export middleware for convenience\nexport { tracingMiddleware, functionTracingMiddleware } from './middleware';\nexport { traceServerFn } from './server-functions';\nexport { traceLoader, traceBeforeLoad } from './loaders';\n\n/**\n * Check if auto-instrumentation is active\n */\nexport function isAutoInstrumentationActive(): boolean {\n  return true;\n}\n\n/**\n * Get the configured service name\n */\nexport function getServiceName(): string {\n  return service;\n}\n\n/**\n * Get the configured endpoint\n */\nexport function getEndpoint(): string | undefined {\n  return endpoint;\n}\n"]}
+{"version":3,"sources":["../src/auto.ts"],"names":[],"mappings":";;;;;;;;;;;;AA2BA,UAAA,EAAW;AAGX,IAAI,QAAQ,GAAA,CAAI,QAAA,KAAa,aAAA,IAAiB,OAAA,CAAQ,IAAI,aAAA,EAAe;AACvE,EAAA,OAAA,CAAQ,IAAI,qCAAA,EAAuC;AAAA,IACjD,OAAA,EAAS,OAAA,CAAQ,GAAA,CAAI,iBAAA,IAAqB,gBAAA;AAAA,IAC1C,QAAA,EACE,QAAQ,GAAA,CAAI,GAAA,KAAQ,MAChB,kBAAA,GACA,OAAA,CAAQ,IAAI,2BAAA,IAA+B;AAAA,GAClD,CAAA;AACH;AASO,SAAS,2BAAA,GAAuC;AACrD,EAAA,OAAO,IAAA;AACT;AAGO,SAAS,cAAA,GAAyB;AACvC,EAAA,OAAO,OAAA,CAAQ,IAAI,iBAAA,IAAqB,gBAAA;AAC1C;AAGO,SAAS,WAAA,GAAkC;AAChD,EAAA,OAAO,QAAQ,GAAA,CAAI,2BAAA;AACrB","file":"auto.js","sourcesContent":["/**\n * Zero-config auto-instrumentation for TanStack Start.\n *\n * Importing this module configures OpenTelemetry tracing from environment\n * variables — it is simply `instrument()` with no options. For subscribers,\n * structured logs, canonical log lines, or an explicit endpoint, call\n * `instrument(options)` from `autotel-tanstack` directly (see ./instrument).\n *\n * Environment Variables (resolved by autotel core):\n * - OTEL_SERVICE_NAME: Service name (default: 'tanstack-start')\n * - OTEL_EXPORTER_OTLP_ENDPOINT: OTLP collector URL\n * - OTEL_EXPORTER_OTLP_HEADERS: Auth headers (key=value,key=value)\n * - AUTOTEL_DEBUG: 'true' | 'pretty' to log spans to the server console\n *\n * @example\n * ```typescript\n * // app/start.ts\n * import 'autotel-tanstack/auto';\n * import { createStart } from '@tanstack/react-start';\n * export const startInstance = createStart(() => ({}));\n * ```\n *\n * @module\n */\n\nimport { instrument } from './instrument';\n\ninstrument();\n\n// Surface what happened, in development only.\nif (process.env.NODE_ENV === 'development' || process.env.AUTOTEL_DEBUG) {\n  console.log('[autotel-tanstack] Auto-initialized', {\n    service: process.env.OTEL_SERVICE_NAME || 'tanstack-start',\n    endpoint:\n      process.env.E2E === '1'\n        ? '(E2E: in-memory)'\n        : process.env.OTEL_EXPORTER_OTLP_ENDPOINT || '(not configured)',\n  });\n}\n\n// Re-export the configurable form + middleware/helpers for convenience.\nexport { instrument } from './instrument';\nexport { tracingMiddleware, functionTracingMiddleware } from './middleware';\nexport { traceServerFn } from './server-functions';\nexport { traceLoader, traceBeforeLoad } from './loaders';\n\n/** Check if auto-instrumentation is active. */\nexport function isAutoInstrumentationActive(): boolean {\n  return true;\n}\n\n/** The configured service name. */\nexport function getServiceName(): string {\n  return process.env.OTEL_SERVICE_NAME || 'tanstack-start';\n}\n\n/** The configured OTLP endpoint, if any. */\nexport function getEndpoint(): string | undefined {\n  return process.env.OTEL_EXPORTER_OTLP_ENDPOINT;\n}\n"]}

package/dist/chunk-7OXOAS64.js

@@ -0,0 +1,41 @@
+import { isInitialized, init } from 'autotel';
+import { InMemorySpanExporter } from 'autotel/exporters';
+import { SimpleSpanProcessor } from 'autotel/processors';
+
+// src/instrument.ts
+var DEFAULT_SERVICE = "tanstack-start";
+function resolveDebug(explicit, endpoint) {
+  if (explicit !== void 0) return explicit;
+  const env = process.env.AUTOTEL_DEBUG;
+  if (env === "pretty") return "pretty";
+  if (env === "true" || env === "1") return true;
+  if (env === "false" || env === "0") return false;
+  if (!endpoint && process.env.NODE_ENV === "development") return "pretty";
+  return false;
+}
+function instrument(options = {}) {
+  if (isInitialized()) return;
+  const service = options.service ?? process.env.OTEL_SERVICE_NAME ?? DEFAULT_SERVICE;
+  if (process.env.E2E === "1") {
+    const exporter = new InMemorySpanExporter();
+    globalThis.__testSpanExporter = exporter;
+    init({
+      service,
+      subscribers: options.subscribers,
+      spanProcessors: [
+        new SimpleSpanProcessor(exporter),
+        ...options.spanProcessors ?? []
+      ]
+    });
+    return;
+  }
+  init({
+    ...options,
+    service,
+    debug: resolveDebug(options.debug, options.endpoint)
+  });
+}
+
+export { instrument };
+//# sourceMappingURL=chunk-7OXOAS64.js.map
+//# sourceMappingURL=chunk-7OXOAS64.js.map

package/dist/chunk-7OXOAS64.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/instrument.ts"],"names":[],"mappings":";;;;;AAgDA,IAAM,eAAA,GAAkB,gBAAA;AAOxB,SAAS,YAAA,CACP,UACA,QAAA,EACoB;AACpB,EAAA,IAAI,QAAA,KAAa,QAAW,OAAO,QAAA;AACnC,EAAA,MAAM,GAAA,GAAM,QAAQ,GAAA,CAAI,aAAA;AACxB,EAAA,IAAI,GAAA,KAAQ,UAAU,OAAO,QAAA;AAC7B,EAAA,IAAI,GAAA,KAAQ,MAAA,IAAU,GAAA,KAAQ,GAAA,EAAK,OAAO,IAAA;AAC1C,EAAA,IAAI,GAAA,KAAQ,OAAA,IAAW,GAAA,KAAQ,GAAA,EAAK,OAAO,KAAA;AAC3C,EAAA,IAAI,CAAC,QAAA,IAAY,OAAA,CAAQ,GAAA,CAAI,QAAA,KAAa,eAAe,OAAO,QAAA;AAChE,EAAA,OAAO,KAAA;AACT;AAEO,SAAS,UAAA,CAAW,OAAA,GAA6B,EAAC,EAAS;AAGhE,EAAA,IAAI,eAAc,EAAG;AAErB,EAAA,MAAM,OAAA,GACJ,OAAA,CAAQ,OAAA,IAAW,OAAA,CAAQ,IAAI,iBAAA,IAAqB,eAAA;AAEtD,EAAA,IAAI,OAAA,CAAQ,GAAA,CAAI,GAAA,KAAQ,GAAA,EAAK;AAE3B,IAAA,MAAM,QAAA,GAAW,IAAI,oBAAA,EAAqB;AAC1C,IAAC,WAAuC,kBAAA,GAAqB,QAAA;AAC7D,IAAA,IAAA,CAAK;AAAA,MACH,OAAA;AAAA,MACA,aAAa,OAAA,CAAQ,WAAA;AAAA,MACrB,cAAA,EAAgB;AAAA,QACd,IAAI,oBAAoB,QAAQ,CAAA;AAAA,QAChC,GAAI,OAAA,CAAQ,cAAA,IAAkB;AAAC;AACjC,KACD,CAAA;AACD,IAAA;AAAA,EACF;AAEA,EAAA,IAAA,CAAK;AAAA,IACH,GAAG,OAAA;AAAA,IACH,OAAA;AAAA,IACA,KAAA,EAAO,YAAA,CAAa,OAAA,CAAQ,KAAA,EAAO,QAAQ,QAAQ;AAAA,GACpD,CAAA;AACH","file":"chunk-7OXOAS64.js","sourcesContent":["/**\n * Configurable tracing setup for TanStack Start.\n *\n * `instrument(options)` is a thin wrapper over autotel's `init` that adds the\n * TanStack defaults so apps don't hand-roll them:\n *\n * - service name defaults to `OTEL_SERVICE_NAME` or `'tanstack-start'`;\n * - `debug` resolves from `AUTOTEL_DEBUG` (`pretty` in dev when no endpoint set);\n * - when `E2E=1`, spans are captured by an `InMemorySpanExporter` exposed as\n *   `globalThis.__testSpanExporter` (for span assertions) instead of shipping\n *   over OTLP;\n * - it's idempotent — a second call is a no-op.\n *\n * Everything else — `endpoint`, `headers`, `subscribers`, `logs`,\n * `canonicalLogLines`, extra `spanProcessors`, … — passes straight through to\n * `init`, and the standard `OTEL_*` env vars are resolved by autotel core, so\n * apps never re-parse them.\n *\n * The zero-config `autotel-tanstack/auto` side-effect module is just\n * `instrument()` with no options.\n *\n * @example\n * ```ts\n * import { instrument } from 'autotel-tanstack';\n * import { PostHogSubscriber } from 'autotel-subscribers';\n *\n * instrument({\n *   subscribers: process.env.POSTHOG_KEY\n *     ? [new PostHogSubscriber({ apiKey: process.env.POSTHOG_KEY })]\n *     : [],\n *   logs: true,\n *   canonicalLogLines: { enabled: true, rootSpansOnly: true },\n * });\n * ```\n *\n * @module\n */\n\nimport { init, isInitialized, type AutotelConfig } from 'autotel';\nimport { InMemorySpanExporter } from 'autotel/exporters';\nimport { SimpleSpanProcessor } from 'autotel/processors';\n\n// `service` is optional here — instrument() defaults it to OTEL_SERVICE_NAME or\n// 'tanstack-start'. Everything else matches autotel's init config.\nexport type InstrumentOptions = Omit<AutotelConfig, 'service'> & {\n  service?: string;\n};\n\nconst DEFAULT_SERVICE = 'tanstack-start';\n\n/**\n * Resolve span-debug output: an explicit option wins; otherwise `AUTOTEL_DEBUG`\n * (`pretty` | `true`/`1` | `false`/`0`); otherwise pretty-print in development\n * when there's no OTLP endpoint, so spans are visible immediately.\n */\nfunction resolveDebug(\n  explicit: AutotelConfig['debug'],\n  endpoint: string | undefined,\n): boolean | 'pretty' {\n  if (explicit !== undefined) return explicit;\n  const env = process.env.AUTOTEL_DEBUG;\n  if (env === 'pretty') return 'pretty';\n  if (env === 'true' || env === '1') return true;\n  if (env === 'false' || env === '0') return false;\n  if (!endpoint && process.env.NODE_ENV === 'development') return 'pretty';\n  return false;\n}\n\nexport function instrument(options: InstrumentOptions = {}): void {\n  // Idempotent: tolerate the instrumentation module being evaluated more than\n  // once (HMR, multiple entry points) without re-initializing.\n  if (isInitialized()) return;\n\n  const service =\n    options.service ?? process.env.OTEL_SERVICE_NAME ?? DEFAULT_SERVICE;\n\n  if (process.env.E2E === '1') {\n    // Capture spans in memory for test assertions; skip OTLP/logs entirely.\n    const exporter = new InMemorySpanExporter();\n    (globalThis as Record<string, unknown>).__testSpanExporter = exporter;\n    init({\n      service,\n      subscribers: options.subscribers,\n      spanProcessors: [\n        new SimpleSpanProcessor(exporter),\n        ...(options.spanProcessors ?? []),\n      ],\n    });\n    return;\n  }\n\n  init({\n    ...options,\n    service,\n    debug: resolveDebug(options.debug, options.endpoint),\n  });\n}\n"]}

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export { createTracedHeaders, extractContextFromRequest, getActiveContext, injec
 export { DebugHeadersConfig, debugHeadersMiddleware } from './debug-headers.js';
 export { TimingStats, createMetricsHandler, metricsCollector, recordTiming } from './metrics.js';
 export { ErrorReport, createErrorReportingHandler, errorStore, reportError, withErrorReporting } from './error-reporting.js';
+export { I as InstrumentOptions, i as instrument } from './instrument-DRR7VL63.js';
 export { flush, init, shutdown, span, trace } from 'autotel';
 import '@opentelemetry/api';
 import '@tanstack/react-router';

package/dist/index.js

@@ -1,6 +1,7 @@
 export { debugHeadersMiddleware } from './chunk-UTPW3QRT.js';
 export { createMetricsHandler, metricsCollector, recordTiming } from './chunk-G526TOMY.js';
 export { createErrorReportingHandler, errorStore, reportError, withErrorReporting } from './chunk-XXBHZR3M.js';
+export { instrument } from './chunk-7OXOAS64.js';
 export { createTracingMiddleware, createTracingServerHandler, functionTracingMiddleware, tracingMiddleware } from './chunk-LRA2UVVS.js';
 export { createTracedServerFnFactory, traceServerFn } from './chunk-ESU66L3L.js';
 export { createTracedRoute, traceBeforeLoad, traceLoader } from './chunk-KPXGFKPU.js';

package/dist/instrument-DRR7VL63.d.ts

@@ -0,0 +1,46 @@
+import { AutotelConfig } from 'autotel';
+
+/**
+ * Configurable tracing setup for TanStack Start.
+ *
+ * `instrument(options)` is a thin wrapper over autotel's `init` that adds the
+ * TanStack defaults so apps don't hand-roll them:
+ *
+ * - service name defaults to `OTEL_SERVICE_NAME` or `'tanstack-start'`;
+ * - `debug` resolves from `AUTOTEL_DEBUG` (`pretty` in dev when no endpoint set);
+ * - when `E2E=1`, spans are captured by an `InMemorySpanExporter` exposed as
+ *   `globalThis.__testSpanExporter` (for span assertions) instead of shipping
+ *   over OTLP;
+ * - it's idempotent — a second call is a no-op.
+ *
+ * Everything else — `endpoint`, `headers`, `subscribers`, `logs`,
+ * `canonicalLogLines`, extra `spanProcessors`, … — passes straight through to
+ * `init`, and the standard `OTEL_*` env vars are resolved by autotel core, so
+ * apps never re-parse them.
+ *
+ * The zero-config `autotel-tanstack/auto` side-effect module is just
+ * `instrument()` with no options.
+ *
+ * @example
+ * ```ts
+ * import { instrument } from 'autotel-tanstack';
+ * import { PostHogSubscriber } from 'autotel-subscribers';
+ *
+ * instrument({
+ *   subscribers: process.env.POSTHOG_KEY
+ *     ? [new PostHogSubscriber({ apiKey: process.env.POSTHOG_KEY })]
+ *     : [],
+ *   logs: true,
+ *   canonicalLogLines: { enabled: true, rootSpansOnly: true },
+ * });
+ * ```
+ *
+ * @module
+ */
+
+type InstrumentOptions = Omit<AutotelConfig, 'service'> & {
+    service?: string;
+};
+declare function instrument(options?: InstrumentOptions): void;
+
+export { type InstrumentOptions as I, instrument as i };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-tanstack",
-  "version": "1.13.24",
+  "version": "1.13.26",
   "description": "OpenTelemetry instrumentation for TanStack Start - automatic tracing for server functions, middleware, and route loaders",
   "type": "module",
   "main": "./dist/index.js",
@@ -120,8 +120,8 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "autotel": "3.4.0",
-    "autotel-adapters": "0.3.2",
+    "autotel": "3.4.2",
+    "autotel-adapters": "0.3.4",
     "autotel-edge": "3.16.12"
   },
   "peerDependencies": {

package/src/auto.test.ts

@@ -7,6 +7,8 @@ const mockGetFinishedSpans = vi.fn(() => []);
 
 vi.mock('autotel', () => ({
   init: mockInit,
+  // instrument() guards on this; false so every test proceeds to init().
+  isInitialized: vi.fn(() => false),
 }));
 
 const mockExporterInstance = {
@@ -85,15 +87,20 @@ describe('auto.ts E2E mode', () => {
     expect(call.spanProcessors).toHaveLength(2);
   });
 
-  it('passes endpoint and debug to init in production mode', async () => {
+  it('initializes in production mode without injecting an in-memory processor', async () => {
+    // The OTLP endpoint/headers are resolved by autotel core from env, so the
+    // zero-config path no longer passes them explicitly — it just inits.
     delete process.env.E2E;
     process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://localhost:4318';
     await import('./auto');
-    expect(mockInit).toHaveBeenCalledWith(
-      expect.objectContaining({
-        endpoint: 'http://localhost:4318',
-      }),
-    );
+    expect(mockInit).toHaveBeenCalledOnce();
+    const call = mockInit.mock.calls[0][0] as {
+      spanProcessors?: unknown[];
+      service?: string;
+    };
+    expect(call.spanProcessors).toBeUndefined();
+    expect(call.service).toBe('tanstack-start');
+    expect(MockInMemorySpanExporter).not.toHaveBeenCalled();
   });
 
   it('uses OTEL_SERVICE_NAME env var', async () => {

package/src/auto.ts

@@ -1,119 +1,60 @@
 /**
- * Zero-config auto-instrumentation for TanStack Start
+ * Zero-config auto-instrumentation for TanStack Start.
  *
- * Import this module to automatically instrument TanStack Start applications
- * with OpenTelemetry tracing. Configuration is read from environment variables.
+ * Importing this module configures OpenTelemetry tracing from environment
+ * variables — it is simply `instrument()` with no options. For subscribers,
+ * structured logs, canonical log lines, or an explicit endpoint, call
+ * `instrument(options)` from `autotel-tanstack` directly (see ./instrument).
  *
- * Environment Variables:
+ * Environment Variables (resolved by autotel core):
  * - OTEL_SERVICE_NAME: Service name (default: 'tanstack-start')
  * - OTEL_EXPORTER_OTLP_ENDPOINT: OTLP collector URL
- * - OTEL_EXPORTER_OTLP_HEADERS: Authentication headers (key=value,key=value)
- * - AUTOTEL_DEBUG: Set to 'true' or 'pretty' to log spans to the server console
+ * - OTEL_EXPORTER_OTLP_HEADERS: Auth headers (key=value,key=value)
+ * - AUTOTEL_DEBUG: 'true' | 'pretty' to log spans to the server console
  *
  * @example
  * ```typescript
  * // app/start.ts
  * import 'autotel-tanstack/auto';
  * import { createStart } from '@tanstack/react-start';
- *
- * // Tracing is automatically configured!
  * export const startInstance = createStart(() => ({}));
  * ```
  *
  * @module
  */
 
-import { init } from 'autotel';
-import { InMemorySpanExporter } from 'autotel/exporters';
-import { SimpleSpanProcessor } from 'autotel/processors';
-
-// Parse service name
-const service = process.env.OTEL_SERVICE_NAME || 'tanstack-start';
+import { instrument } from './instrument';
 
-// Parse endpoint
-const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+instrument();
 
-// Parse headers
-let headers: Record<string, string> | undefined;
-if (process.env.OTEL_EXPORTER_OTLP_HEADERS) {
-  headers = {};
-  const pairs = process.env.OTEL_EXPORTER_OTLP_HEADERS.split(',');
-  for (const pair of pairs) {
-    const [key, value] = pair.split('=');
-    if (key && value) {
-      headers[key.trim()] = value.trim();
-    }
-  }
-}
-
-// Debug: span output to server console. AUTOTEL_DEBUG=pretty | true, or default
-// to pretty in dev when no OTLP endpoint is set so you see spans immediately.
-function resolveDebug(): boolean | 'pretty' {
-  const env = process.env.AUTOTEL_DEBUG;
-  if (env === 'pretty') return 'pretty';
-  if (env === 'true' || env === '1') return true;
-  if (env === 'false' || env === '0') return false;
-  if (!endpoint && process.env.NODE_ENV === 'development') return 'pretty';
-  return false;
-}
-
-// E2E mode: use InMemorySpanExporter so tests can capture and assert on spans.
-// When E2E=1, skip the normal OTLP path and use in-memory storage instead.
-// Note: combined E2E + OTLP (two processors) is handled at integration level
-// because constructing an OTLP processor requires deps not available here.
-if (process.env.E2E === '1') {
-  const e2eExporter = new InMemorySpanExporter();
-  const e2eProcessor = new SimpleSpanProcessor(e2eExporter);
-  (globalThis as Record<string, unknown>).__testSpanExporter = e2eExporter;
-
-  init({
-    service,
-    spanProcessors: [e2eProcessor],
-  });
-} else {
-  // Initialize autotel (production path — unchanged)
-  init({
-    service,
-    endpoint,
-    headers,
-    debug: resolveDebug(),
-  });
-}
-
-// Log initialization (only in development)
+// Surface what happened, in development only.
 if (process.env.NODE_ENV === 'development' || process.env.AUTOTEL_DEBUG) {
-  console.log('[autotel-tanstack] Auto-initialized with:', {
-    service,
+  console.log('[autotel-tanstack] Auto-initialized', {
+    service: process.env.OTEL_SERVICE_NAME || 'tanstack-start',
     endpoint:
       process.env.E2E === '1'
         ? '(E2E: in-memory)'
-        : endpoint || '(not configured)',
-    hasHeaders: !!headers,
+        : process.env.OTEL_EXPORTER_OTLP_ENDPOINT || '(not configured)',
   });
 }
 
-// Re-export middleware for convenience
+// Re-export the configurable form + middleware/helpers for convenience.
+export { instrument } from './instrument';
 export { tracingMiddleware, functionTracingMiddleware } from './middleware';
 export { traceServerFn } from './server-functions';
 export { traceLoader, traceBeforeLoad } from './loaders';
 
-/**
- * Check if auto-instrumentation is active
- */
+/** Check if auto-instrumentation is active. */
 export function isAutoInstrumentationActive(): boolean {
   return true;
 }
 
-/**
- * Get the configured service name
- */
+/** The configured service name. */
 export function getServiceName(): string {
-  return service;
+  return process.env.OTEL_SERVICE_NAME || 'tanstack-start';
 }
 
-/**
- * Get the configured endpoint
- */
+/** The configured OTLP endpoint, if any. */
 export function getEndpoint(): string | undefined {
-  return endpoint;
+  return process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
 }

package/src/index.ts

@@ -84,6 +84,10 @@ export {
   type ErrorReport,
 } from './error-reporting';
 
+// Configurable TanStack Start tracing setup (the configurable form of the
+// zero-config `autotel-tanstack/auto` import).
+export { instrument, type InstrumentOptions } from './instrument';
+
 // Re-export autotel core utilities for convenience
 // Note: These should only be used on the server side
 // They use Node.js APIs (AsyncLocalStorage) that don't exist in the browser

package/src/instrument.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Hoisted so the values exist when the (also-hoisted) vi.mock factories run,
+// since instrument is imported statically below.
+const {
+  mockInit,
+  mockIsInitialized,
+  mockExporter,
+  MockInMemorySpanExporter,
+  MockSimpleSpanProcessor,
+} = vi.hoisted(() => {
+  const exporter = { reset: vi.fn(), getFinishedSpans: vi.fn(() => []) };
+  return {
+    mockInit: vi.fn(),
+    mockIsInitialized: vi.fn(() => false),
+    mockExporter: exporter,
+    MockInMemorySpanExporter: vi.fn(function () {
+      return exporter;
+    }),
+    MockSimpleSpanProcessor: vi.fn(function (exp: unknown) {
+      return { exporter: exp };
+    }),
+  };
+});
+
+vi.mock('autotel', () => ({
+  init: mockInit,
+  isInitialized: mockIsInitialized,
+}));
+vi.mock('autotel/exporters', () => ({
+  InMemorySpanExporter: MockInMemorySpanExporter,
+}));
+vi.mock('autotel/processors', () => ({
+  SimpleSpanProcessor: MockSimpleSpanProcessor,
+}));
+
+import { instrument } from './instrument';
+
+type InitCall = {
+  service?: string;
+  endpoint?: string;
+  debug?: boolean | 'pretty';
+  logs?: unknown;
+  subscribers?: unknown;
+  spanProcessors?: unknown[];
+};
+const lastInit = () => mockInit.mock.calls[0][0] as InitCall;
+
+describe('instrument()', () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    mockInit.mockReset();
+    mockIsInitialized.mockReturnValue(false);
+    MockInMemorySpanExporter.mockClear();
+    MockSimpleSpanProcessor.mockClear();
+    delete (globalThis as Record<string, unknown>).__testSpanExporter;
+    delete process.env.E2E;
+    delete process.env.AUTOTEL_DEBUG;
+    delete process.env.OTEL_SERVICE_NAME;
+    delete process.env.NODE_ENV;
+  });
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  it('is idempotent — does nothing when already initialized', () => {
+    mockIsInitialized.mockReturnValue(true);
+    instrument({ service: 'x' });
+    expect(mockInit).not.toHaveBeenCalled();
+  });
+
+  it('defaults the service name to tanstack-start', () => {
+    instrument();
+    expect(lastInit().service).toBe('tanstack-start');
+  });
+
+  it('prefers an explicit service over OTEL_SERVICE_NAME', () => {
+    process.env.OTEL_SERVICE_NAME = 'from-env';
+    instrument({ service: 'explicit' });
+    expect(lastInit().service).toBe('explicit');
+  });
+
+  it('falls back to OTEL_SERVICE_NAME', () => {
+    process.env.OTEL_SERVICE_NAME = 'from-env';
+    instrument();
+    expect(lastInit().service).toBe('from-env');
+  });
+
+  it('passes options straight through to init in normal mode', () => {
+    const subscribers = [{ name: 'sub' } as never];
+    instrument({
+      endpoint: 'http://collector:4318',
+      subscribers,
+      logs: true,
+    });
+    const call = lastInit();
+    expect(call.endpoint).toBe('http://collector:4318');
+    expect(call.subscribers).toBe(subscribers);
+    expect(call.logs).toBe(true);
+    expect(call.spanProcessors).toBeUndefined();
+  });
+
+  it('resolves debug from AUTOTEL_DEBUG', () => {
+    process.env.AUTOTEL_DEBUG = 'pretty';
+    instrument({ endpoint: 'http://c:4318' });
+    expect(lastInit().debug).toBe('pretty');
+  });
+
+  it('pretty-prints in dev when no endpoint is set', () => {
+    process.env.NODE_ENV = 'development';
+    instrument();
+    expect(lastInit().debug).toBe('pretty');
+  });
+
+  it('captures spans in memory under E2E=1 and skips OTLP + logs', () => {
+    process.env.E2E = '1';
+    const subscribers = [{ name: 'sub' } as never];
+    instrument({ endpoint: 'http://c:4318', subscribers, logs: true });
+
+    expect(MockInMemorySpanExporter).toHaveBeenCalledOnce();
+    const call = lastInit();
+    expect(call.spanProcessors).toHaveLength(1);
+    expect(call.endpoint).toBeUndefined(); // no OTLP shipping in tests
+    expect(call.logs).toBeUndefined(); // logs off in E2E
+    expect(call.subscribers).toBe(subscribers); // subscribers still flow
+    expect((globalThis as Record<string, unknown>).__testSpanExporter).toBe(
+      mockExporter,
+    );
+  });
+});

package/src/instrument.ts

@@ -0,0 +1,97 @@
+/**
+ * Configurable tracing setup for TanStack Start.
+ *
+ * `instrument(options)` is a thin wrapper over autotel's `init` that adds the
+ * TanStack defaults so apps don't hand-roll them:
+ *
+ * - service name defaults to `OTEL_SERVICE_NAME` or `'tanstack-start'`;
+ * - `debug` resolves from `AUTOTEL_DEBUG` (`pretty` in dev when no endpoint set);
+ * - when `E2E=1`, spans are captured by an `InMemorySpanExporter` exposed as
+ *   `globalThis.__testSpanExporter` (for span assertions) instead of shipping
+ *   over OTLP;
+ * - it's idempotent — a second call is a no-op.
+ *
+ * Everything else — `endpoint`, `headers`, `subscribers`, `logs`,
+ * `canonicalLogLines`, extra `spanProcessors`, … — passes straight through to
+ * `init`, and the standard `OTEL_*` env vars are resolved by autotel core, so
+ * apps never re-parse them.
+ *
+ * The zero-config `autotel-tanstack/auto` side-effect module is just
+ * `instrument()` with no options.
+ *
+ * @example
+ * ```ts
+ * import { instrument } from 'autotel-tanstack';
+ * import { PostHogSubscriber } from 'autotel-subscribers';
+ *
+ * instrument({
+ *   subscribers: process.env.POSTHOG_KEY
+ *     ? [new PostHogSubscriber({ apiKey: process.env.POSTHOG_KEY })]
+ *     : [],
+ *   logs: true,
+ *   canonicalLogLines: { enabled: true, rootSpansOnly: true },
+ * });
+ * ```
+ *
+ * @module
+ */
+
+import { init, isInitialized, type AutotelConfig } from 'autotel';
+import { InMemorySpanExporter } from 'autotel/exporters';
+import { SimpleSpanProcessor } from 'autotel/processors';
+
+// `service` is optional here — instrument() defaults it to OTEL_SERVICE_NAME or
+// 'tanstack-start'. Everything else matches autotel's init config.
+export type InstrumentOptions = Omit<AutotelConfig, 'service'> & {
+  service?: string;
+};
+
+const DEFAULT_SERVICE = 'tanstack-start';
+
+/**
+ * Resolve span-debug output: an explicit option wins; otherwise `AUTOTEL_DEBUG`
+ * (`pretty` | `true`/`1` | `false`/`0`); otherwise pretty-print in development
+ * when there's no OTLP endpoint, so spans are visible immediately.
+ */
+function resolveDebug(
+  explicit: AutotelConfig['debug'],
+  endpoint: string | undefined,
+): boolean | 'pretty' {
+  if (explicit !== undefined) return explicit;
+  const env = process.env.AUTOTEL_DEBUG;
+  if (env === 'pretty') return 'pretty';
+  if (env === 'true' || env === '1') return true;
+  if (env === 'false' || env === '0') return false;
+  if (!endpoint && process.env.NODE_ENV === 'development') return 'pretty';
+  return false;
+}
+
+export function instrument(options: InstrumentOptions = {}): void {
+  // Idempotent: tolerate the instrumentation module being evaluated more than
+  // once (HMR, multiple entry points) without re-initializing.
+  if (isInitialized()) return;
+
+  const service =
+    options.service ?? process.env.OTEL_SERVICE_NAME ?? DEFAULT_SERVICE;
+
+  if (process.env.E2E === '1') {
+    // Capture spans in memory for test assertions; skip OTLP/logs entirely.
+    const exporter = new InMemorySpanExporter();
+    (globalThis as Record<string, unknown>).__testSpanExporter = exporter;
+    init({
+      service,
+      subscribers: options.subscribers,
+      spanProcessors: [
+        new SimpleSpanProcessor(exporter),
+        ...(options.spanProcessors ?? []),
+      ],
+    });
+    return;
+  }
+
+  init({
+    ...options,
+    service,
+    debug: resolveDebug(options.debug, options.endpoint),
+  });
+}