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

package/dist/index.cjs

@@ -1,5 +1,5 @@
 const require_utils = require('./utils-BmfIfQcB.cjs');
-const require_client = require('./client-CPYdIP16.cjs');
+const require_client = require('./client-VmPk12gK.cjs');
 let dotenv = require("dotenv");
 let _opentelemetry_api = require("@opentelemetry/api");
 let _opentelemetry_context_async_hooks = require("@opentelemetry/context-async-hooks");
@@ -343,7 +343,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.");
@@ -353,7 +353,7 @@ function instrumentClaudeAgentQuery(originalQuery) {
 					yield message;
 				}
 			} catch (error) {
-				await Laminar.withSpan(span, () => {
+				Laminar.withSpan(span, () => {
 					span.recordException(error);
 				});
 				throw error;
@@ -445,6 +445,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';
@@ -464,7 +466,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;
@@ -486,6 +488,7 @@ var Laminar = class Laminar {
 		this.globalMetadata = metadata ?? {};
 		require_client.LaminarContextManager.setGlobalMetadata(this.globalMetadata);
 		if (inheritGlobalContext) require_client.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, "");
@@ -502,7 +505,8 @@ var Laminar = class Laminar {
 			disableBatch,
 			maxExportBatchSize,
 			traceExportTimeoutMillis,
-			sessionRecordingOptions
+			sessionRecordingOptions,
+			spanProcessor: spanProcessor$1
 		});
 		this._initializeContextFromEnv();
 	}
@@ -851,7 +855,10 @@ var Laminar = class Laminar {
 		return _opentelemetry_api.context.with(context$4, () => require_client.LaminarContextManager.runWithIsolatedContext([context$4], () => {
 			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();
@@ -3347,7 +3354,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.
@@ -3366,11 +3373,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 _opentelemetry_sdk_trace_base.SimpleSpanProcessor(exporter) : new _opentelemetry_sdk_trace_base.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 _opentelemetry_sdk_trace_base.SimpleSpanProcessor(exporter) : new _opentelemetry_sdk_trace_base.BatchSpanProcessor(exporter, {
+				maxExportBatchSize: options.maxExportBatchSize ?? 512,
+				exportTimeoutMillis: options.traceExportTimeoutMillis ?? 3e4
+			});
+		}
 	}
 	forceFlush() {
 		return this.instance.forceFlush();
@@ -3490,6 +3504,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,
@@ -3637,7 +3652,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 _opentelemetry_api.context.with(entityContext, () => getTracer().startActiveSpan(name, { attributes: associationProperties }, entityContext, async (span) => {
+	return _opentelemetry_api.context.with(entityContext, () => getTracer().startActiveSpan(name, { attributes: associationProperties }, entityContext, (span) => {
 		if (shouldSendTraces() && !ignoreInput) try {
 			const spanInput = inputParameters ?? args;
 			if (input !== void 0) span.setAttribute(require_utils.SPAN_INPUT, typeof input === "string" ? input : serialize(input));
@@ -3731,7 +3746,7 @@ const logger$1 = require_utils.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,
@@ -3742,7 +3757,7 @@ async function observe({ name, sessionId, userId, traceType, spanType, input, ig
 		metadata,
 		parentSpanContext
 	});
-	return await observeBase({
+	return observeBase({
 		name: name ?? fn.name,
 		associationProperties,
 		input,
@@ -3836,6 +3851,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
@@ -3843,6 +3864,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 {
@@ -3863,8 +3891,72 @@ const buildAssociationProperties = (options) => {
 * ```
 */
 function observeDecorator(config$2) {
+	return function(originalMethod, context$4) {
+		if (context$4.kind !== "method") throw new Error(`observeDecorator can only be applied to methods. Applied to: ${String(context$4.name)}`);
+		const methodName = String(context$4.name);
+		return function(...args) {
+			let actualConfig;
+			if (typeof config$2 === "function") actualConfig = config$2(this, ...args);
+			else actualConfig = config$2;
+			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$2) {
 	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;
@@ -4245,6 +4337,7 @@ exports.initializeLaminarInstrumentations = initializeLaminarInstrumentations;
 exports.instrumentClaudeAgentQuery = instrumentClaudeAgentQuery;
 exports.observe = observe;
 exports.observeDecorator = observeDecorator;
+exports.observeExperimentalDecorator = observeExperimentalDecorator;
 exports.withTracingLevel = withTracingLevel;
 exports.wrapAISDK = wrapAISDK;
 //# sourceMappingURL=index.cjs.map