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

package/dist/index.d.cts

@@ -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 {
@@ -549,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;
   /**
@@ -664,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

@@ -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 {
@@ -549,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;
   /**
@@ -664,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-BugRObJS.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;
@@ -853,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();
@@ -3647,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));
@@ -3741,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,
@@ -3752,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,
@@ -3846,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
@@ -3853,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 {
@@ -3873,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;
@@ -4240,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