autotel 3.6.0 → 4.0.0

package/dist/semantic-helpers.d.ts

@@ -1,31 +1,7 @@
-import { T as TraceContext } from './trace-context-DbGKd1Rn.js';
-import { Attributes } from '@opentelemetry/api';
+import { n as TraceContext } from "./trace-context-Cijqoi6e.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/
- */
-
-/**
- * Configuration for LLM (Large Language Model) operations
- *
- * Follows Gen AI semantic conventions:
- * 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;
-}
+//#region src/semantic-helpers.d.ts
 /**
  * Configuration for database operations
  *
@@ -33,16 +9,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 +27,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,112 +41,15 @@ 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
- *
- * 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
- */
-declare function traceLLM<TArgs extends unknown[], TReturn>(config: LLMConfig): (fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>) => ((...args: TArgs) => Promise<TReturn>);
 /**
  * Trace database operations with DB semantic conventions
  *
@@ -438,5 +317,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, MessagingConfig, traceDB, traceHTTP, 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":";;;;;;;;;AA6ByB;UAVR,QAAA;EAmBU;EAjBzB,MAAA;EAuBuB;EArBvB,SAAA;EAmBA;EAjBA,QAAA;EAmBa;EAjBb,UAAA;EAiBuB;EAfvB,UAAA,GAAa,UAAU;AAAA;;;;;;;UASR,UAAA;EAuBQ;EArBvB,MAAA;EA2Hc;EAzHd,GAAA;EAyHqB;EAvHrB,UAAA,GAAa,UAAU;AAAA;;;;;;;UASR,eAAA;EAiHgB;EA/G/B,MAAA;EA4G+C;EA1G/C,SAAA;EA0GwD;EAxGxD,WAAA;EA0Gc;EAxGd,UAAA,GAAa,UAAU;AAAA;;;;;;;;;AAyGgB;AAuGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKyC;AAgIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBApPzB,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,21 +1,327 @@
-export { traceDB, traceHTTP, traceLLM, traceMessaging } from './chunk-N25JDZSC.js';
-import './chunk-T7JO2TCP.js';
-import './chunk-HT5JQKN2.js';
-import './chunk-SEO6NAQT.js';
-import './chunk-66YJ66GG.js';
-import './chunk-LVIPBYFE.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 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, 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 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 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmKA,SAAgB,QAA0C,QAAkB;CAC1E,QACE,cAC2C;EAC3C,OAAO,OAAuB,QAAQ;GAEpC,IAAI,aAAa,aAAa,OAAO,MAAM;GAC3C,IAAI,OAAO,WACT,IAAI,aAAa,gBAAgB,OAAO,SAAS;GAEnD,IAAI,OAAO,UACT,IAAI,aAAa,WAAW,OAAO,QAAQ;GAE7C,IAAI,OAAO,YACT,IAAI,aAAa,sBAAsB,OAAO,UAAU;GAE1D,IAAI,OAAO,YACT;SAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,UAAU,GACzD,IAAI,UAAU,UAAa,UAAU,MAAM;KAGzC,MAAM,YACJ,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,YACb,QACA,KAAK,UAAU,KAAK;KAC1B,IAAI,aAAa,KAAK,SAAS;IACjC;GACF;GAIF,OAAO,UAAU,GAAG;EACtB,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,SAAgB,UACd,QACA;CACA,QACE,cAC2C;EAC3C,OAAO,OAAuB,QAAQ;GAEpC,IAAI,OAAO,QACT,IAAI,aAAa,uBAAuB,OAAO,MAAM;GAEvD,IAAI,OAAO,KACT,IAAI,aAAa,YAAY,OAAO,GAAG;GAEzC,IAAI,OAAO,YACT;SAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,UAAU,GACzD,IAAI,UAAU,UAAa,UAAU,MAAM;KAGzC,MAAM,YACJ,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,YACb,QACA,KAAK,UAAU,KAAK;KAC1B,IAAI,aAAa,KAAK,SAAS;IACjC;GACF;GAIF,OAAO,UAAU,GAAG;EACtB,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGA,SAAgB,eACd,QACA;CACA,QACE,cAC2C;EAC3C,OAAO,OAAuB,QAAQ;GAEpC,IAAI,aAAa,oBAAoB,OAAO,MAAM;GAClD,IAAI,OAAO,WACT,IAAI,aAAa,uBAAuB,OAAO,SAAS;GAE1D,IAAI,OAAO,aACT,IAAI,aAAa,8BAA8B,OAAO,WAAW;GAEnE,IAAI,OAAO,YACT;SAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,UAAU,GACzD,IAAI,UAAU,UAAa,UAAU,MAAM;KAGzC,MAAM,YACJ,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,YACb,QACA,KAAK,UAAU,KAAK;KAC1B,IAAI,aAAa,KAAK,SAAS;IACjC;GACF;GAIF,OAAO,UAAU,GAAG;EACtB,CAAC;CACH;AACF"}

package/dist/span-name-normalizer-8ZOGJuwv.d.cts

@@ -0,0 +1,70 @@
+import { ReadableSpan, Span, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { Context } from "@opentelemetry/api";
+
+//#region src/span-name-normalizer.d.ts
+/**
+ * Function to normalize a span name
+ * @param name - The original span name
+ * @returns The normalized span name
+ */
+type SpanNameNormalizerFn = (name: string) => string;
+/**
+ * Built-in normalizer preset names
+ */
+type SpanNameNormalizerPreset = 'rest-api' | 'graphql' | 'minimal';
+/**
+ * Normalizer config - either a function or a preset name
+ */
+type SpanNameNormalizerConfig = SpanNameNormalizerFn | SpanNameNormalizerPreset;
+interface SpanNameNormalizingProcessorOptions {
+  /**
+   * Normalizer function or preset name
+   */
+  normalizer: SpanNameNormalizerConfig;
+}
+/**
+ * Built-in normalizer patterns
+ */
+declare const NORMALIZER_PATTERNS: {
+  readonly numericId: RegExp;
+  readonly uuid: RegExp;
+  readonly shortUuid: RegExp;
+  readonly objectId: RegExp;
+  readonly hash: RegExp;
+  readonly isoDate: RegExp;
+  readonly timestamp: RegExp;
+  readonly email: RegExp;
+};
+/**
+ * Built-in normalizer presets
+ */
+declare const NORMALIZER_PRESETS: Record<SpanNameNormalizerPreset, SpanNameNormalizerFn>;
+/**
+ * Span processor that normalizes span names to reduce cardinality.
+ *
+ * Normalization happens in onStart() when we have access to the mutable Span.
+ * This allows us to call span.updateName() before the span is finalized.
+ *
+ * Common use cases:
+ * - REST APIs: /users/123/posts/456 → /users/:id/posts/:id
+ * - UUIDs: /items/550e8400-e29b-41d4-a716-446655440000 → /items/:uuid
+ * - Dates: /logs/2024-01-15 → /logs/:date
+ */
+declare class SpanNameNormalizingProcessor implements SpanProcessor {
+  private readonly wrappedProcessor;
+  private readonly normalizer;
+  constructor(wrappedProcessor: SpanProcessor, options: SpanNameNormalizingProcessorOptions);
+  /**
+   * Normalize span name on start (when Span is mutable)
+   */
+  onStart(span: Span, parentContext: Context): void;
+  /**
+   * Pass through onEnd unchanged
+   */
+  onEnd(span: ReadableSpan): void;
+  forceFlush(): Promise<void>;
+  shutdown(): Promise<void>;
+}
+//#endregion
+export { SpanNameNormalizerPreset as a, SpanNameNormalizerFn as i, NORMALIZER_PRESETS as n, SpanNameNormalizingProcessor as o, SpanNameNormalizerConfig as r, SpanNameNormalizingProcessorOptions as s, NORMALIZER_PATTERNS as t };
+//# sourceMappingURL=span-name-normalizer-8ZOGJuwv.d.cts.map

package/dist/span-name-normalizer-8ZOGJuwv.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span-name-normalizer-8ZOGJuwv.d.cts","names":[],"sources":["../src/span-name-normalizer.ts"],"mappings":";;;;;;;;;KAsCY,oBAAA,IAAwB,IAAY;;;;KAKpC,wBAAA;;;;KAKA,wBAAA,GACR,oBAAA,GACA,wBAAwB;AAAA,UAEX,mCAAA;;;;EAIf,UAAA,EAAY,wBAAwB;AAAA;;;;cAMhC,mBAAA;EAAA;;;;;;;;;;;;cA6BA,kBAAA,EAAoB,MAAA,CACxB,wBAAA,EACA,oBAAA;;;AAAoB;AAsEtB;;;;;;;;cAAa,4BAAA,YAAwC,aAAA;EAAA,iBAClC,gBAAA;EAAA,iBACA,UAAA;cAGf,gBAAA,EAAkB,aAAA,EAClB,OAAA,EAAS,mCAAA;EANqD;;;EAehE,OAAA,CAAQ,IAAA,EAAM,IAAA,EAAM,aAAA,EAAe,OAAA;;;;EAkBnC,KAAA,CAAM,IAAA,EAAM,YAAA;EAIZ,UAAA,IAAc,OAAA;EAId,QAAA,IAAY,OAAA;AAAA"}