autotel 3.6.0 → 4.0.0

package/dist/correlation-id.d.cts

@@ -1,8 +1,8 @@
-import * as _opentelemetry_api from '@opentelemetry/api';
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { AsyncLocalStorage } from "node:async_hooks";
 
+//#region src/correlation-id.d.ts
 type CorrelationStore = {
-    value: string;
+  value: string;
 };
 /**
  * Baggage key for correlation ID propagation
@@ -111,10 +111,11 @@ declare function setCorrelationId(correlationId: string): void;
  * });
  * ```
  */
-declare function setCorrelationIdInBaggage(correlationId: string): _opentelemetry_api.Context;
+declare function setCorrelationIdInBaggage(correlationId: string): import('@opentelemetry/api').Context;
 /**
  * Get the correlation storage instance (for internal use in init/shutdown)
  */
 declare function getCorrelationStorage(): AsyncLocalStorage<CorrelationStore>;
-
+//#endregion
 export { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getCorrelationStorage, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage };
+//# sourceMappingURL=correlation-id.d.cts.map

package/dist/correlation-id.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correlation-id.d.cts","names":[],"sources":["../src/correlation-id.ts"],"mappings":";;;KA4BK,gBAAA;EACH,KAAK;AAAA;AA+FiC;AAsBxC;;AAtBwC,cAnF3B,0BAAA;;;;;;;;AAyGiE;AAkB9E;;;;AAAsD;iBA5GtC,qBAAA;;;;AAsIuB;AAavC;;;;AAA2E;;;;;;;;;;;iBAvH3D,gBAAA;;;;;;;;;;;;;;;iBAwCA,wBAAA;;;;;;;;;;;;;;;;;;;iBAsBA,oBAAA,IAAwB,aAAA,UAAuB,EAAA,QAAU,CAAA,GAAI,CAAC;;;;;;;;;;;;;;;iBAkB9D,gBAAA,CAAiB,aAAqB;;;;;;;;;;;;;;;;;;;;;iBAwBtC,yBAAA,CACd,aAAA,wCAC8B,OAAO;;;;iBAavB,qBAAA,IAAyB,iBAAiB,CAAC,gBAAA"}

package/dist/correlation-id.d.ts

@@ -1,8 +1,8 @@
-import * as _opentelemetry_api from '@opentelemetry/api';
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { AsyncLocalStorage } from "node:async_hooks";
 
+//#region src/correlation-id.d.ts
 type CorrelationStore = {
-    value: string;
+  value: string;
 };
 /**
  * Baggage key for correlation ID propagation
@@ -111,10 +111,11 @@ declare function setCorrelationId(correlationId: string): void;
  * });
  * ```
  */
-declare function setCorrelationIdInBaggage(correlationId: string): _opentelemetry_api.Context;
+declare function setCorrelationIdInBaggage(correlationId: string): import('@opentelemetry/api').Context;
 /**
  * Get the correlation storage instance (for internal use in init/shutdown)
  */
 declare function getCorrelationStorage(): AsyncLocalStorage<CorrelationStore>;
-
+//#endregion
 export { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getCorrelationStorage, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage };
+//# sourceMappingURL=correlation-id.d.ts.map

package/dist/correlation-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correlation-id.d.ts","names":[],"sources":["../src/correlation-id.ts"],"mappings":";;;KA4BK,gBAAA;EACH,KAAK;AAAA;AA+FiC;AAsBxC;;AAtBwC,cAnF3B,0BAAA;;;;;;;;AAyGiE;AAkB9E;;;;AAAsD;iBA5GtC,qBAAA;;;;AAsIuB;AAavC;;;;AAA2E;;;;;;;;;;;iBAvH3D,gBAAA;;;;;;;;;;;;;;;iBAwCA,wBAAA;;;;;;;;;;;;;;;;;;;iBAsBA,oBAAA,IAAwB,aAAA,UAAuB,EAAA,QAAU,CAAA,GAAI,CAAC;;;;;;;;;;;;;;;iBAkB9D,gBAAA,CAAiB,aAAqB;;;;;;;;;;;;;;;;;;;;;iBAwBtC,yBAAA,CACd,aAAA,wCAC8B,OAAO;;;;iBAavB,qBAAA,IAAyB,iBAAiB,CAAC,gBAAA"}

package/dist/correlation-id.js

@@ -1,17 +1,3 @@
-export { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getCorrelationStorage, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage } from './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=correlation-id.js.map
-//# sourceMappingURL=correlation-id.js.map
+import { a as CORRELATION_ID_BAGGAGE_KEY, c as getCorrelationStorage, d as setCorrelationId, f as setCorrelationIdInBaggage, l as getOrCreateCorrelationId, o as generateCorrelationId, s as getCorrelationId, u as runWithCorrelationId } from "./track-nsKVy-pj.js";
+
+export { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getCorrelationStorage, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage };

package/dist/db.cjs

@@ -1,232 +1,267 @@
-'use strict';
-
-var chunkESLWRGAG_cjs = require('./chunk-ESLWRGAG.cjs');
-require('./chunk-YREV3LGG.cjs');
-var api = require('@opentelemetry/api');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_config = require('./config.cjs');
+let _opentelemetry_api = require("@opentelemetry/api");
 
+//#region src/db.ts
+/**
+* Database Instrumentation Helpers
+*
+* Optional import: Not included in main bundle
+* Import from: 'autotel/db'
+*
+* Provides functional utilities for database query instrumentation.
+* Works with Prisma, Drizzle, TypeORM, raw SQL, and more.
+*
+* @example
+* ```typescript
+* import { instrumentDatabase } from 'autotel/db'
+*
+* const db = drizzle(pool)
+* instrumentDatabase(db, { dbSystem: 'postgresql', dbName: 'myapp' })
+*
+* // Now all queries are automatically trace
+* await db.select().from(users)
+* ```
+*/
+/**
+* Helper: Trace a single database query
+*
+* @example
+* ```typescript
+* import { tracebQuery } from 'autotel/db'
+*
+* const users = await tracebQuery(
+*   'postgresql',
+*   'SELECT',
+*   () => db.query('SELECT * FROM users WHERE active = true')
+* )
+* ```
+*/
 async function tracebQuery(dbSystem, operation, fn, attributes) {
-  const config = chunkESLWRGAG_cjs.getConfig();
-  const tracer = config.tracer;
-  const spanName = `${dbSystem}.${operation}`;
-  return tracer.startActiveSpan(spanName, async (span) => {
-    const startTime = performance.now();
-    try {
-      span.setAttributes({
-        "db.system": dbSystem,
-        "db.operation": operation,
-        ...attributes
-      });
-      const result = await fn();
-      const duration = performance.now() - startTime;
-      span.setStatus({ code: api.SpanStatusCode.OK });
-      span.setAttribute("db.duration_ms", duration);
-      if (Array.isArray(result)) {
-        span.setAttribute("db.result_count", result.length);
-      }
-      return result;
-    } catch (error) {
-      const duration = performance.now() - startTime;
-      span.setStatus({
-        code: api.SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : "Unknown error"
-      });
-      span.setAttributes({
-        "db.duration_ms": duration,
-        "error.type": error instanceof Error ? error.constructor.name : "Unknown",
-        "error.message": error instanceof Error ? error.message : "Unknown error"
-      });
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
+	const tracer = require_config.getConfig().tracer;
+	const spanName = `${dbSystem}.${operation}`;
+	return tracer.startActiveSpan(spanName, async (span) => {
+		const startTime = performance.now();
+		try {
+			span.setAttributes({
+				"db.system": dbSystem,
+				"db.operation": operation,
+				...attributes
+			});
+			const result = await fn();
+			const duration = performance.now() - startTime;
+			span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
+			span.setAttribute("db.duration_ms", duration);
+			if (Array.isArray(result)) span.setAttribute("db.result_count", result.length);
+			return result;
+		} catch (error) {
+			const duration = performance.now() - startTime;
+			span.setStatus({
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
+				message: error instanceof Error ? error.message : "Unknown error"
+			});
+			span.setAttributes({
+				"db.duration_ms": duration,
+				"error.type": error instanceof Error ? error.constructor.name : "Unknown",
+				"error.message": error instanceof Error ? error.message : "Unknown error"
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
 }
 function inferDbOperation(methodName) {
-  const lower = methodName.toLowerCase();
-  if (lower.includes("find") || lower.includes("get") || lower.includes("list"))
-    return "SELECT";
-  if (lower.includes("create") || lower.includes("insert")) return "INSERT";
-  if (lower.includes("update") || lower.includes("modify")) return "UPDATE";
-  if (lower.includes("delete") || lower.includes("remove")) return "DELETE";
-  if (lower.includes("count")) return "COUNT";
-  return "QUERY";
+	const lower = methodName.toLowerCase();
+	if (lower.includes("find") || lower.includes("get") || lower.includes("list")) return "SELECT";
+	if (lower.includes("create") || lower.includes("insert")) return "INSERT";
+	if (lower.includes("update") || lower.includes("modify")) return "UPDATE";
+	if (lower.includes("delete") || lower.includes("remove")) return "DELETE";
+	if (lower.includes("count")) return "COUNT";
+	return "QUERY";
 }
 function inferTableName(methodName) {
-  const patterns = [
-    /find([A-Z][a-zA-Z]+)/,
-    /get([A-Z][a-zA-Z]+)/,
-    /list([A-Z][a-zA-Z]+)/,
-    /create([A-Z][a-zA-Z]+)/,
-    /update([A-Z][a-zA-Z]+)/,
-    /delete([A-Z][a-zA-Z]+)/,
-    /remove([A-Z][a-zA-Z]+)/
-  ];
-  for (const pattern of patterns) {
-    const match = methodName.match(pattern);
-    if (match && match[1]) {
-      return match[1].toLowerCase();
-    }
-  }
-  return void 0;
+	for (const pattern of [
+		/find([A-Z][a-zA-Z]+)/,
+		/get([A-Z][a-zA-Z]+)/,
+		/list([A-Z][a-zA-Z]+)/,
+		/create([A-Z][a-zA-Z]+)/,
+		/update([A-Z][a-zA-Z]+)/,
+		/delete([A-Z][a-zA-Z]+)/,
+		/remove([A-Z][a-zA-Z]+)/
+	]) {
+		const match = methodName.match(pattern);
+		if (match && match[1]) return match[1].toLowerCase();
+	}
 }
 function sanitizeSqlQuery(query) {
-  return query.replaceAll(/'[^']*'/g, "'?'").replaceAll(/"[^"]*"/g, '"?"').replaceAll(/\b\d+\b/g, "?").trim();
+	return query.replaceAll(/'[^']*'/g, "'?'").replaceAll(/"[^"]*"/g, "\"?\"").replaceAll(/\b\d+\b/g, "?").trim();
 }
-var DB_OPERATIONS = {
-  SELECT: "SELECT",
-  INSERT: "INSERT",
-  UPDATE: "UPDATE",
-  DELETE: "DELETE",
-  COUNT: "COUNT",
-  AGGREGATE: "AGGREGATE"
+/**
+* Common database operation metrics
+*/
+const DB_OPERATIONS = {
+	SELECT: "SELECT",
+	INSERT: "INSERT",
+	UPDATE: "UPDATE",
+	DELETE: "DELETE",
+	COUNT: "COUNT",
+	AGGREGATE: "AGGREGATE"
 };
-var DB_SYSTEMS = {
-  POSTGRESQL: "postgresql",
-  MYSQL: "mysql",
-  MONGODB: "mongodb",
-  REDIS: "redis",
-  SQLITE: "sqlite",
-  MSSQL: "mssql"
+/**
+* Common database systems
+*/
+const DB_SYSTEMS = {
+	POSTGRESQL: "postgresql",
+	MYSQL: "mysql",
+	MONGODB: "mongodb",
+	REDIS: "redis",
+	SQLITE: "sqlite",
+	MSSQL: "mssql"
 };
-var INSTRUMENTED_SYMBOL = /* @__PURE__ */ Symbol.for("autotel.db.instrumented");
+const INSTRUMENTED_SYMBOL = Symbol.for("autotel.db.instrumented");
+/**
+* Instrument a database client instance with OpenTelemetry tracing
+*
+* This is a function-based alternative to @DbInstrumented decorator.
+* Modifies the client in-place and returns it (idempotent - safe to call multiple times).
+*
+* Inspired by otel-drizzle and other otel instrumentation packages.
+*
+* @example Drizzle ORM
+* ```typescript
+* import { drizzle } from 'drizzle-orm/node-postgres'
+* import { instrumentDatabase } from 'autotel/db'
+*
+* const db = drizzle(pool)
+* instrumentDatabase(db, { dbSystem: 'postgresql', dbName: 'myapp' })
+*
+* // Now all db queries are automatically trace
+* await db.select().from(users)
+* ```
+*
+* @example Prisma
+* ```typescript
+* import { PrismaClient } from '@prisma/client'
+* import { instrumentDatabase } from 'autotel/db'
+*
+* const prisma = new PrismaClient()
+* instrumentDatabase(prisma, {
+*   dbSystem: 'postgresql',
+*   methods: ['findMany', 'findUnique', 'create', 'update', 'delete']
+* })
+*
+* // All specified methods are trace
+* await prisma.user.findMany()
+* ```
+*
+* @example Generic database client
+* ```typescript
+* import { instrumentDatabase } from 'autotel/db'
+*
+* const db = createDatabaseClient()
+* instrumentDatabase(db, {
+*   dbSystem: 'mongodb',
+*   methods: ['find', 'findOne', 'insertOne', 'updateOne', 'deleteOne']
+* })
+* ```
+*/
 function instrumentDatabase(client, options) {
-  if (client[INSTRUMENTED_SYMBOL]) {
-    return client;
-  }
-  const {
-    dbSystem,
-    dbName,
-    methods,
-    skipMethods = [],
-    sanitizeQuery = true,
-    slowQueryThresholdMs = 1e3
-  } = options;
-  const config = chunkESLWRGAG_cjs.getConfig();
-  const tracer = config.tracer;
-  const methodsToInstrument = methods || extractDatabaseMethods(client);
-  const skipSet = new Set(skipMethods);
-  for (const methodName of methodsToInstrument) {
-    if (skipSet.has(methodName)) continue;
-    if (methodName.startsWith("_")) continue;
-    const method = client[methodName];
-    if (typeof method !== "function") continue;
-    const originalMethod = method;
-    client[methodName] = async function(...args) {
-      const operation = inferDbOperation(methodName);
-      const table = inferTableName(methodName);
-      const spanName = table ? `${dbSystem}.${operation} ${table}` : `${dbSystem}.${operation}`;
-      return tracer.startActiveSpan(spanName, async (span) => {
-        const startTime = performance.now();
-        try {
-          span.setAttributes({
-            "db.system": dbSystem,
-            "db.operation": operation
-          });
-          if (dbName) {
-            span.setAttribute("db.name", dbName);
-          }
-          if (table) {
-            span.setAttribute("db.sql.table", table);
-          }
-          const query = extractQueryFromArgs(args);
-          if (query) {
-            span.setAttribute(
-              "db.statement",
-              sanitizeQuery ? sanitizeSqlQuery(query) : query
-            );
-          }
-          const result = await originalMethod.apply(this, args);
-          const duration = performance.now() - startTime;
-          span.setStatus({ code: api.SpanStatusCode.OK });
-          span.setAttributes({
-            "db.duration_ms": duration
-          });
-          if (duration > slowQueryThresholdMs) {
-            span.setAttribute("db.slow_query", true);
-            span.setAttribute(
-              "db.slow_query_threshold_ms",
-              slowQueryThresholdMs
-            );
-          }
-          if (Array.isArray(result)) {
-            span.setAttribute("db.result_count", result.length);
-          }
-          return result;
-        } catch (error) {
-          const duration = performance.now() - startTime;
-          span.setStatus({
-            code: api.SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : "Unknown error"
-          });
-          span.setAttributes({
-            "db.duration_ms": duration,
-            "error.type": error instanceof Error ? error.constructor.name : "Unknown",
-            "error.message": error instanceof Error ? error.message : "Unknown error"
-          });
-          span.recordException(
-            error instanceof Error ? error : new Error(String(error))
-          );
-          throw error;
-        } finally {
-          span.end();
-        }
-      });
-    };
-    Object.defineProperty(client[methodName], "name", {
-      value: methodName,
-      configurable: true
-    });
-  }
-  client[INSTRUMENTED_SYMBOL] = true;
-  return client;
+	if (client[INSTRUMENTED_SYMBOL]) return client;
+	const { dbSystem, dbName, methods, skipMethods = [], sanitizeQuery = true, slowQueryThresholdMs = 1e3 } = options;
+	const tracer = require_config.getConfig().tracer;
+	const methodsToInstrument = methods || extractDatabaseMethods(client);
+	const skipSet = new Set(skipMethods);
+	for (const methodName of methodsToInstrument) {
+		if (skipSet.has(methodName)) continue;
+		if (methodName.startsWith("_")) continue;
+		const method = client[methodName];
+		if (typeof method !== "function") continue;
+		const originalMethod = method;
+		client[methodName] = async function(...args) {
+			const operation = inferDbOperation(methodName);
+			const table = inferTableName(methodName);
+			const spanName = table ? `${dbSystem}.${operation} ${table}` : `${dbSystem}.${operation}`;
+			return tracer.startActiveSpan(spanName, async (span) => {
+				const startTime = performance.now();
+				try {
+					span.setAttributes({
+						"db.system": dbSystem,
+						"db.operation": operation
+					});
+					if (dbName) span.setAttribute("db.name", dbName);
+					if (table) span.setAttribute("db.sql.table", table);
+					const query = extractQueryFromArgs(args);
+					if (query) span.setAttribute("db.statement", sanitizeQuery ? sanitizeSqlQuery(query) : query);
+					const result = await originalMethod.apply(this, args);
+					const duration = performance.now() - startTime;
+					span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
+					span.setAttributes({ "db.duration_ms": duration });
+					if (duration > slowQueryThresholdMs) {
+						span.setAttribute("db.slow_query", true);
+						span.setAttribute("db.slow_query_threshold_ms", slowQueryThresholdMs);
+					}
+					if (Array.isArray(result)) span.setAttribute("db.result_count", result.length);
+					return result;
+				} catch (error) {
+					const duration = performance.now() - startTime;
+					span.setStatus({
+						code: _opentelemetry_api.SpanStatusCode.ERROR,
+						message: error instanceof Error ? error.message : "Unknown error"
+					});
+					span.setAttributes({
+						"db.duration_ms": duration,
+						"error.type": error instanceof Error ? error.constructor.name : "Unknown",
+						"error.message": error instanceof Error ? error.message : "Unknown error"
+					});
+					span.recordException(error instanceof Error ? error : new Error(String(error)));
+					throw error;
+				} finally {
+					span.end();
+				}
+			});
+		};
+		Object.defineProperty(client[methodName], "name", {
+			value: methodName,
+			configurable: true
+		});
+	}
+	client[INSTRUMENTED_SYMBOL] = true;
+	return client;
 }
+/**
+* Extract method names from a database client that should be instrumented
+*/
 function extractDatabaseMethods(client) {
-  const methods = [];
-  const proto = Object.getPrototypeOf(client);
-  for (const key of Object.getOwnPropertyNames(client)) {
-    if (typeof client[key] === "function" && !key.startsWith("_")) {
-      methods.push(key);
-    }
-  }
-  if (proto) {
-    for (const key of Object.getOwnPropertyNames(proto)) {
-      if (typeof proto[key] === "function" && !key.startsWith("_") && key !== "constructor") {
-        methods.push(key);
-      }
-    }
-  }
-  return [...new Set(methods)];
+	const methods = [];
+	const proto = Object.getPrototypeOf(client);
+	for (const key of Object.getOwnPropertyNames(client)) if (typeof client[key] === "function" && !key.startsWith("_")) methods.push(key);
+	if (proto) {
+		for (const key of Object.getOwnPropertyNames(proto)) if (typeof proto[key] === "function" && !key.startsWith("_") && key !== "constructor") methods.push(key);
+	}
+	return [...new Set(methods)];
 }
+/**
+* Try to extract SQL query from common argument patterns
+*/
 function extractQueryFromArgs(args) {
-  if (args.length === 0) return void 0;
-  const firstArg = args[0];
-  if (typeof firstArg === "string") {
-    return firstArg;
-  }
-  if (firstArg && typeof firstArg === "object") {
-    if ("sql" in firstArg && typeof firstArg.sql === "string") {
-      return firstArg.sql;
-    }
-    if ("text" in firstArg && typeof firstArg.text === "string") {
-      return firstArg.text;
-    }
-    if ("toQuery" in firstArg && typeof firstArg.toQuery === "function") {
-      try {
-        const queryResult = firstArg.toQuery();
-        if (typeof queryResult === "string") return queryResult;
-        if (queryResult && typeof queryResult === "object" && "sql" in queryResult) {
-          return queryResult.sql;
-        }
-      } catch {
-      }
-    }
-  }
-  return void 0;
+	if (args.length === 0) return void 0;
+	const firstArg = args[0];
+	if (typeof firstArg === "string") return firstArg;
+	if (firstArg && typeof firstArg === "object") {
+		if ("sql" in firstArg && typeof firstArg.sql === "string") return firstArg.sql;
+		if ("text" in firstArg && typeof firstArg.text === "string") return firstArg.text;
+		if ("toQuery" in firstArg && typeof firstArg.toQuery === "function") try {
+			const queryResult = firstArg.toQuery();
+			if (typeof queryResult === "string") return queryResult;
+			if (queryResult && typeof queryResult === "object" && "sql" in queryResult) return queryResult.sql;
+		} catch {}
+	}
 }
 
+//#endregion
 exports.DB_OPERATIONS = DB_OPERATIONS;
 exports.DB_SYSTEMS = DB_SYSTEMS;
 exports.instrumentDatabase = instrumentDatabase;
 exports.tracebQuery = tracebQuery;
-//# sourceMappingURL=db.cjs.map
 //# sourceMappingURL=db.cjs.map