@lmnr-ai/lmnr 0.7.13-alpha.1 → 0.8.0-alpha.1

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { S as TracingLevel, _ as MaskInputOptions, a as HumanEvaluator, b as SpanType, c as EvaluationDataset, d as StringUUID, f as Dataset, g as LaminarSpanContext, h as Event, i as EvaluatorFunctionReturn, l as LaminarDataset, m as EvaluationDatapointDatasetLink, o as evaluate, p as EvaluationDatapoint, r as EvaluatorFunction, s as InitializeOptions, t as Datapoint, u as LaminarClient, v as PushDatapointsResponse, x as TraceType, y as SessionRecordingOptions } from "./evaluations-C6jDSeZI.cjs";
+import { S as TracingLevel, _ as MaskInputOptions, a as HumanEvaluator, b as SpanType, c as EvaluationDataset, d as StringUUID, f as Dataset, g as LaminarSpanContext, h as Event, i as EvaluatorFunctionReturn, l as LaminarDataset, m as EvaluationDatapointDatasetLink, o as evaluate, p as EvaluationDatapoint, r as EvaluatorFunction, s as InitializeOptions, t as Datapoint, u as LaminarClient, v as PushDatapointsResponse, x as TraceType, y as SessionRecordingOptions } from "./evaluations-BE5hm0RG.cjs";
 import { AttributeValue, Context, Span, Span as Span$1, TimeInput, Tracer, TracerProvider } from "@opentelemetry/api";
 import { ReadableSpan, Span as Span$2, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
 import * as AI from "ai";
@@ -60,7 +60,7 @@ declare function observe<A extends unknown[], F extends (...args: A) => ReturnTy
   parentSpanContext,
   metadata,
   tags
-}: ObserveOptions, fn: F, ...args: A): Promise<ReturnType<F>>;
+}: ObserveOptions, fn: F, ...args: A): ReturnType<F>;
 /**
  * Sets the tracing level for any spans inside the function. This is useful for
  * conditionally disabling the tracing for certain functions.
@@ -83,6 +83,12 @@ declare function observe<A extends unknown[], F extends (...args: A) => ReturnTy
 declare function withTracingLevel<A extends unknown[], F extends (...args: A) => ReturnType<F>>(tracingLevel: TracingLevel, fn: F, ...args: A): ReturnType<F>;
 /**
  * Decorator that wraps a method to automatically observe it with Laminar tracing.
+ * This decorator uses the TypeScript 5.0+ standard decorator syntax.
+ *
+ * **Important**: Use this decorator only if your `tsconfig.json` does NOT have
+ * `experimentalDecorators: true`. If you're using experimental decorators, use
+ * {@link observeExperimentalDecorator} instead.
+ *
  * This decorator can be used on class methods to automatically create spans.
  *
  * @param config - Configuration for the observe decorator, can be static or a function
@@ -90,6 +96,13 @@ declare function withTracingLevel<A extends unknown[], F extends (...args: A) =>
  *
  * @example
  * ```typescript
+ * // In your tsconfig.json, ensure experimentalDecorators is NOT enabled:
+ * // {
+ * //   "compilerOptions": {
+ * //     "experimentalDecorators": false  // or omit this line
+ * //   }
+ * // }
+ *
  * import { observeDecorator } from '@lmnr-ai/lmnr';
  *
  * class MyService {
@@ -109,7 +122,53 @@ declare function withTracingLevel<A extends unknown[], F extends (...args: A) =>
  * }
  * ```
  */
-declare function observeDecorator(config: Partial<ObserveOptions> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<ObserveOptions>)): (_target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function observeDecorator<This, Args extends unknown[], Return>(config: Partial<ObserveOptions> | ((thisArg: This, ...funcArgs: Args) => Partial<ObserveOptions>)): (originalMethod: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => (this: This, ...args: Args) => Return;
+/**
+ * Decorator that wraps a method to automatically observe it with Laminar tracing.
+ * This decorator uses the legacy experimental decorator syntax
+ * (requires `--experimentalDecorators` flag).
+ *
+ * **Important**: Use this decorator only if your `tsconfig.json` has
+ * `experimentalDecorators: true` in the `compilerOptions` section
+ * (or if you compile with the `--experimentalDecorators` flag).
+ * For TypeScript 5.0+ projects without experimental decorators, use
+ * {@link observeDecorator} instead.
+ *
+ * This decorator can be used on class methods to automatically create spans.
+ *
+ * Use this only if you need the legacy experimental decorator syntax.
+ * @param config - Configuration for the observe decorator, can be static or a function
+ * @returns A method decorator
+ *
+ * @example
+ * ```typescript
+ * // In your tsconfig.json, ensure experimentalDecorators is enabled:
+ * // {
+ * //   "compilerOptions": {
+ * //     "experimentalDecorators": true
+ * //   }
+ * // }
+ *
+ * import { observeExperimentalDecorator } from '@lmnr-ai/lmnr';
+ *
+ * class MyService {
+ *   @observeExperimentalDecorator({ name: 'processData', spanType: 'DEFAULT' })
+ *   async processData(input: string) {
+ *     // Your code here
+ *     return `processed: ${input}`;
+ *   }
+ *
+ *   @observeExperimentalDecorator((thisArg, ...args) => ({
+ *     name: `dynamicMethod_${args[0]}`,
+ *     sessionId: thisArg.sessionId
+ *   }))
+ *   async dynamicMethod(id: string) {
+ *     // Your code here
+ *   }
+ * }
+ * ```
+ */
+declare function observeExperimentalDecorator(config: Partial<ObserveOptions> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<ObserveOptions>)): (_target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
 //#endregion
 //#region src/opentelemetry-lib/tracing/processor.d.ts
 interface LaminarSpanProcessorOptions {
@@ -155,6 +214,11 @@ interface LaminarSpanProcessorOptions {
    * Defaults to a new LaminarSpanExporter.
    */
   exporter?: SpanExporter;
+  /**
+   * The span processor to use. If passed, some of the other options will be ignored.
+   * If passed, wraps the underlying span processor.
+   */
+  spanProcessor?: SpanProcessor;
 }
 declare class LaminarSpanProcessor implements SpanProcessor {
   private instance;
@@ -221,6 +285,7 @@ interface LaminarInitializeProps {
   sessionRecordingOptions?: SessionRecordingOptions;
   metadata?: Record<string, any>;
   inheritGlobalContext?: boolean;
+  spanProcessor?: SpanProcessor;
 }
 type LaminarAttributesProp = Record<typeof LaminarAttributes[keyof typeof LaminarAttributes], AttributeValue>;
 declare class Laminar {
@@ -271,6 +336,8 @@ declare class Laminar {
    * @param {boolean} props.inheritGlobalContext - Whether to inherit the global OpenTelemetry
    * context. Defaults to false. This is useful if your library is instrumented with OpenTelemetry
    * and you want Laminar spans to be children of the existing spans.
+   * @param {SpanProcessor} props.spanProcessor - The span processor to use. If passed, some of
+   * the other options will be ignored.
    *
    * @example
    * import { Laminar } from '@lmnr-ai/lmnr';
@@ -304,7 +371,8 @@ declare class Laminar {
     forceHttp,
     sessionRecordingOptions,
     metadata,
-    inheritGlobalContext
+    inheritGlobalContext,
+    spanProcessor
   }?: LaminarInitializeProps): void;
   /**
    * Initialize Laminar context from the LMNR_SPAN_CONTEXT environment variable.
@@ -540,7 +608,7 @@ declare class Laminar {
    *
    * See {@link startSpan} docs for a usage example
    */
-  static withSpan<T>(span: Span$1, fn: () => T, endOnExit?: boolean): T | Promise<T>;
+  static withSpan<T>(span: Span$1, fn: () => T, endOnExit?: boolean): T;
   static serializeLaminarSpanContext(span?: Span$1): string | null;
   static getLaminarSpanContext(span?: Span$1): LaminarSpanContext | null;
   /**
@@ -655,5 +723,5 @@ declare const initializeLaminarInstrumentations: (options?: {
   sessionRecordingOptions?: SessionRecordingOptions;
 }) => Instrumentation<_opentelemetry_instrumentation0.InstrumentationConfig>[];
 //#endregion
-export { type Datapoint, EvaluationDataset as Dataset, type Dataset as DatasetType, type EvaluationDatapoint, type EvaluationDatapointDatasetLink, type EvaluatorFunction, type EvaluatorFunctionReturn, type Event, HumanEvaluator, Laminar, LaminarAttributes, LaminarClient, LaminarDataset, type LaminarSpanContext, LaminarSpanProcessor, type MaskInputOptions, type PushDatapointsResponse, type SessionRecordingOptions, type Span, TracingLevel, evaluate, getTracer, getTracerProvider, initializeLaminarInstrumentations, instrumentClaudeAgentQuery, observe, observeDecorator, withTracingLevel, wrapAISDK };
+export { type Datapoint, EvaluationDataset as Dataset, type Dataset as DatasetType, type EvaluationDatapoint, type EvaluationDatapointDatasetLink, type EvaluatorFunction, type EvaluatorFunctionReturn, type Event, HumanEvaluator, Laminar, LaminarAttributes, LaminarClient, LaminarDataset, type LaminarSpanContext, LaminarSpanProcessor, type MaskInputOptions, type PushDatapointsResponse, type SessionRecordingOptions, type Span, TracingLevel, evaluate, getTracer, getTracerProvider, initializeLaminarInstrumentations, instrumentClaudeAgentQuery, observe, observeDecorator, observeExperimentalDecorator, withTracingLevel, wrapAISDK };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { S as TracingLevel, _ as MaskInputOptions, a as HumanEvaluator, b as SpanType, c as EvaluationDataset, d as StringUUID, f as Dataset, g as LaminarSpanContext, h as Event, i as EvaluatorFunctionReturn, l as LaminarDataset, m as EvaluationDatapointDatasetLink, o as evaluate, p as EvaluationDatapoint, r as EvaluatorFunction, s as InitializeOptions, t as Datapoint, u as LaminarClient, v as PushDatapointsResponse, x as TraceType, y as SessionRecordingOptions } from "./evaluations-DQmES9uI.mjs";
+import { S as TracingLevel, _ as MaskInputOptions, a as HumanEvaluator, b as SpanType, c as EvaluationDataset, d as StringUUID, f as Dataset, g as LaminarSpanContext, h as Event, i as EvaluatorFunctionReturn, l as LaminarDataset, m as EvaluationDatapointDatasetLink, o as evaluate, p as EvaluationDatapoint, r as EvaluatorFunction, s as InitializeOptions, t as Datapoint, u as LaminarClient, v as PushDatapointsResponse, x as TraceType, y as SessionRecordingOptions } from "./evaluations-CL4yZPJK.mjs";
 import { AttributeValue, Context, Span, Span as Span$1, TimeInput, Tracer, TracerProvider } from "@opentelemetry/api";
 import * as _opentelemetry_instrumentation0 from "@opentelemetry/instrumentation";
 import { Instrumentation, InstrumentationBase } from "@opentelemetry/instrumentation";
@@ -60,7 +60,7 @@ declare function observe<A extends unknown[], F extends (...args: A) => ReturnTy
   parentSpanContext,
   metadata,
   tags
-}: ObserveOptions, fn: F, ...args: A): Promise<ReturnType<F>>;
+}: ObserveOptions, fn: F, ...args: A): ReturnType<F>;
 /**
  * Sets the tracing level for any spans inside the function. This is useful for
  * conditionally disabling the tracing for certain functions.
@@ -83,6 +83,12 @@ declare function observe<A extends unknown[], F extends (...args: A) => ReturnTy
 declare function withTracingLevel<A extends unknown[], F extends (...args: A) => ReturnType<F>>(tracingLevel: TracingLevel, fn: F, ...args: A): ReturnType<F>;
 /**
  * Decorator that wraps a method to automatically observe it with Laminar tracing.
+ * This decorator uses the TypeScript 5.0+ standard decorator syntax.
+ *
+ * **Important**: Use this decorator only if your `tsconfig.json` does NOT have
+ * `experimentalDecorators: true`. If you're using experimental decorators, use
+ * {@link observeExperimentalDecorator} instead.
+ *
  * This decorator can be used on class methods to automatically create spans.
  *
  * @param config - Configuration for the observe decorator, can be static or a function
@@ -90,6 +96,13 @@ declare function withTracingLevel<A extends unknown[], F extends (...args: A) =>
  *
  * @example
  * ```typescript
+ * // In your tsconfig.json, ensure experimentalDecorators is NOT enabled:
+ * // {
+ * //   "compilerOptions": {
+ * //     "experimentalDecorators": false  // or omit this line
+ * //   }
+ * // }
+ *
  * import { observeDecorator } from '@lmnr-ai/lmnr';
  *
  * class MyService {
@@ -109,7 +122,53 @@ declare function withTracingLevel<A extends unknown[], F extends (...args: A) =>
  * }
  * ```
  */
-declare function observeDecorator(config: Partial<ObserveOptions> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<ObserveOptions>)): (_target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function observeDecorator<This, Args extends unknown[], Return>(config: Partial<ObserveOptions> | ((thisArg: This, ...funcArgs: Args) => Partial<ObserveOptions>)): (originalMethod: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => (this: This, ...args: Args) => Return;
+/**
+ * Decorator that wraps a method to automatically observe it with Laminar tracing.
+ * This decorator uses the legacy experimental decorator syntax
+ * (requires `--experimentalDecorators` flag).
+ *
+ * **Important**: Use this decorator only if your `tsconfig.json` has
+ * `experimentalDecorators: true` in the `compilerOptions` section
+ * (or if you compile with the `--experimentalDecorators` flag).
+ * For TypeScript 5.0+ projects without experimental decorators, use
+ * {@link observeDecorator} instead.
+ *
+ * This decorator can be used on class methods to automatically create spans.
+ *
+ * Use this only if you need the legacy experimental decorator syntax.
+ * @param config - Configuration for the observe decorator, can be static or a function
+ * @returns A method decorator
+ *
+ * @example
+ * ```typescript
+ * // In your tsconfig.json, ensure experimentalDecorators is enabled:
+ * // {
+ * //   "compilerOptions": {
+ * //     "experimentalDecorators": true
+ * //   }
+ * // }
+ *
+ * import { observeExperimentalDecorator } from '@lmnr-ai/lmnr';
+ *
+ * class MyService {
+ *   @observeExperimentalDecorator({ name: 'processData', spanType: 'DEFAULT' })
+ *   async processData(input: string) {
+ *     // Your code here
+ *     return `processed: ${input}`;
+ *   }
+ *
+ *   @observeExperimentalDecorator((thisArg, ...args) => ({
+ *     name: `dynamicMethod_${args[0]}`,
+ *     sessionId: thisArg.sessionId
+ *   }))
+ *   async dynamicMethod(id: string) {
+ *     // Your code here
+ *   }
+ * }
+ * ```
+ */
+declare function observeExperimentalDecorator(config: Partial<ObserveOptions> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<ObserveOptions>)): (_target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
 //#endregion
 //#region src/opentelemetry-lib/tracing/processor.d.ts
 interface LaminarSpanProcessorOptions {
@@ -155,6 +214,11 @@ interface LaminarSpanProcessorOptions {
    * Defaults to a new LaminarSpanExporter.
    */
   exporter?: SpanExporter;
+  /**
+   * The span processor to use. If passed, some of the other options will be ignored.
+   * If passed, wraps the underlying span processor.
+   */
+  spanProcessor?: SpanProcessor;
 }
 declare class LaminarSpanProcessor implements SpanProcessor {
   private instance;
@@ -221,6 +285,7 @@ interface LaminarInitializeProps {
   sessionRecordingOptions?: SessionRecordingOptions;
   metadata?: Record<string, any>;
   inheritGlobalContext?: boolean;
+  spanProcessor?: SpanProcessor;
 }
 type LaminarAttributesProp = Record<typeof LaminarAttributes[keyof typeof LaminarAttributes], AttributeValue>;
 declare class Laminar {
@@ -271,6 +336,8 @@ declare class Laminar {
    * @param {boolean} props.inheritGlobalContext - Whether to inherit the global OpenTelemetry
    * context. Defaults to false. This is useful if your library is instrumented with OpenTelemetry
    * and you want Laminar spans to be children of the existing spans.
+   * @param {SpanProcessor} props.spanProcessor - The span processor to use. If passed, some of
+   * the other options will be ignored.
    *
    * @example
    * import { Laminar } from '@lmnr-ai/lmnr';
@@ -304,7 +371,8 @@ declare class Laminar {
     forceHttp,
     sessionRecordingOptions,
     metadata,
-    inheritGlobalContext
+    inheritGlobalContext,
+    spanProcessor
   }?: LaminarInitializeProps): void;
   /**
    * Initialize Laminar context from the LMNR_SPAN_CONTEXT environment variable.
@@ -540,7 +608,7 @@ declare class Laminar {
    *
    * See {@link startSpan} docs for a usage example
    */
-  static withSpan<T>(span: Span$1, fn: () => T, endOnExit?: boolean): T | Promise<T>;
+  static withSpan<T>(span: Span$1, fn: () => T, endOnExit?: boolean): T;
   static serializeLaminarSpanContext(span?: Span$1): string | null;
   static getLaminarSpanContext(span?: Span$1): LaminarSpanContext | null;
   /**
@@ -655,5 +723,5 @@ declare const initializeLaminarInstrumentations: (options?: {
   sessionRecordingOptions?: SessionRecordingOptions;
 }) => Instrumentation<_opentelemetry_instrumentation0.InstrumentationConfig>[];
 //#endregion
-export { type Datapoint, EvaluationDataset as Dataset, type Dataset as DatasetType, type EvaluationDatapoint, type EvaluationDatapointDatasetLink, type EvaluatorFunction, type EvaluatorFunctionReturn, type Event, HumanEvaluator, Laminar, LaminarAttributes, LaminarClient, LaminarDataset, type LaminarSpanContext, LaminarSpanProcessor, type MaskInputOptions, type PushDatapointsResponse, type SessionRecordingOptions, type Span, TracingLevel, evaluate, getTracer, getTracerProvider, initializeLaminarInstrumentations, instrumentClaudeAgentQuery, observe, observeDecorator, withTracingLevel, wrapAISDK };
+export { type Datapoint, EvaluationDataset as Dataset, type Dataset as DatasetType, type EvaluationDatapoint, type EvaluationDatapointDatasetLink, type EvaluatorFunction, type EvaluatorFunctionReturn, type Event, HumanEvaluator, Laminar, LaminarAttributes, LaminarClient, LaminarDataset, type LaminarSpanContext, LaminarSpanProcessor, type MaskInputOptions, type PushDatapointsResponse, type SessionRecordingOptions, type Span, TracingLevel, evaluate, getTracer, getTracerProvider, initializeLaminarInstrumentations, instrumentClaudeAgentQuery, observe, observeDecorator, observeExperimentalDecorator, withTracingLevel, wrapAISDK };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as CONTEXT_SPAN_PATH_KEY, c as createResource, d as TracingLevel, f as __require, i as ASSOCIATION_PROPERTIES_KEY, l as getParentSpanId, n as getLangVersion, o as LaminarContextManager, r as version, s as LaminarSpan, t as LaminarClient, u as makeSpanOtelV2Compatible } from "./client-Cnj-Zfa4.mjs";
+import { a as CONTEXT_SPAN_PATH_KEY, c as createResource, d as TracingLevel, f as __require, i as ASSOCIATION_PROPERTIES_KEY, l as getParentSpanId, n as getLangVersion, o as LaminarContextManager, r as version, s as LaminarSpan, t as LaminarClient, u as makeSpanOtelV2Compatible } from "./client-BmOjmnjR.mjs";
 import { A as SPAN_SDK_VERSION, C as SESSION_ID, D as SPAN_LANGUAGE_VERSION, E as SPAN_INSTRUMENTATION_SOURCE, M as TRACE_HAS_BROWSER_SESSION, N as TRACE_TYPE, O as SPAN_OUTPUT, P as USER_ID, S as PARENT_SPAN_PATH, T as SPAN_INPUT, _ as ASSOCIATION_PROPERTIES, a as getOtelEnvVar, b as LaminarAttributes, d as otelSpanIdToUUID, f as otelTraceIdToUUID, g as validateTracingConfig, h as tryToOtelSpanContext, j as SPAN_TYPE, k as SPAN_PATH, l as metadataToAttributes, n as Semaphore, o as initializeLogger, p as parseOtelHeaders, r as deserializeLaminarSpanContext, s as isOtelAttributeValueType, t as NIL_UUID, u as newUUID, v as ASSOCIATION_PROPERTIES_OVERRIDES, w as SPAN_IDS_PATH, x as PARENT_SPAN_IDS_PATH, y as HUMAN_EVALUATOR_OPTIONS } from "./utils-viuxL6V7.mjs";
 import { config } from "dotenv";
 import { DiagConsoleLogger, DiagLogLevel, ROOT_CONTEXT, context, createContextKey, diag, isSpanContextValid, trace } from "@opentelemetry/api";
@@ -341,7 +341,7 @@ function instrumentClaudeAgentQuery(originalQuery) {
 			const collected = [];
 			try {
 				await startProxy();
-				if (getProxyBaseUrl()) await Laminar.withSpan(span, () => {
+				if (getProxyBaseUrl()) Laminar.withSpan(span, () => {
 					setTraceToProxy();
 				});
 				else logger$10.debug("No claude proxy server found. Skipping span context publication.");
@@ -351,7 +351,7 @@ function instrumentClaudeAgentQuery(originalQuery) {
 					yield message;
 				}
 			} catch (error) {
-				await Laminar.withSpan(span, () => {
+				Laminar.withSpan(span, () => {
 					span.recordException(error);
 				});
 				throw error;
@@ -443,6 +443,8 @@ var Laminar = class Laminar {
 	* @param {boolean} props.inheritGlobalContext - Whether to inherit the global OpenTelemetry
 	* context. Defaults to false. This is useful if your library is instrumented with OpenTelemetry
 	* and you want Laminar spans to be children of the existing spans.
+	* @param {SpanProcessor} props.spanProcessor - The span processor to use. If passed, some of
+	* the other options will be ignored.
 	*
 	* @example
 	* import { Laminar } from '@lmnr-ai/lmnr';
@@ -462,7 +464,7 @@ var Laminar = class Laminar {
 	*
 	* @throws {Error} - If project API key is not set
 	*/
-	static initialize({ projectApiKey, baseUrl, baseHttpUrl, httpPort, grpcPort, instrumentModules, disableBatch, traceExportTimeoutMillis, logLevel, maxExportBatchSize, forceHttp, sessionRecordingOptions, metadata, inheritGlobalContext } = {}) {
+	static initialize({ projectApiKey, baseUrl, baseHttpUrl, httpPort, grpcPort, instrumentModules, disableBatch, traceExportTimeoutMillis, logLevel, maxExportBatchSize, forceHttp, sessionRecordingOptions, metadata, inheritGlobalContext, spanProcessor: spanProcessor$1 } = {}) {
 		if (this.isInitialized) {
 			logger$9.warn("Laminar has already been initialized. Skipping initialization.");
 			return;
@@ -484,6 +486,7 @@ var Laminar = class Laminar {
 		this.globalMetadata = metadata ?? {};
 		LaminarContextManager.setGlobalMetadata(this.globalMetadata);
 		if (inheritGlobalContext) LaminarContextManager.inheritGlobalContext = true;
+		if (spanProcessor$1 && !(spanProcessor$1 instanceof LaminarSpanProcessor)) logger$9.warn("Span processor is not a LaminarSpanProcessor. Some functionality may be impaired.");
 		this.isInitialized = true;
 		const urlWithoutSlash = url?.replace(/\/$/, "").replace(/:\d{1,5}$/g, "");
 		const httpUrlWithoutSlash = httpUrl?.replace(/\/$/, "").replace(/:\d{1,5}$/g, "");
@@ -500,7 +503,8 @@ var Laminar = class Laminar {
 			disableBatch,
 			maxExportBatchSize,
 			traceExportTimeoutMillis,
-			sessionRecordingOptions
+			sessionRecordingOptions,
+			spanProcessor: spanProcessor$1
 		});
 		this._initializeContextFromEnv();
 	}
@@ -849,7 +853,10 @@ var Laminar = class Laminar {
 		return context.with(context$1, () => LaminarContextManager.runWithIsolatedContext([context$1], () => {
 			try {
 				const result = fn();
-				if (result instanceof Promise) return result.finally(() => {
+				if (result instanceof Promise) return result.catch((err) => {
+					span.recordException(err);
+					throw err;
+				}).finally(() => {
 					if (endOnExit !== void 0 && endOnExit) span.end();
 				});
 				if (endOnExit !== void 0 && endOnExit) span.end();
@@ -3345,7 +3352,7 @@ var LaminarSpanExporter = class {
 
 //#endregion
 //#region src/opentelemetry-lib/tracing/processor.ts
-var LaminarSpanProcessor = class {
+var LaminarSpanProcessor = class LaminarSpanProcessor {
 	/**
 	* @param {object} options - The options for the Laminar span processor.
 	* @param {string} options.baseUrl - The base URL of the Laminar API.
@@ -3364,11 +3371,18 @@ var LaminarSpanProcessor = class {
 	constructor(options = {}) {
 		this._spanIdToPath = /* @__PURE__ */ new Map();
 		this._spanIdLists = /* @__PURE__ */ new Map();
-		const exporter = options.exporter ?? new LaminarSpanExporter(options);
-		this.instance = options.disableBatch ? new SimpleSpanProcessor(exporter) : new BatchSpanProcessor(exporter, {
-			maxExportBatchSize: options.maxExportBatchSize ?? 512,
-			exportTimeoutMillis: options.traceExportTimeoutMillis ?? 3e4
-		});
+		if (options.spanProcessor && options.spanProcessor instanceof LaminarSpanProcessor) {
+			this.instance = options.spanProcessor.instance;
+			this._spanIdToPath = options.spanProcessor._spanIdToPath;
+			this._spanIdLists = options.spanProcessor._spanIdLists;
+		} else if (options.spanProcessor) this.instance = options.spanProcessor;
+		else {
+			const exporter = options.exporter ?? new LaminarSpanExporter(options);
+			this.instance = options.disableBatch ? new SimpleSpanProcessor(exporter) : new BatchSpanProcessor(exporter, {
+				maxExportBatchSize: options.maxExportBatchSize ?? 512,
+				exportTimeoutMillis: options.traceExportTimeoutMillis ?? 3e4
+			});
+		}
 	}
 	forceFlush() {
 		return this.instance.forceFlush();
@@ -3488,6 +3502,7 @@ const startTracing = (options) => {
 	});
 	const port = options.forceHttp ? options.httpPort : options.port;
 	spanProcessor = new LaminarSpanProcessor({
+		spanProcessor: options.spanProcessor,
 		baseUrl: options.baseUrl,
 		port,
 		apiKey: options.apiKey,
@@ -3635,7 +3650,7 @@ function observeBase({ name, associationProperties, input, ignoreInput, ignoreOu
 	} catch (e) {
 		logger$2.warn("Failed to parse parent span context: " + (e instanceof Error ? e.message : String(e)));
 	}
-	return context.with(entityContext, () => getTracer().startActiveSpan(name, { attributes: associationProperties }, entityContext, async (span) => {
+	return context.with(entityContext, () => getTracer().startActiveSpan(name, { attributes: associationProperties }, entityContext, (span) => {
 		if (shouldSendTraces() && !ignoreInput) try {
 			const spanInput = inputParameters ?? args;
 			if (input !== void 0) span.setAttribute(SPAN_INPUT, typeof input === "string" ? input : serialize(input));
@@ -3729,7 +3744,7 @@ const logger$1 = initializeLogger();
 *    // Your code here
 * });
 */
-async function observe({ name, sessionId, userId, traceType, spanType, input, ignoreInput, ignoreOutput, parentSpanContext, metadata, tags }, fn, ...args) {
+function observe({ name, sessionId, userId, traceType, spanType, input, ignoreInput, ignoreOutput, parentSpanContext, metadata, tags }, fn, ...args) {
 	if (fn === void 0 || typeof fn !== "function") throw new Error("Invalid `observe` usage. Second argument `fn` must be a function.");
 	const associationProperties = buildAssociationProperties({
 		sessionId,
@@ -3740,7 +3755,7 @@ async function observe({ name, sessionId, userId, traceType, spanType, input, ig
 		metadata,
 		parentSpanContext
 	});
-	return await observeBase({
+	return observeBase({
 		name: name ?? fn.name,
 		associationProperties,
 		input,
@@ -3834,6 +3849,12 @@ const buildAssociationProperties = (options) => {
 };
 /**
 * Decorator that wraps a method to automatically observe it with Laminar tracing.
+* This decorator uses the TypeScript 5.0+ standard decorator syntax.
+*
+* **Important**: Use this decorator only if your `tsconfig.json` does NOT have
+* `experimentalDecorators: true`. If you're using experimental decorators, use
+* {@link observeExperimentalDecorator} instead.
+*
 * This decorator can be used on class methods to automatically create spans.
 *
 * @param config - Configuration for the observe decorator, can be static or a function
@@ -3841,6 +3862,13 @@ const buildAssociationProperties = (options) => {
 *
 * @example
 * ```typescript
+* // In your tsconfig.json, ensure experimentalDecorators is NOT enabled:
+* // {
+* //   "compilerOptions": {
+* //     "experimentalDecorators": false  // or omit this line
+* //   }
+* // }
+*
 * import { observeDecorator } from '@lmnr-ai/lmnr';
 *
 * class MyService {
@@ -3861,8 +3889,72 @@ const buildAssociationProperties = (options) => {
 * ```
 */
 function observeDecorator(config$1) {
+	return function(originalMethod, context$1) {
+		if (context$1.kind !== "method") throw new Error(`observeDecorator can only be applied to methods. Applied to: ${String(context$1.name)}`);
+		const methodName = String(context$1.name);
+		return function(...args) {
+			let actualConfig;
+			if (typeof config$1 === "function") actualConfig = config$1(this, ...args);
+			else actualConfig = config$1;
+			return observeBase({
+				name: actualConfig.name ?? methodName,
+				associationProperties: buildAssociationProperties(actualConfig),
+				input: actualConfig.input,
+				ignoreInput: actualConfig.ignoreInput,
+				ignoreOutput: actualConfig.ignoreOutput,
+				parentSpanContext: actualConfig.parentSpanContext
+			}, originalMethod, this, ...args);
+		};
+	};
+}
+/**
+* Decorator that wraps a method to automatically observe it with Laminar tracing.
+* This decorator uses the legacy experimental decorator syntax
+* (requires `--experimentalDecorators` flag).
+*
+* **Important**: Use this decorator only if your `tsconfig.json` has
+* `experimentalDecorators: true` in the `compilerOptions` section
+* (or if you compile with the `--experimentalDecorators` flag).
+* For TypeScript 5.0+ projects without experimental decorators, use
+* {@link observeDecorator} instead.
+*
+* This decorator can be used on class methods to automatically create spans.
+*
+* Use this only if you need the legacy experimental decorator syntax.
+* @param config - Configuration for the observe decorator, can be static or a function
+* @returns A method decorator
+*
+* @example
+* ```typescript
+* // In your tsconfig.json, ensure experimentalDecorators is enabled:
+* // {
+* //   "compilerOptions": {
+* //     "experimentalDecorators": true
+* //   }
+* // }
+*
+* import { observeExperimentalDecorator } from '@lmnr-ai/lmnr';
+*
+* class MyService {
+*   @observeExperimentalDecorator({ name: 'processData', spanType: 'DEFAULT' })
+*   async processData(input: string) {
+*     // Your code here
+*     return `processed: ${input}`;
+*   }
+*
+*   @observeExperimentalDecorator((thisArg, ...args) => ({
+*     name: `dynamicMethod_${args[0]}`,
+*     sessionId: thisArg.sessionId
+*   }))
+*   async dynamicMethod(id: string) {
+*     // Your code here
+*   }
+* }
+* ```
+*/
+function observeExperimentalDecorator(config$1) {
 	return function(_target, propertyKey, descriptor) {
-		if (!descriptor || typeof descriptor.value !== "function") throw new Error(`observeDecorator can only be applied to methods. Applied to: ${String(propertyKey)}`);
+		if (!descriptor || typeof descriptor.value !== "function") throw new Error(`observeExperimentalDecorator can only be applied to methods. Applied to: ${String(propertyKey)}`);
 		const originalMethod = descriptor.value;
 		descriptor.value = function(...args) {
 			let actualConfig;
@@ -4228,5 +4320,5 @@ const wrapAISDK = (ai) => {
 };
 
 //#endregion
-export { EvaluationDataset as Dataset, HumanEvaluator, Laminar, LaminarAttributes, LaminarClient, LaminarDataset, LaminarSpanProcessor, TracingLevel, evaluate, getTracer, getTracerProvider, initializeLaminarInstrumentations, instrumentClaudeAgentQuery, observe, observeDecorator, withTracingLevel, wrapAISDK };
+export { EvaluationDataset as Dataset, HumanEvaluator, Laminar, LaminarAttributes, LaminarClient, LaminarDataset, LaminarSpanProcessor, TracingLevel, evaluate, getTracer, getTracerProvider, initializeLaminarInstrumentations, instrumentClaudeAgentQuery, observe, observeDecorator, observeExperimentalDecorator, withTracingLevel, wrapAISDK };
 //# sourceMappingURL=index.mjs.map