autotel 3.5.0 → 3.7.0

package/dist/semantic-helpers.d.ts

@@ -1,15 +1,7 @@
-import { T as TraceContext } from './trace-context-DbGKd1Rn.js';
-import { Attributes } from '@opentelemetry/api';
-
-/**
- * Semantic convention helpers for OpenTelemetry
- *
- * Pre-configured trace helpers that follow OpenTelemetry semantic conventions
- * for common operation types. Reduces boilerplate and ensures consistency.
- *
- * Based on: https://opentelemetry.io/docs/specs/semconv/
- */
+import { n as TraceContext } from "./trace-context-Cijqoi6e.js";
+import { Attributes } from "@opentelemetry/api";
 
+//#region src/semantic-helpers.d.ts
 /**
  * Configuration for LLM (Large Language Model) operations
  *
@@ -17,14 +9,14 @@ import { Attributes } from '@opentelemetry/api';
  * https://opentelemetry.io/docs/specs/semconv/gen-ai/
  */
 interface LLMConfig {
-    /** Model name (e.g., 'gpt-4', 'claude-3-opus') */
-    model: string;
-    /** Operation type */
-    operation?: 'chat' | 'completion' | 'embedding';
-    /** Model provider (e.g., 'openai', 'anthropic', 'cohere') - maps to gen.ai.system */
-    provider?: string;
-    /** Additional attributes to add to the span */
-    attributes?: Attributes;
+  /** Model name (e.g., 'gpt-4', 'claude-3-opus') */
+  model: string;
+  /** Operation type */
+  operation?: 'chat' | 'completion' | 'embedding';
+  /** Model provider (e.g., 'openai', 'anthropic', 'cohere') - maps to gen.ai.system */
+  provider?: string;
+  /** Additional attributes to add to the span */
+  attributes?: Attributes;
 }
 /**
  * Configuration for database operations
@@ -33,16 +25,16 @@ interface LLMConfig {
  * https://opentelemetry.io/docs/specs/semconv/database/
  */
 interface DBConfig {
-    /** Database system (e.g., 'postgresql', 'mongodb', 'redis') */
-    system: string;
-    /** Operation type (e.g., 'SELECT', 'INSERT', 'find', 'get') */
-    operation?: string;
-    /** Database name */
-    database?: string;
-    /** Collection/table name */
-    collection?: string;
-    /** Additional attributes to add to the span */
-    attributes?: Attributes;
+  /** Database system (e.g., 'postgresql', 'mongodb', 'redis') */
+  system: string;
+  /** Operation type (e.g., 'SELECT', 'INSERT', 'find', 'get') */
+  operation?: string;
+  /** Database name */
+  database?: string;
+  /** Collection/table name */
+  collection?: string;
+  /** Additional attributes to add to the span */
+  attributes?: Attributes;
 }
 /**
  * Configuration for HTTP client operations
@@ -51,12 +43,12 @@ interface DBConfig {
  * https://opentelemetry.io/docs/specs/semconv/http/
  */
 interface HTTPConfig {
-    /** HTTP method (e.g., 'GET', 'POST') */
-    method?: string;
-    /** Target URL or URL template */
-    url?: string;
-    /** Additional attributes to add to the span */
-    attributes?: Attributes;
+  /** HTTP method (e.g., 'GET', 'POST') */
+  method?: string;
+  /** Target URL or URL template */
+  url?: string;
+  /** Additional attributes to add to the span */
+  attributes?: Attributes;
 }
 /**
  * Configuration for messaging operations
@@ -65,14 +57,14 @@ interface HTTPConfig {
  * https://opentelemetry.io/docs/specs/semconv/messaging/
  */
 interface MessagingConfig {
-    /** Messaging system (e.g., 'kafka', 'rabbitmq', 'sqs') */
-    system: string;
-    /** Operation type */
-    operation?: 'publish' | 'receive' | 'process';
-    /** Destination name (queue/topic) */
-    destination?: string;
-    /** Additional attributes to add to the span */
-    attributes?: Attributes;
+  /** Messaging system (e.g., 'kafka', 'rabbitmq', 'sqs') */
+  system: string;
+  /** Operation type */
+  operation?: 'publish' | 'receive' | 'process';
+  /** Destination name (queue/topic) */
+  destination?: string;
+  /** Additional attributes to add to the span */
+  attributes?: Attributes;
 }
 /**
  * Trace LLM operations with Gen AI semantic conventions
@@ -438,5 +430,6 @@ declare function traceHTTP<TArgs extends unknown[], TReturn>(config: HTTPConfig)
  * @public
  */
 declare function traceMessaging<TArgs extends unknown[], TReturn>(config: MessagingConfig): (fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>) => ((...args: TArgs) => Promise<TReturn>);
-
-export { type DBConfig, type HTTPConfig, type LLMConfig, type MessagingConfig, traceDB, traceHTTP, traceLLM, traceMessaging };
+//#endregion
+export { DBConfig, HTTPConfig, LLMConfig, MessagingConfig, traceDB, traceHTTP, traceLLM, traceMessaging };
+//# sourceMappingURL=semantic-helpers.d.ts.map

package/dist/semantic-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-helpers.d.ts","names":[],"sources":["../src/semantic-helpers.ts"],"mappings":";;;;;;;;AA2ByB;AASzB;UAjBiB,SAAA;;EAEf,KAAA;EAiBA;EAfA,SAAA;EAmBA;EAjBA,QAAA;EAqBA;EAnBA,UAAA,GAAa,UAAU;AAAA;AAmBA;AASzB;;;;;AATyB,UAVR,QAAA;EAyBf;EAvBA,MAAA;EAuBuB;EArBvB,SAAA;EA8Be;EA5Bf,QAAA;;EAEA,UAAA;EA4BA;EA1BA,UAAA,GAAa,UAAU;AAAA;;;;AAgCA;AAmGzB;;UA1HiB,UAAA;EA0HkD;EAxHjE,MAAA;EA0H8C;EAxH9C,GAAA;EAwHwD;EAtHxD,UAAA,GAAa,UAAU;AAAA;;;;;;;UASR,eAAA;EA6GI;EA3GnB,MAAA;EA2GwC;EAzGxC,SAAA;EAyGwD;EAvGxD,WAAA;EAuGE;EArGF,UAAA,GAAa,UAAU;AAAA;;;;AAsGgB;AAiIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGyC;AAuGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKyC;AAgIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKyC;;;iBAxXzB,QAAA,mCAA2C,MAAA,EAAQ,SAAA,IAE/D,SAAA,GAAY,GAAA,EAAK,YAAA,SAAqB,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA,WACxD,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiIlB,OAAA,mCAA0C,MAAA,EAAQ,QAAA,IAE9D,SAAA,GAAY,GAAA,EAAK,YAAA,SAAqB,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA,WACxD,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuGlB,SAAA,mCACd,MAAA,EAAQ,UAAA,IAGN,SAAA,GAAY,GAAA,EAAK,YAAA,SAAqB,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA,WACxD,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgIlB,cAAA,mCACd,MAAA,EAAQ,eAAA,IAGN,SAAA,GAAY,GAAA,EAAK,YAAA,SAAqB,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA,WACxD,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA"}

package/dist/semantic-helpers.js

@@ -1,20 +1,439 @@
-export { traceDB, traceHTTP, traceLLM, traceMessaging } from './chunk-NVGPMGI4.js';
-import './chunk-YWCESU4Y.js';
-import './chunk-HT5JQKN2.js';
-import './chunk-SEO6NAQT.js';
-import './chunk-O4JZUCUE.js';
-import './chunk-ALPYR2GC.js';
-import './chunk-CMHVQR6P.js';
-import './chunk-A4E5AQFK.js';
-import './chunk-WGWSHJ2N.js';
-import './chunk-GYR5K654.js';
-import './chunk-RUPKBKUF.js';
-import './chunk-6UQRVUN3.js';
-import './chunk-3QXBFGKP.js';
-import './chunk-Q4EULJQY.js';
-import './chunk-DPSA4QLA.js';
-import './chunk-55ER2KD5.js';
-import './chunk-J5QENANM.js';
-import './chunk-HA2WBOGQ.js';
-//# sourceMappingURL=semantic-helpers.js.map
+import { a as trace } from "./functional-BGkT8J-h.js";
+
+//#region src/semantic-helpers.ts
+/**
+* Semantic convention helpers for OpenTelemetry
+*
+* Pre-configured trace helpers that follow OpenTelemetry semantic conventions
+* for common operation types. Reduces boilerplate and ensures consistency.
+*
+* Based on: https://opentelemetry.io/docs/specs/semconv/
+*/
+/**
+* Trace LLM operations with Gen AI semantic conventions
+*
+* Automatically adds standard attributes for LLM operations:
+* - gen.ai.request.model
+* - gen.ai.operation.name
+* - gen.ai.system
+*
+* **Use Cases:**
+* - Chat completions
+* - Text generation
+* - Embeddings
+* - Multi-step LLM workflows
+*
+* @param config - LLM operation configuration
+* @returns Traced function factory with Gen AI attributes
+*
+* @example Chat completion with OpenAI
+* ```typescript
+* import { traceLLM } from 'autotel/semantic-helpers'
+* import OpenAI from 'openai'
+*
+* const openai = new OpenAI()
+*
+* export const generateResponse = traceLLM({
+*   model: 'gpt-4-turbo',
+*   operation: 'chat',
+*   provider: 'openai'
+* })(ctx => async (prompt: string) => {
+*   const response = await openai.chat.completions.create({
+*     model: 'gpt-4-turbo',
+*     messages: [{ role: 'user', content: prompt }]
+*   })
+*
+*   // Add usage metrics to span
+*   ctx.setAttribute('gen.ai.usage.completion_tokens', response.usage?.completion_tokens)
+*   ctx.setAttribute('gen.ai.usage.prompt_tokens', response.usage?.prompt_tokens)
+*
+*   return response.choices[0].message.content
+* })
+* ```
+*
+* @example Anthropic Claude with streaming
+* ```typescript
+* import { traceLLM } from 'autotel/semantic-helpers'
+* import Anthropic from '@anthropic-ai/sdk'
+*
+* const anthropic = new Anthropic()
+*
+* export const streamResponse = traceLLM({
+*   model: 'claude-3-opus-20240229',
+*   operation: 'chat',
+*   provider: 'anthropic'
+* })(ctx => async function* (prompt: string) {
+*   const stream = await anthropic.messages.create({
+*     model: 'claude-3-opus-20240229',
+*     messages: [{ role: 'user', content: prompt }],
+*     stream: true,
+*     max_tokens: 1024
+*   })
+*
+*   let totalTokens = 0
+*   for await (const event of stream) {
+*     if (event.type === 'content_block_delta') {
+*       yield event.delta.text
+*     }
+*     if (event.type === 'message_stop') {
+*       ctx.setAttribute('gen.ai.usage.completion_tokens', event.message.usage.output_tokens)
+*       totalTokens = event.message.usage.output_tokens
+*     }
+*   }
+*
+*   return totalTokens
+* })
+* ```
+*
+* @example Embeddings
+* ```typescript
+* import { traceLLM } from 'autotel/semantic-helpers'
+* import { OpenAIEmbeddings } from '@langchain/openai'
+*
+* const embeddings = new OpenAIEmbeddings()
+*
+* export const embed = traceLLM({
+*   model: 'text-embedding-3-small',
+*   operation: 'embedding',
+*   provider: 'openai'
+* })(ctx => async (text: string) => {
+*   const result = await embeddings.embedQuery(text)
+*   ctx.setAttribute('gen.ai.response.embedding_length', result.length)
+*   return result
+* })
+* ```
+*
+* @public
+*/
+function traceLLM(config) {
+	return (fnFactory) => {
+		return trace((ctx) => {
+			ctx.setAttribute("gen.ai.request.model", config.model);
+			ctx.setAttribute("gen.ai.operation.name", config.operation || "chat");
+			if (config.provider) ctx.setAttribute("gen.ai.system", config.provider);
+			if (config.attributes) {
+				for (const [key, value] of Object.entries(config.attributes)) if (value !== void 0 && value !== null) {
+					const attrValue = typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : JSON.stringify(value);
+					ctx.setAttribute(key, attrValue);
+				}
+			}
+			return fnFactory(ctx);
+		});
+	};
+}
+/**
+* Trace database operations with DB semantic conventions
+*
+* Automatically adds standard attributes for database operations:
+* - db.system
+* - db.operation
+* - db.name
+* - db.collection.name (for NoSQL)
+*
+* **Use Cases:**
+* - SQL queries (PostgreSQL, MySQL, SQLite)
+* - NoSQL operations (MongoDB, DynamoDB, Redis)
+* - ORM queries (Prisma, TypeORM, Drizzle)
+*
+* @param config - Database operation configuration
+* @returns Traced function factory with DB attributes
+*
+* @example PostgreSQL query
+* ```typescript
+* import { traceDB } from 'autotel/semantic-helpers'
+* import { pool } from './db'
+*
+* export const getUser = traceDB({
+*   system: 'postgresql',
+*   operation: 'SELECT',
+*   database: 'app_db',
+*   collection: 'users'
+* })(ctx => async (userId: string) => {
+*   const query = 'SELECT * FROM users WHERE id = $1'
+*   ctx.setAttribute('db.statement', query)
+*
+*   const result = await pool.query(query, [userId])
+*   ctx.setAttribute('db.rows_affected', result.rowCount)
+*
+*   return result.rows[0]
+* })
+* ```
+*
+* @example MongoDB with Mongoose
+* ```typescript
+* import { traceDB } from 'autotel/semantic-helpers'
+* import { User } from './models/User'
+*
+* export const findUsers = traceDB({
+*   system: 'mongodb',
+*   operation: 'find',
+*   database: 'app_db',
+*   collection: 'users'
+* })(ctx => async (filter: object) => {
+*   ctx.setAttribute('db.mongodb.filter', JSON.stringify(filter))
+*
+*   const users = await User.find(filter).limit(100)
+*   ctx.setAttribute('db.response.count', users.length)
+*
+*   return users
+* })
+* ```
+*
+* @example Redis operations
+* ```typescript
+* import { traceDB } from 'autotel/semantic-helpers'
+* import { redis } from './redis'
+*
+* export const cacheGet = traceDB({
+*   system: 'redis',
+*   operation: 'GET'
+* })(ctx => async (key: string) => {
+*   ctx.setAttribute('db.redis.key', key)
+*
+*   const value = await redis.get(key)
+*   ctx.setAttribute('db.response.cache_hit', value !== null)
+*
+*   return value
+* })
+* ```
+*
+* @example Prisma with detailed query info
+* ```typescript
+* import { traceDB } from 'autotel/semantic-helpers'
+* import { prisma } from './prisma'
+*
+* export const createPost = traceDB({
+*   system: 'postgresql',
+*   operation: 'INSERT',
+*   database: 'app_db',
+*   collection: 'posts'
+* })(ctx => async (data: { title: string; content: string; authorId: string }) => {
+*   ctx.setAttribute('db.prisma.model', 'Post')
+*   ctx.setAttribute('db.prisma.action', 'create')
+*
+*   const post = await prisma.post.create({ data })
+*
+*   ctx.setAttribute('db.response.id', post.id)
+*   return post
+* })
+* ```
+*
+* @public
+*/
+function traceDB(config) {
+	return (fnFactory) => {
+		return trace((ctx) => {
+			ctx.setAttribute("db.system", config.system);
+			if (config.operation) ctx.setAttribute("db.operation", config.operation);
+			if (config.database) ctx.setAttribute("db.name", config.database);
+			if (config.collection) ctx.setAttribute("db.collection.name", config.collection);
+			if (config.attributes) {
+				for (const [key, value] of Object.entries(config.attributes)) if (value !== void 0 && value !== null) {
+					const attrValue = typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : JSON.stringify(value);
+					ctx.setAttribute(key, attrValue);
+				}
+			}
+			return fnFactory(ctx);
+		});
+	};
+}
+/**
+* Trace HTTP client operations with HTTP semantic conventions
+*
+* Automatically adds standard attributes for HTTP requests:
+* - http.request.method
+* - url.full
+*
+* **Use Cases:**
+* - External API calls
+* - Microservice communication
+* - Third-party integrations
+*
+* @param config - HTTP operation configuration
+* @returns Traced function factory with HTTP attributes
+*
+* @example Fetch API
+* ```typescript
+* import { traceHTTP } from 'autotel/semantic-helpers'
+*
+* export const fetchUser = traceHTTP({
+*   method: 'GET',
+*   url: 'https://api.example.com/users/:id'
+* })(ctx => async (userId: string) => {
+*   const url = `https://api.example.com/users/${userId}`
+*   ctx.setAttribute('url.full', url)
+*
+*   const response = await fetch(url)
+*   ctx.setAttribute('http.response.status_code', response.status)
+*
+*   if (!response.ok) {
+*     ctx.setAttribute('error', true)
+*     throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+*   }
+*
+*   return response.json()
+* })
+* ```
+*
+* @example Axios with retry logic
+* ```typescript
+* import { traceHTTP } from 'autotel/semantic-helpers'
+* import axios from 'axios'
+*
+* export const sendWebhook = traceHTTP({
+*   method: 'POST',
+*   url: 'https://webhook.example.com/events'
+* })(ctx => async (payload: object) => {
+*   let attempts = 0
+*   const maxAttempts = 3
+*
+*   while (attempts < maxAttempts) {
+*     try {
+*       attempts++
+*       ctx.setAttribute('http.request.resend_count', attempts - 1)
+*
+*       const response = await axios.post('https://webhook.example.com/events', payload)
+*       ctx.setAttribute('http.response.status_code', response.status)
+*       return response.data
+*     } catch (error) {
+*       if (attempts >= maxAttempts) throw error
+*       await new Promise(resolve => setTimeout(resolve, 1000 * attempts))
+*     }
+*   }
+* })
+* ```
+*
+* @public
+*/
+function traceHTTP(config) {
+	return (fnFactory) => {
+		return trace((ctx) => {
+			if (config.method) ctx.setAttribute("http.request.method", config.method);
+			if (config.url) ctx.setAttribute("url.full", config.url);
+			if (config.attributes) {
+				for (const [key, value] of Object.entries(config.attributes)) if (value !== void 0 && value !== null) {
+					const attrValue = typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : JSON.stringify(value);
+					ctx.setAttribute(key, attrValue);
+				}
+			}
+			return fnFactory(ctx);
+		});
+	};
+}
+/**
+* Trace messaging operations with Messaging semantic conventions
+*
+* Automatically adds standard attributes for messaging:
+* - messaging.system
+* - messaging.operation
+* - messaging.destination.name
+*
+* **Use Cases:**
+* - Publishing messages to queues/topics
+* - Consuming messages from queues/topics
+* - Event-driven architectures
+*
+* @param config - Messaging operation configuration
+* @returns Traced function factory with Messaging attributes
+*
+* @example Publishing to Kafka
+* ```typescript
+* import { traceMessaging } from 'autotel/semantic-helpers'
+* import { kafka } from './kafka'
+*
+* const producer = kafka.producer()
+*
+* export const publishEvent = traceMessaging({
+*   system: 'kafka',
+*   operation: 'publish',
+*   destination: 'user-events'
+* })(ctx => async (event: { type: string; userId: string; data: object }) => {
+*   ctx.setAttribute('messaging.message.type', event.type)
+*   ctx.setAttribute('messaging.kafka.partition', 0)
+*
+*   await producer.send({
+*     topic: 'user-events',
+*     messages: [
+*       {
+*         key: event.userId,
+*         value: JSON.stringify(event.data)
+*       }
+*     ]
+*   })
+*
+*   ctx.setAttribute('messaging.message.id', event.userId)
+* })
+* ```
+*
+* @example Consuming from RabbitMQ
+* ```typescript
+* import { traceMessaging } from 'autotel/semantic-helpers'
+* import { channel } from './rabbitmq'
+*
+* export const processOrder = traceMessaging({
+*   system: 'rabbitmq',
+*   operation: 'process',
+*   destination: 'orders'
+* })(ctx => async (message: { orderId: string; items: object[] }) => {
+*   ctx.setAttribute('messaging.message.id', message.orderId)
+*   ctx.setAttribute('messaging.message.body.size', JSON.stringify(message).length)
+*
+*   // Process order logic
+*   const result = await processOrderInternal(message)
+*
+*   ctx.setAttribute('messaging.operation.result', 'success')
+*   return result
+* })
+* ```
+*
+* @example AWS SQS with batch processing
+* ```typescript
+* import { traceMessaging } from 'autotel/semantic-helpers'
+* import { SQS } from '@aws-sdk/client-sqs'
+*
+* const sqs = new SQS()
+*
+* export const sendBatch = traceMessaging({
+*   system: 'aws_sqs',
+*   operation: 'publish',
+*   destination: 'notifications-queue'
+* })(ctx => async (messages: Array<{ id: string; body: object }>) => {
+*   ctx.setAttribute('messaging.batch.message_count', messages.length)
+*
+*   const result = await sqs.sendMessageBatch({
+*     QueueUrl: process.env.QUEUE_URL,
+*     Entries: messages.map(msg => ({
+*       Id: msg.id,
+*       MessageBody: JSON.stringify(msg.body)
+*     }))
+*   })
+*
+*   ctx.setAttribute('messaging.operation.success_count', result.Successful?.length || 0)
+*   ctx.setAttribute('messaging.operation.failed_count', result.Failed?.length || 0)
+*
+*   return result
+* })
+* ```
+*
+* @public
+*/
+function traceMessaging(config) {
+	return (fnFactory) => {
+		return trace((ctx) => {
+			ctx.setAttribute("messaging.system", config.system);
+			if (config.operation) ctx.setAttribute("messaging.operation", config.operation);
+			if (config.destination) ctx.setAttribute("messaging.destination.name", config.destination);
+			if (config.attributes) {
+				for (const [key, value] of Object.entries(config.attributes)) if (value !== void 0 && value !== null) {
+					const attrValue = typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : JSON.stringify(value);
+					ctx.setAttribute(key, attrValue);
+				}
+			}
+			return fnFactory(ctx);
+		});
+	};
+}
+
+//#endregion
+export { traceDB, traceHTTP, traceLLM, traceMessaging };
 //# sourceMappingURL=semantic-helpers.js.map

package/dist/semantic-helpers.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"semantic-helpers.js"}
+{"version":3,"file":"semantic-helpers.js","names":[],"sources":["../src/semantic-helpers.ts"],"sourcesContent":["/**\n * Semantic convention helpers for OpenTelemetry\n *\n * Pre-configured trace helpers that follow OpenTelemetry semantic conventions\n * for common operation types. Reduces boilerplate and ensures consistency.\n *\n * Based on: https://opentelemetry.io/docs/specs/semconv/\n */\n\nimport { trace } from './functional';\nimport type { TraceContext } from './trace-context';\nimport type { Attributes } from '@opentelemetry/api';\n\n/**\n * Configuration for LLM (Large Language Model) operations\n *\n * Follows Gen AI semantic conventions:\n * https://opentelemetry.io/docs/specs/semconv/gen-ai/\n */\nexport interface LLMConfig {\n  /** Model name (e.g., 'gpt-4', 'claude-3-opus') */\n  model: string;\n  /** Operation type */\n  operation?: 'chat' | 'completion' | 'embedding';\n  /** Model provider (e.g., 'openai', 'anthropic', 'cohere') - maps to gen.ai.system */\n  provider?: string;\n  /** Additional attributes to add to the span */\n  attributes?: Attributes;\n}\n\n/**\n * Configuration for database operations\n *\n * Follows DB semantic conventions:\n * https://opentelemetry.io/docs/specs/semconv/database/\n */\nexport interface DBConfig {\n  /** Database system (e.g., 'postgresql', 'mongodb', 'redis') */\n  system: string;\n  /** Operation type (e.g., 'SELECT', 'INSERT', 'find', 'get') */\n  operation?: string;\n  /** Database name */\n  database?: string;\n  /** Collection/table name */\n  collection?: string;\n  /** Additional attributes to add to the span */\n  attributes?: Attributes;\n}\n\n/**\n * Configuration for HTTP client operations\n *\n * Follows HTTP semantic conventions:\n * https://opentelemetry.io/docs/specs/semconv/http/\n */\nexport interface HTTPConfig {\n  /** HTTP method (e.g., 'GET', 'POST') */\n  method?: string;\n  /** Target URL or URL template */\n  url?: string;\n  /** Additional attributes to add to the span */\n  attributes?: Attributes;\n}\n\n/**\n * Configuration for messaging operations\n *\n * Follows Messaging semantic conventions:\n * https://opentelemetry.io/docs/specs/semconv/messaging/\n */\nexport interface MessagingConfig {\n  /** Messaging system (e.g., 'kafka', 'rabbitmq', 'sqs') */\n  system: string;\n  /** Operation type */\n  operation?: 'publish' | 'receive' | 'process';\n  /** Destination name (queue/topic) */\n  destination?: string;\n  /** Additional attributes to add to the span */\n  attributes?: Attributes;\n}\n\n/**\n * Trace LLM operations with Gen AI semantic conventions\n *\n * Automatically adds standard attributes for LLM operations:\n * - gen.ai.request.model\n * - gen.ai.operation.name\n * - gen.ai.system\n *\n * **Use Cases:**\n * - Chat completions\n * - Text generation\n * - Embeddings\n * - Multi-step LLM workflows\n *\n * @param config - LLM operation configuration\n * @returns Traced function factory with Gen AI attributes\n *\n * @example Chat completion with OpenAI\n * ```typescript\n * import { traceLLM } from 'autotel/semantic-helpers'\n * import OpenAI from 'openai'\n *\n * const openai = new OpenAI()\n *\n * export const generateResponse = traceLLM({\n *   model: 'gpt-4-turbo',\n *   operation: 'chat',\n *   provider: 'openai'\n * })(ctx => async (prompt: string) => {\n *   const response = await openai.chat.completions.create({\n *     model: 'gpt-4-turbo',\n *     messages: [{ role: 'user', content: prompt }]\n *   })\n *\n *   // Add usage metrics to span\n *   ctx.setAttribute('gen.ai.usage.completion_tokens', response.usage?.completion_tokens)\n *   ctx.setAttribute('gen.ai.usage.prompt_tokens', response.usage?.prompt_tokens)\n *\n *   return response.choices[0].message.content\n * })\n * ```\n *\n * @example Anthropic Claude with streaming\n * ```typescript\n * import { traceLLM } from 'autotel/semantic-helpers'\n * import Anthropic from '@anthropic-ai/sdk'\n *\n * const anthropic = new Anthropic()\n *\n * export const streamResponse = traceLLM({\n *   model: 'claude-3-opus-20240229',\n *   operation: 'chat',\n *   provider: 'anthropic'\n * })(ctx => async function* (prompt: string) {\n *   const stream = await anthropic.messages.create({\n *     model: 'claude-3-opus-20240229',\n *     messages: [{ role: 'user', content: prompt }],\n *     stream: true,\n *     max_tokens: 1024\n *   })\n *\n *   let totalTokens = 0\n *   for await (const event of stream) {\n *     if (event.type === 'content_block_delta') {\n *       yield event.delta.text\n *     }\n *     if (event.type === 'message_stop') {\n *       ctx.setAttribute('gen.ai.usage.completion_tokens', event.message.usage.output_tokens)\n *       totalTokens = event.message.usage.output_tokens\n *     }\n *   }\n *\n *   return totalTokens\n * })\n * ```\n *\n * @example Embeddings\n * ```typescript\n * import { traceLLM } from 'autotel/semantic-helpers'\n * import { OpenAIEmbeddings } from '@langchain/openai'\n *\n * const embeddings = new OpenAIEmbeddings()\n *\n * export const embed = traceLLM({\n *   model: 'text-embedding-3-small',\n *   operation: 'embedding',\n *   provider: 'openai'\n * })(ctx => async (text: string) => {\n *   const result = await embeddings.embedQuery(text)\n *   ctx.setAttribute('gen.ai.response.embedding_length', result.length)\n *   return result\n * })\n * ```\n *\n * @public\n */\nexport function traceLLM<TArgs extends unknown[], TReturn>(config: LLMConfig) {\n  return (\n    fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n  ): ((...args: TArgs) => Promise<TReturn>) => {\n    return trace<TArgs, TReturn>((ctx) => {\n      // Set semantic convention attributes\n      ctx.setAttribute('gen.ai.request.model', config.model);\n      ctx.setAttribute('gen.ai.operation.name', config.operation || 'chat');\n      if (config.provider) {\n        ctx.setAttribute('gen.ai.system', config.provider);\n      }\n      if (config.attributes) {\n        for (const [key, value] of Object.entries(config.attributes)) {\n          if (value !== undefined && value !== null) {\n            // setAttribute only accepts primitives (string | number | boolean)\n            // Arrays and objects should be serialized\n            const attrValue =\n              typeof value === 'string' ||\n              typeof value === 'number' ||\n              typeof value === 'boolean'\n                ? value\n                : JSON.stringify(value);\n            ctx.setAttribute(key, attrValue);\n          }\n        }\n      }\n\n      // Call the user's factory to get their function and return it\n      return fnFactory(ctx);\n    });\n  };\n}\n\n/**\n * Trace database operations with DB semantic conventions\n *\n * Automatically adds standard attributes for database operations:\n * - db.system\n * - db.operation\n * - db.name\n * - db.collection.name (for NoSQL)\n *\n * **Use Cases:**\n * - SQL queries (PostgreSQL, MySQL, SQLite)\n * - NoSQL operations (MongoDB, DynamoDB, Redis)\n * - ORM queries (Prisma, TypeORM, Drizzle)\n *\n * @param config - Database operation configuration\n * @returns Traced function factory with DB attributes\n *\n * @example PostgreSQL query\n * ```typescript\n * import { traceDB } from 'autotel/semantic-helpers'\n * import { pool } from './db'\n *\n * export const getUser = traceDB({\n *   system: 'postgresql',\n *   operation: 'SELECT',\n *   database: 'app_db',\n *   collection: 'users'\n * })(ctx => async (userId: string) => {\n *   const query = 'SELECT * FROM users WHERE id = $1'\n *   ctx.setAttribute('db.statement', query)\n *\n *   const result = await pool.query(query, [userId])\n *   ctx.setAttribute('db.rows_affected', result.rowCount)\n *\n *   return result.rows[0]\n * })\n * ```\n *\n * @example MongoDB with Mongoose\n * ```typescript\n * import { traceDB } from 'autotel/semantic-helpers'\n * import { User } from './models/User'\n *\n * export const findUsers = traceDB({\n *   system: 'mongodb',\n *   operation: 'find',\n *   database: 'app_db',\n *   collection: 'users'\n * })(ctx => async (filter: object) => {\n *   ctx.setAttribute('db.mongodb.filter', JSON.stringify(filter))\n *\n *   const users = await User.find(filter).limit(100)\n *   ctx.setAttribute('db.response.count', users.length)\n *\n *   return users\n * })\n * ```\n *\n * @example Redis operations\n * ```typescript\n * import { traceDB } from 'autotel/semantic-helpers'\n * import { redis } from './redis'\n *\n * export const cacheGet = traceDB({\n *   system: 'redis',\n *   operation: 'GET'\n * })(ctx => async (key: string) => {\n *   ctx.setAttribute('db.redis.key', key)\n *\n *   const value = await redis.get(key)\n *   ctx.setAttribute('db.response.cache_hit', value !== null)\n *\n *   return value\n * })\n * ```\n *\n * @example Prisma with detailed query info\n * ```typescript\n * import { traceDB } from 'autotel/semantic-helpers'\n * import { prisma } from './prisma'\n *\n * export const createPost = traceDB({\n *   system: 'postgresql',\n *   operation: 'INSERT',\n *   database: 'app_db',\n *   collection: 'posts'\n * })(ctx => async (data: { title: string; content: string; authorId: string }) => {\n *   ctx.setAttribute('db.prisma.model', 'Post')\n *   ctx.setAttribute('db.prisma.action', 'create')\n *\n *   const post = await prisma.post.create({ data })\n *\n *   ctx.setAttribute('db.response.id', post.id)\n *   return post\n * })\n * ```\n *\n * @public\n */\nexport function traceDB<TArgs extends unknown[], TReturn>(config: DBConfig) {\n  return (\n    fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n  ): ((...args: TArgs) => Promise<TReturn>) => {\n    return trace<TArgs, TReturn>((ctx) => {\n      // Set semantic convention attributes\n      ctx.setAttribute('db.system', config.system);\n      if (config.operation) {\n        ctx.setAttribute('db.operation', config.operation);\n      }\n      if (config.database) {\n        ctx.setAttribute('db.name', config.database);\n      }\n      if (config.collection) {\n        ctx.setAttribute('db.collection.name', config.collection);\n      }\n      if (config.attributes) {\n        for (const [key, value] of Object.entries(config.attributes)) {\n          if (value !== undefined && value !== null) {\n            // setAttribute only accepts primitives (string | number | boolean)\n            // Arrays and objects should be serialized\n            const attrValue =\n              typeof value === 'string' ||\n              typeof value === 'number' ||\n              typeof value === 'boolean'\n                ? value\n                : JSON.stringify(value);\n            ctx.setAttribute(key, attrValue);\n          }\n        }\n      }\n\n      // Call the user's factory to get their function and return it\n      return fnFactory(ctx);\n    });\n  };\n}\n\n/**\n * Trace HTTP client operations with HTTP semantic conventions\n *\n * Automatically adds standard attributes for HTTP requests:\n * - http.request.method\n * - url.full\n *\n * **Use Cases:**\n * - External API calls\n * - Microservice communication\n * - Third-party integrations\n *\n * @param config - HTTP operation configuration\n * @returns Traced function factory with HTTP attributes\n *\n * @example Fetch API\n * ```typescript\n * import { traceHTTP } from 'autotel/semantic-helpers'\n *\n * export const fetchUser = traceHTTP({\n *   method: 'GET',\n *   url: 'https://api.example.com/users/:id'\n * })(ctx => async (userId: string) => {\n *   const url = `https://api.example.com/users/${userId}`\n *   ctx.setAttribute('url.full', url)\n *\n *   const response = await fetch(url)\n *   ctx.setAttribute('http.response.status_code', response.status)\n *\n *   if (!response.ok) {\n *     ctx.setAttribute('error', true)\n *     throw new Error(`HTTP ${response.status}: ${response.statusText}`)\n *   }\n *\n *   return response.json()\n * })\n * ```\n *\n * @example Axios with retry logic\n * ```typescript\n * import { traceHTTP } from 'autotel/semantic-helpers'\n * import axios from 'axios'\n *\n * export const sendWebhook = traceHTTP({\n *   method: 'POST',\n *   url: 'https://webhook.example.com/events'\n * })(ctx => async (payload: object) => {\n *   let attempts = 0\n *   const maxAttempts = 3\n *\n *   while (attempts < maxAttempts) {\n *     try {\n *       attempts++\n *       ctx.setAttribute('http.request.resend_count', attempts - 1)\n *\n *       const response = await axios.post('https://webhook.example.com/events', payload)\n *       ctx.setAttribute('http.response.status_code', response.status)\n *       return response.data\n *     } catch (error) {\n *       if (attempts >= maxAttempts) throw error\n *       await new Promise(resolve => setTimeout(resolve, 1000 * attempts))\n *     }\n *   }\n * })\n * ```\n *\n * @public\n */\nexport function traceHTTP<TArgs extends unknown[], TReturn>(\n  config: HTTPConfig,\n) {\n  return (\n    fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n  ): ((...args: TArgs) => Promise<TReturn>) => {\n    return trace<TArgs, TReturn>((ctx) => {\n      // Set semantic convention attributes\n      if (config.method) {\n        ctx.setAttribute('http.request.method', config.method);\n      }\n      if (config.url) {\n        ctx.setAttribute('url.full', config.url);\n      }\n      if (config.attributes) {\n        for (const [key, value] of Object.entries(config.attributes)) {\n          if (value !== undefined && value !== null) {\n            // setAttribute only accepts primitives (string | number | boolean)\n            // Arrays and objects should be serialized\n            const attrValue =\n              typeof value === 'string' ||\n              typeof value === 'number' ||\n              typeof value === 'boolean'\n                ? value\n                : JSON.stringify(value);\n            ctx.setAttribute(key, attrValue);\n          }\n        }\n      }\n\n      // Call the user's factory to get their function and return it\n      return fnFactory(ctx);\n    });\n  };\n}\n\n/**\n * Trace messaging operations with Messaging semantic conventions\n *\n * Automatically adds standard attributes for messaging:\n * - messaging.system\n * - messaging.operation\n * - messaging.destination.name\n *\n * **Use Cases:**\n * - Publishing messages to queues/topics\n * - Consuming messages from queues/topics\n * - Event-driven architectures\n *\n * @param config - Messaging operation configuration\n * @returns Traced function factory with Messaging attributes\n *\n * @example Publishing to Kafka\n * ```typescript\n * import { traceMessaging } from 'autotel/semantic-helpers'\n * import { kafka } from './kafka'\n *\n * const producer = kafka.producer()\n *\n * export const publishEvent = traceMessaging({\n *   system: 'kafka',\n *   operation: 'publish',\n *   destination: 'user-events'\n * })(ctx => async (event: { type: string; userId: string; data: object }) => {\n *   ctx.setAttribute('messaging.message.type', event.type)\n *   ctx.setAttribute('messaging.kafka.partition', 0)\n *\n *   await producer.send({\n *     topic: 'user-events',\n *     messages: [\n *       {\n *         key: event.userId,\n *         value: JSON.stringify(event.data)\n *       }\n *     ]\n *   })\n *\n *   ctx.setAttribute('messaging.message.id', event.userId)\n * })\n * ```\n *\n * @example Consuming from RabbitMQ\n * ```typescript\n * import { traceMessaging } from 'autotel/semantic-helpers'\n * import { channel } from './rabbitmq'\n *\n * export const processOrder = traceMessaging({\n *   system: 'rabbitmq',\n *   operation: 'process',\n *   destination: 'orders'\n * })(ctx => async (message: { orderId: string; items: object[] }) => {\n *   ctx.setAttribute('messaging.message.id', message.orderId)\n *   ctx.setAttribute('messaging.message.body.size', JSON.stringify(message).length)\n *\n *   // Process order logic\n *   const result = await processOrderInternal(message)\n *\n *   ctx.setAttribute('messaging.operation.result', 'success')\n *   return result\n * })\n * ```\n *\n * @example AWS SQS with batch processing\n * ```typescript\n * import { traceMessaging } from 'autotel/semantic-helpers'\n * import { SQS } from '@aws-sdk/client-sqs'\n *\n * const sqs = new SQS()\n *\n * export const sendBatch = traceMessaging({\n *   system: 'aws_sqs',\n *   operation: 'publish',\n *   destination: 'notifications-queue'\n * })(ctx => async (messages: Array<{ id: string; body: object }>) => {\n *   ctx.setAttribute('messaging.batch.message_count', messages.length)\n *\n *   const result = await sqs.sendMessageBatch({\n *     QueueUrl: process.env.QUEUE_URL,\n *     Entries: messages.map(msg => ({\n *       Id: msg.id,\n *       MessageBody: JSON.stringify(msg.body)\n *     }))\n *   })\n *\n *   ctx.setAttribute('messaging.operation.success_count', result.Successful?.length || 0)\n *   ctx.setAttribute('messaging.operation.failed_count', result.Failed?.length || 0)\n *\n *   return result\n * })\n * ```\n *\n * @public\n */\nexport function traceMessaging<TArgs extends unknown[], TReturn>(\n  config: MessagingConfig,\n) {\n  return (\n    fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>,\n  ): ((...args: TArgs) => Promise<TReturn>) => {\n    return trace<TArgs, TReturn>((ctx) => {\n      // Set semantic convention attributes\n      ctx.setAttribute('messaging.system', config.system);\n      if (config.operation) {\n        ctx.setAttribute('messaging.operation', config.operation);\n      }\n      if (config.destination) {\n        ctx.setAttribute('messaging.destination.name', config.destination);\n      }\n      if (config.attributes) {\n        for (const [key, value] of Object.entries(config.attributes)) {\n          if (value !== undefined && value !== null) {\n            // setAttribute only accepts primitives (string | number | boolean)\n            // Arrays and objects should be serialized\n            const attrValue =\n              typeof value === 'string' ||\n              typeof value === 'number' ||\n              typeof value === 'boolean'\n                ? value\n                : JSON.stringify(value);\n            ctx.setAttribute(key, attrValue);\n          }\n        }\n      }\n\n      // Call the user's factory to get their function and return it\n      return fnFactory(ctx);\n    });\n  };\n}\n"],"mappings":"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"}