autotel 3.6.0 → 3.7.0

package/dist/attributes-D3etyRVc.cjs

@@ -0,0 +1,713 @@
+const require_attribute_redacting_processor = require('./attribute-redacting-processor.cjs');
+const require_registry = require('./registry-JZg2J3RZ.cjs');
+let _opentelemetry_resources = require("@opentelemetry/resources");
+
+//#region src/attributes/builders.ts
+/**
+* Attribute builders for constructing OpenTelemetry attributes
+* Provides both key builders (Pattern A) and object builders (Pattern B)
+*
+* @example Pattern A: Key builders
+* ```typescript
+* attrs.user.id('123')                              // { 'user.id': '123' }
+* attrs.user.email('user@example.com')                 // { 'user.email': 'user@example.com' }
+* attrs.http.request.method('GET')                   // { 'http.request.method': 'GET' }
+* attrs.http.response.statusCode(200)                 // { 'http.response.status_code': 200 }
+* ```
+*
+* @example Pattern B: Object builders
+* ```typescript
+* attrs.user({ id: '123', email: 'user@example.com' })
+* attrs.http.server({ method: 'GET', route: '/users/:id', statusCode: 200 })
+* attrs.db.client({ system: 'postgresql', operation: 'SELECT', collectionName: 'users' })
+* ```
+*/
+const attrs = {
+	user: {
+		id: (value) => ({ [require_registry.UserAttributes.id]: value }),
+		email: (value) => ({ [require_registry.UserAttributes.email]: value }),
+		name: (value) => ({ [require_registry.UserAttributes.name]: value }),
+		fullName: (value) => ({ [require_registry.UserAttributes.fullName]: value }),
+		hash: (value) => ({ [require_registry.UserAttributes.hash]: value }),
+		roles: (value) => ({ [require_registry.UserAttributes.roles]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.id !== void 0) result[require_registry.UserAttributes.id] = data.id;
+			if (data.email !== void 0) result[require_registry.UserAttributes.email] = data.email;
+			if (data.name !== void 0) result[require_registry.UserAttributes.name] = data.name;
+			if (data.fullName !== void 0) result[require_registry.UserAttributes.fullName] = data.fullName;
+			if (data.hash !== void 0) result[require_registry.UserAttributes.hash] = data.hash;
+			if (data.roles !== void 0) result[require_registry.UserAttributes.roles] = data.roles;
+			return result;
+		}
+	},
+	session: {
+		id: (value) => ({ [require_registry.SessionAttributes.id]: value }),
+		previousId: (value) => ({ [require_registry.SessionAttributes.previousId]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.id !== void 0) result[require_registry.SessionAttributes.id] = data.id;
+			if (data.previousId !== void 0) result[require_registry.SessionAttributes.previousId] = data.previousId;
+			return result;
+		}
+	},
+	device: {
+		id: (value) => ({ [require_registry.DeviceAttributes.id]: value }),
+		manufacturer: (value) => ({ [require_registry.DeviceAttributes.manufacturer]: value }),
+		modelIdentifier: (value) => ({ [require_registry.DeviceAttributes.modelIdentifier]: value }),
+		modelName: (value) => ({ [require_registry.DeviceAttributes.modelName]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.id !== void 0) result[require_registry.DeviceAttributes.id] = data.id;
+			if (data.manufacturer !== void 0) result[require_registry.DeviceAttributes.manufacturer] = data.manufacturer;
+			if (data.modelIdentifier !== void 0) result[require_registry.DeviceAttributes.modelIdentifier] = data.modelIdentifier;
+			if (data.modelName !== void 0) result[require_registry.DeviceAttributes.modelName] = data.modelName;
+			return result;
+		}
+	},
+	http: {
+		request: {
+			method: (value) => ({ [require_registry.HTTPAttributes.requestMethod]: value }),
+			methodOriginal: (value) => ({ [require_registry.HTTPAttributes.requestMethodOriginal]: value }),
+			resendCount: (value) => ({ [require_registry.HTTPAttributes.requestResendCount]: value }),
+			size: (value) => ({ [require_registry.HTTPAttributes.requestSize]: value }),
+			bodySize: (value) => ({ [require_registry.HTTPAttributes.requestBodySize]: value })
+		},
+		response: {
+			statusCode: (value) => ({ [require_registry.HTTPAttributes.responseStatusCode]: value }),
+			size: (value) => ({ [require_registry.HTTPAttributes.responseSize]: value }),
+			bodySize: (value) => ({ [require_registry.HTTPAttributes.responseBodySize]: value })
+		},
+		route: (value) => ({ [require_registry.HTTPAttributes.route]: value }),
+		connectionState: (value) => ({ [require_registry.HTTPAttributes.connectionState]: value }),
+		server: (data) => {
+			const result = {};
+			if (data.method !== void 0) result[require_registry.HTTPAttributes.requestMethod] = data.method;
+			if (data.route !== void 0) result[require_registry.HTTPAttributes.route] = data.route;
+			if (data.statusCode !== void 0) result[require_registry.HTTPAttributes.responseStatusCode] = data.statusCode;
+			if (data.bodySize !== void 0) result[require_registry.HTTPAttributes.requestBodySize] = data.bodySize;
+			if (data.requestSize !== void 0) result[require_registry.HTTPAttributes.requestSize] = data.requestSize;
+			if (data.responseSize !== void 0) result[require_registry.HTTPAttributes.responseSize] = data.responseSize;
+			if (data.resendCount !== void 0) result[require_registry.HTTPAttributes.requestResendCount] = data.resendCount;
+			return result;
+		},
+		client: (data) => {
+			const result = {};
+			if (data.method !== void 0) result[require_registry.HTTPAttributes.requestMethod] = data.method;
+			if (data.url !== void 0) result[require_registry.HTTPAttributes.route] = data.url;
+			if (data.statusCode !== void 0) result[require_registry.HTTPAttributes.responseStatusCode] = data.statusCode;
+			return result;
+		}
+	},
+	db: { client: {
+		system: (value) => ({ [require_registry.DBAttributes.systemName]: value }),
+		operation: (value) => ({ [require_registry.DBAttributes.operationName]: value }),
+		collectionName: (value) => ({ [require_registry.DBAttributes.collectionName]: value }),
+		namespace: (value) => ({ [require_registry.DBAttributes.namespace]: value }),
+		statement: (value) => ({ [require_registry.DBAttributes.statement]: value }),
+		querySummary: (value) => ({ [require_registry.DBAttributes.querySummary]: value }),
+		queryText: (value) => ({ [require_registry.DBAttributes.queryText]: value }),
+		responseStatus: (value) => ({ [require_registry.DBAttributes.responseStatusCode]: value }),
+		rowsReturned: (value) => ({ [require_registry.DBAttributes.responseReturnedRows]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.system !== void 0) result[require_registry.DBAttributes.systemName] = data.system;
+			if (data.operation !== void 0) result[require_registry.DBAttributes.operationName] = data.operation;
+			if (data.collectionName !== void 0) result[require_registry.DBAttributes.collectionName] = data.collectionName;
+			if (data.name !== void 0) result[require_registry.DBAttributes.namespace] = data.name;
+			if (data.namespace !== void 0) result[require_registry.DBAttributes.namespace] = data.namespace;
+			if (data.statement !== void 0) result[require_registry.DBAttributes.statement] = data.statement;
+			if (data.querySummary !== void 0) result[require_registry.DBAttributes.querySummary] = data.querySummary;
+			if (data.queryText !== void 0) result[require_registry.DBAttributes.queryText] = data.queryText;
+			if (data.responseStatus !== void 0) result[require_registry.DBAttributes.responseStatusCode] = data.responseStatus;
+			if (data.rowsReturned !== void 0) result[require_registry.DBAttributes.responseReturnedRows] = data.rowsReturned;
+			return result;
+		}
+	} },
+	service: {
+		name: (value) => ({ [require_registry.ServiceAttributes.name]: value }),
+		instance: (value) => ({ [require_registry.ServiceAttributes.instance]: value }),
+		version: (value) => ({ [require_registry.ServiceAttributes.version]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.name !== void 0) result[require_registry.ServiceAttributes.name] = data.name;
+			if (data.instance !== void 0) result[require_registry.ServiceAttributes.instance] = data.instance;
+			if (data.version !== void 0) result[require_registry.ServiceAttributes.version] = data.version;
+			return result;
+		}
+	},
+	network: {
+		peerAddress: (value) => ({ [require_registry.NetworkAttributes.peerAddress]: value }),
+		peerPort: (value) => ({ [require_registry.NetworkAttributes.peerPort]: value }),
+		transport: (value) => ({ [require_registry.NetworkAttributes.transport]: value }),
+		protocolName: (value) => ({ [require_registry.NetworkAttributes.protocolName]: value }),
+		protocolVersion: (value) => ({ [require_registry.NetworkAttributes.protocolVersion]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.peerAddress !== void 0) result[require_registry.NetworkAttributes.peerAddress] = data.peerAddress;
+			if (data.peerPort !== void 0) result[require_registry.NetworkAttributes.peerPort] = data.peerPort;
+			if (data.transport !== void 0) result[require_registry.NetworkAttributes.transport] = data.transport;
+			if (data.protocolName !== void 0) result[require_registry.NetworkAttributes.protocolName] = data.protocolName;
+			if (data.protocolVersion !== void 0) result[require_registry.NetworkAttributes.protocolVersion] = data.protocolVersion;
+			return result;
+		}
+	},
+	server: {
+		address: (value) => ({ [require_registry.ServerAddressAttributes.address]: value }),
+		port: (value) => ({ [require_registry.ServerAddressAttributes.port]: value }),
+		socketAddress: (value) => ({ [require_registry.ServerAddressAttributes.socketAddress]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.address !== void 0) result[require_registry.ServerAddressAttributes.address] = data.address;
+			if (data.port !== void 0) result[require_registry.ServerAddressAttributes.port] = data.port;
+			if (data.socketAddress !== void 0) result[require_registry.ServerAddressAttributes.socketAddress] = data.socketAddress;
+			return result;
+		}
+	},
+	url: {
+		scheme: (value) => ({ [require_registry.URLAttributes.scheme]: value }),
+		full: (value) => ({ [require_registry.URLAttributes.full]: value }),
+		path: (value) => ({ [require_registry.URLAttributes.path]: value }),
+		query: (value) => ({ [require_registry.URLAttributes.query]: value }),
+		fragment: (value) => ({ [require_registry.URLAttributes.fragment]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.scheme !== void 0) result[require_registry.URLAttributes.scheme] = data.scheme;
+			if (data.full !== void 0) result[require_registry.URLAttributes.full] = data.full;
+			if (data.path !== void 0) result[require_registry.URLAttributes.path] = data.path;
+			if (data.query !== void 0) result[require_registry.URLAttributes.query] = data.query;
+			if (data.fragment !== void 0) result[require_registry.URLAttributes.fragment] = data.fragment;
+			return result;
+		}
+	},
+	error: {
+		type: (value) => ({ [require_registry.ErrorAttributes.type]: value }),
+		message: (value) => ({ [require_registry.ErrorAttributes.message]: value }),
+		stackTrace: (value) => ({ [require_registry.ErrorAttributes.stackTrace]: value }),
+		code: (value) => ({ [require_registry.ErrorAttributes.code]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.type !== void 0) result[require_registry.ErrorAttributes.type] = data.type;
+			if (data.message !== void 0) result[require_registry.ErrorAttributes.message] = data.message;
+			if (data.stackTrace !== void 0) result[require_registry.ErrorAttributes.stackTrace] = data.stackTrace;
+			if (data.code !== void 0) result[require_registry.ErrorAttributes.code] = data.code;
+			return result;
+		}
+	},
+	exception: {
+		escaped: (value) => ({ [require_registry.ExceptionAttributes.escaped]: value }),
+		message: (value) => ({ [require_registry.ExceptionAttributes.message]: value }),
+		stackTrace: (value) => ({ [require_registry.ExceptionAttributes.stackTrace]: value }),
+		type: (value) => ({ [require_registry.ExceptionAttributes.type]: value }),
+		moduleName: (value) => ({ [require_registry.ExceptionAttributes.moduleName]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.escaped !== void 0) result[require_registry.ExceptionAttributes.escaped] = data.escaped;
+			if (data.message !== void 0) result[require_registry.ExceptionAttributes.message] = data.message;
+			if (data.stackTrace !== void 0) result[require_registry.ExceptionAttributes.stackTrace] = data.stackTrace;
+			if (data.type !== void 0) result[require_registry.ExceptionAttributes.type] = data.type;
+			if (data.moduleName !== void 0) result[require_registry.ExceptionAttributes.moduleName] = data.moduleName;
+			return result;
+		}
+	},
+	process: {
+		pid: (value) => ({ [require_registry.ProcessAttributes.pid]: value }),
+		executablePath: (value) => ({ [require_registry.ProcessAttributes.executablePath]: value }),
+		command: (value) => ({ [require_registry.ProcessAttributes.command]: value }),
+		owner: (value) => ({ [require_registry.ProcessAttributes.owner]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.pid !== void 0) result[require_registry.ProcessAttributes.pid] = data.pid;
+			if (data.executablePath !== void 0) result[require_registry.ProcessAttributes.executablePath] = data.executablePath;
+			if (data.command !== void 0) result[require_registry.ProcessAttributes.command] = data.command;
+			if (data.owner !== void 0) result[require_registry.ProcessAttributes.owner] = data.owner;
+			return result;
+		}
+	},
+	thread: {
+		id: (value) => ({ [require_registry.ThreadAttributes.id]: value }),
+		name: (value) => ({ [require_registry.ThreadAttributes.name]: value })
+	},
+	container: {
+		id: (value) => ({ [require_registry.ContainerAttributes.id]: value }),
+		name: (value) => ({ [require_registry.ContainerAttributes.name]: value }),
+		image: (value) => ({ [require_registry.ContainerAttributes.image]: value }),
+		tag: (value) => ({ [require_registry.ContainerAttributes.tag]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.id !== void 0) result[require_registry.ContainerAttributes.id] = data.id;
+			if (data.name !== void 0) result[require_registry.ContainerAttributes.name] = data.name;
+			if (data.image !== void 0) result[require_registry.ContainerAttributes.image] = data.image;
+			if (data.tag !== void 0) result[require_registry.ContainerAttributes.tag] = data.tag;
+			return result;
+		}
+	},
+	k8s: {
+		podName: (value) => ({ [require_registry.K8sAttributes.podName]: value }),
+		namespaceName: (value) => ({ [require_registry.K8sAttributes.namespaceName]: value }),
+		deploymentName: (value) => ({ [require_registry.K8sAttributes.deploymentName]: value }),
+		state: (value) => ({ [require_registry.K8sAttributes.state]: value })
+	},
+	cloud: {
+		provider: (value) => ({ [require_registry.CloudAttributes.provider]: value }),
+		accountId: (value) => ({ [require_registry.CloudAttributes.accountId]: value }),
+		region: (value) => ({ [require_registry.CloudAttributes.region]: value }),
+		availabilityZone: (value) => ({ [require_registry.CloudAttributes.availabilityZone]: value }),
+		platform: (value) => ({ [require_registry.CloudAttributes.platform]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.provider !== void 0) result[require_registry.CloudAttributes.provider] = data.provider;
+			if (data.accountId !== void 0) result[require_registry.CloudAttributes.accountId] = data.accountId;
+			if (data.region !== void 0) result[require_registry.CloudAttributes.region] = data.region;
+			if (data.availabilityZone !== void 0) result[require_registry.CloudAttributes.availabilityZone] = data.availabilityZone;
+			if (data.platform !== void 0) result[require_registry.CloudAttributes.platform] = data.platform;
+			return result;
+		}
+	},
+	faas: {
+		name: (value) => ({ [require_registry.FaaSAttributes.name]: value }),
+		version: (value) => ({ [require_registry.FaaSAttributes.version]: value }),
+		instance: (value) => ({ [require_registry.FaaSAttributes.instance]: value }),
+		execution: (value) => ({ [require_registry.FaaSAttributes.execution]: value }),
+		coldstart: (value) => ({ [require_registry.FaaSAttributes.coldstart]: value })
+	},
+	featureFlag: {
+		key: (value) => ({ [require_registry.FeatureFlagAttributes.key]: value }),
+		provider: (value) => ({ [require_registry.FeatureFlagAttributes.provider]: value }),
+		variant: (value) => ({ [require_registry.FeatureFlagAttributes.variant]: value })
+	},
+	messaging: {
+		system: (value) => ({ [require_registry.MessagingAttributes.system]: value }),
+		destination: (value) => ({ [require_registry.MessagingAttributes.destination]: value }),
+		operation: (value) => ({ [require_registry.MessagingAttributes.operation]: value }),
+		messageId: (value) => ({ [require_registry.MessagingAttributes.messageId]: value }),
+		conversationId: (value) => ({ [require_registry.MessagingAttributes.conversationId]: value }),
+		data: (data) => {
+			const result = {};
+			if (data.system !== void 0) result[require_registry.MessagingAttributes.system] = data.system;
+			if (data.destination !== void 0) result[require_registry.MessagingAttributes.destination] = data.destination;
+			if (data.operation !== void 0) result[require_registry.MessagingAttributes.operation] = data.operation;
+			if (data.messageId !== void 0) result[require_registry.MessagingAttributes.messageId] = data.messageId;
+			if (data.conversationId !== void 0) result[require_registry.MessagingAttributes.conversationId] = data.conversationId;
+			return result;
+		}
+	},
+	genAI: {
+		system: (value) => ({ [require_registry.GenAIAttributes.system]: value }),
+		requestModel: (value) => ({ [require_registry.GenAIAttributes.requestModel]: value }),
+		responseModel: (value) => ({ [require_registry.GenAIAttributes.responseModel]: value }),
+		operationName: (value) => ({ [require_registry.GenAIAttributes.operationName]: value }),
+		usagePromptTokens: (value) => ({ [require_registry.GenAIAttributes.usagePromptTokens]: value }),
+		usageCompletionTokens: (value) => ({ [require_registry.GenAIAttributes.usageCompletionTokens]: value }),
+		provider: (value) => ({ [require_registry.GenAIAttributes.provider]: value })
+	},
+	rpc: {
+		system: (value) => ({ [require_registry.RPCAttributes.system]: value }),
+		service: (value) => ({ [require_registry.RPCAttributes.service]: value }),
+		method: (value) => ({ [require_registry.RPCAttributes.method]: value }),
+		grpcStatusCode: (value) => ({ [require_registry.RPCAttributes.grpcStatusCode]: value })
+	},
+	graphql: {
+		document: (value) => ({ [require_registry.GraphQLAttributes.document]: value }),
+		operationName: (value) => ({ [require_registry.GraphQLAttributes.operationName]: value }),
+		operationType: (value) => ({ [require_registry.GraphQLAttributes.operationType]: value })
+	},
+	otel: {
+		libraryName: (value) => ({ [require_registry.OTelAttributes.libraryName]: value }),
+		libraryVersion: (value) => ({ [require_registry.OTelAttributes.libraryVersion]: value }),
+		statusCode: (value) => ({ [require_registry.OTelAttributes.statusCode]: value })
+	},
+	code: {
+		namespace: (value) => ({ [require_registry.CodeAttributes.namespace]: value }),
+		filepath: (value) => ({ [require_registry.CodeAttributes.filepath]: value }),
+		function: (value) => ({ [require_registry.CodeAttributes.function]: value }),
+		class: (value) => ({ [require_registry.CodeAttributes.class]: value }),
+		method: (value) => ({ [require_registry.CodeAttributes.method]: value }),
+		column: (value) => ({ [require_registry.CodeAttributes.column]: value }),
+		lineNumber: (value) => ({ [require_registry.CodeAttributes.lineNumber]: value }),
+		repository: (value) => ({ [require_registry.CodeAttributes.repository]: value }),
+		revision: (value) => ({ [require_registry.CodeAttributes.revision]: value })
+	},
+	tls: {
+		protocolVersion: (value) => ({ [require_registry.TLSAttributes.protocolVersion]: value }),
+		cipher: (value) => ({ [require_registry.TLSAttributes.cipher]: value }),
+		curveName: (value) => ({ [require_registry.TLSAttributes.curveName]: value }),
+		resumed: (value) => ({ [require_registry.TLSAttributes.resumed]: value })
+	}
+};
+
+//#endregion
+//#region src/attributes/validators.ts
+/**
+* Attribute validation, PII detection, and guardrails
+* Provides safe-by-default attribute handling with configurable policies
+*/
+const DEPRECATED_ATTRIBUTES = {
+	"enduser.id": "user.id",
+	"enduser.role": "user.roles",
+	"enduser.scope": void 0,
+	"http.method": "http.request.method",
+	"http.host": "server.address",
+	"http.status_code": "http.response.status_code",
+	"http.target": "url.path",
+	"http.url": "url.full",
+	"http.user_agent": "user_agent.original",
+	"http.flavor": "network.protocol.name",
+	"http.scheme": "url.scheme",
+	"http.server_name": "server.address",
+	"db.name": "db.namespace",
+	"db.operation": "db.operation.name",
+	"db.statement": "db.query.text",
+	"db.system": "db.system.name",
+	"db.collection": "db.collection.name",
+	"db.instance.id": void 0,
+	"db.jdbc.driver_classname": void 0,
+	"db.mssql.instance_name": "mssql.instance.name",
+	"db.sql.table": "db.collection.name",
+	"http.client_ip": "client.address",
+	"user_agent.original": "user_agent.original"
+};
+const HTTP_METHODS = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"HEAD",
+	"OPTIONS",
+	"TRACE",
+	"QUERY",
+	"_OTHER"
+]);
+function validateAttribute(key, value, policy = {}) {
+	const { guardrails = {} } = policy;
+	if (value === void 0 || value === null) return;
+	if (typeof value !== "string") return value;
+	const stringValue = value;
+	if (guardrails.pii) {
+		const piiResult = applyPIIPolicy(key, stringValue, guardrails.pii);
+		if (piiResult !== stringValue) return piiResult;
+	}
+	if (guardrails.maxLength && stringValue.length > guardrails.maxLength) return truncateValue(key, stringValue, guardrails.maxLength);
+	if (guardrails.validateEnum && HTTP_METHODS.has(stringValue)) {
+		const normalizedMethod = normalizeHTTPMethod(stringValue);
+		if (normalizedMethod !== stringValue) return normalizedMethod;
+	}
+	return stringValue;
+}
+function applyPIIPolicy(key, value, pii) {
+	if (pii === "allow") return value;
+	if (pii === "redact") return redactIfPII(key, value);
+	if (pii === "hash") return hashIfPII(key, value);
+	if (pii === "block" && isPIIKey(key)) throw new Error(`PII attribute "${key}" is blocked by guardrails. Use pii: "allow" to enable it.`);
+	return value;
+}
+function isPIIKey(key) {
+	const piiKeyPatterns = [
+		"email",
+		"phone",
+		"ssn",
+		"credit_card",
+		"password",
+		"secret",
+		"token",
+		"api_key",
+		"authorization"
+	];
+	const lowerKey = key.toLowerCase();
+	return piiKeyPatterns.some((pattern) => lowerKey.includes(pattern));
+}
+function redactIfPII(key, value) {
+	if (isPIIKey(key)) {
+		for (const [, pattern] of Object.entries(require_attribute_redacting_processor.REDACTOR_PATTERNS)) if (pattern instanceof RegExp && pattern.test(value)) return "[REDACTED]";
+		return "[REDACTED]";
+	}
+	return value;
+}
+function hashIfPII(key, value) {
+	if (!isPIIKey(key)) return value;
+	const FNV_PRIME = 16777619;
+	const FNV_OFFSET = 2166136261;
+	const hashes = [];
+	for (let round = 0; round < 4; round++) {
+		let hash = FNV_OFFSET;
+		for (let i = 0; i < value.length; i++) {
+			hash ^= (value.codePointAt(i) ?? 0) + round;
+			hash = Math.imul(hash, FNV_PRIME);
+		}
+		hashes.push(hash >>> 0);
+	}
+	return `hash_${hashes.map((h) => h.toString(16).padStart(8, "0")).join("")}`;
+}
+function truncateValue(key, value, maxLength) {
+	if (value.length <= maxLength) return value;
+	return value.slice(0, maxLength - 3) + "...";
+}
+function normalizeHTTPMethod(method) {
+	const upper = method.toUpperCase();
+	if (HTTP_METHODS.has(upper)) return upper;
+	return upper;
+}
+function checkDeprecatedAttribute(key, policy = {}) {
+	const { guardrails = {}, deprecatedWarnings = {} } = policy;
+	const { warnDeprecated = true } = guardrails;
+	if (!warnDeprecated) return null;
+	if (key in DEPRECATED_ATTRIBUTES) {
+		const replacement = DEPRECATED_ATTRIBUTES[key];
+		if (replacement === void 0) console.warn(`[autotel/attributes] Attribute "${key}" is deprecated and has no replacement. Remove or find a replacement in OpenTelemetry semantic conventions.`);
+		else console.warn(`[autotel/attributes] Attribute "${key}" is deprecated. Use "${replacement}" instead.`);
+	}
+	if (deprecatedWarnings[key]) console.warn(`[autotel/attributes] ${deprecatedWarnings[key]}`);
+	return DEPRECATED_ATTRIBUTES[key] ?? null;
+}
+function autoRedactPII(attributes, policy = {}) {
+	const { guardrails = { pii: "redact" } } = policy;
+	const redacted = {};
+	for (const [key, value] of Object.entries(attributes)) redacted[key] = validateAttribute(key, value, { guardrails });
+	return redacted;
+}
+function defaultGuardrails() {
+	return {
+		pii: "redact",
+		maxLength: 255,
+		validateEnum: true,
+		warnDeprecated: true
+	};
+}
+
+//#endregion
+//#region src/attributes/utils.ts
+function mergeAttrs(...attrSets) {
+	const result = {};
+	for (const attrSet of attrSets) if (attrSet) Object.assign(result, attrSet);
+	return result;
+}
+function safeSetAttributes(span, attrs, policy) {
+	const mergedGuardrails = {
+		...defaultGuardrails(),
+		...policy?.guardrails
+	};
+	const effectivePolicy = {
+		...policy,
+		guardrails: mergedGuardrails
+	};
+	const validated = autoRedactPII(attrs, effectivePolicy);
+	const sanitizedAttrs = {};
+	for (const [key, value] of Object.entries(validated)) if (value !== void 0) {
+		checkDeprecatedAttribute(key, effectivePolicy);
+		const validatedValue = validateAttribute(key, value, effectivePolicy);
+		if (validatedValue !== void 0) sanitizedAttrs[key] = validatedValue;
+	}
+	span.setAttributes(sanitizedAttrs);
+}
+
+//#endregion
+//#region src/attributes/attachers.ts
+function setUser(spanOrContext, data, guardrails) {
+	safeSetAttributes(spanOrContext, attrs.user.data(data), guardrails);
+}
+function setSession(spanOrContext, data, guardrails) {
+	safeSetAttributes(spanOrContext, attrs.session.data(data), guardrails);
+}
+function setDevice(spanOrContext, data, guardrails) {
+	safeSetAttributes(spanOrContext, attrs.device.data(data), guardrails);
+}
+function httpServer(spanOrContext, data, guardrails) {
+	const attributes = attrs.http.server(data);
+	if ("updateName" in spanOrContext && data.method && data.route) spanOrContext.updateName(`HTTP ${data.method} ${data.route}`);
+	safeSetAttributes(spanOrContext, attributes, guardrails);
+}
+function httpClient(spanOrContext, data, guardrails) {
+	safeSetAttributes(spanOrContext, attrs.http.client(data), guardrails);
+}
+function dbClient(spanOrContext, data, guardrails) {
+	safeSetAttributes(spanOrContext, attrs.db.client.data(data), guardrails);
+}
+/**
+* Merge service attributes into a Resource and return a new Resource.
+*
+* Resource.attributes is readonly, so this function returns a new merged
+* Resource rather than mutating the input.
+*
+* @param resource - The existing resource to merge with
+* @param data - Service attributes to add
+* @returns A new Resource with the merged attributes
+*
+* @example
+* ```typescript
+* const baseResource = Resource.default();
+* const enrichedResource = mergeServiceResource(baseResource, {
+*   name: 'my-service',
+*   version: '1.0.0',
+* });
+* ```
+*/
+function mergeServiceResource(resource, data) {
+	const attributes = attrs.service.data(data);
+	return resource.merge((0, _opentelemetry_resources.resourceFromAttributes)(attributes));
+}
+function identify(spanOrContext, data, guardrails) {
+	const allAttrs = [];
+	if (data.user) allAttrs.push(attrs.user.data(data.user));
+	if (data.session) allAttrs.push(attrs.session.data(data.session));
+	if (data.device) allAttrs.push(attrs.device.data(data.device));
+	const merged = {};
+	for (const attrSet of allAttrs) Object.assign(merged, attrSet);
+	safeSetAttributes(spanOrContext, merged, guardrails);
+}
+function request(spanOrContext, data, guardrails) {
+	const httpAttrs = attrs.http.server(data);
+	const networkAttrs = attrs.network.peerAddress(data.clientIp || "");
+	safeSetAttributes(spanOrContext, {
+		...httpAttrs,
+		...networkAttrs
+	}, guardrails);
+}
+function setError(spanOrContext, data, guardrails) {
+	safeSetAttributes(spanOrContext, attrs.error.data(data), guardrails);
+}
+function setException(spanOrContext, data, guardrails) {
+	safeSetAttributes(spanOrContext, attrs.exception.data(data), guardrails);
+}
+
+//#endregion
+//#region src/attributes/domains.ts
+/**
+* Domain helpers for common attribute patterns
+* These bundle multiple attribute groups into semantic helpers
+*/
+function transaction(spanOrContext, config, guardrails) {
+	const userAttrs = attrs.user.data(config.user || {});
+	const sessionAttrs = attrs.session.data(config.session || {});
+	const httpAttrs = attrs.http.server({
+		method: config.method,
+		route: config.route,
+		statusCode: config.statusCode
+	});
+	const networkAttrs = attrs.network.peerAddress(config.clientIp || "");
+	const merged = {
+		...userAttrs,
+		...sessionAttrs,
+		...httpAttrs,
+		...networkAttrs
+	};
+	if (config.method && config.route && "updateName" in spanOrContext) spanOrContext.updateName(`HTTP ${config.method} ${config.route}`);
+	safeSetAttributes(spanOrContext, merged, guardrails);
+}
+
+//#endregion
+Object.defineProperty(exports, 'attrs', {
+  enumerable: true,
+  get: function () {
+    return attrs;
+  }
+});
+Object.defineProperty(exports, 'autoRedactPII', {
+  enumerable: true,
+  get: function () {
+    return autoRedactPII;
+  }
+});
+Object.defineProperty(exports, 'checkDeprecatedAttribute', {
+  enumerable: true,
+  get: function () {
+    return checkDeprecatedAttribute;
+  }
+});
+Object.defineProperty(exports, 'dbClient', {
+  enumerable: true,
+  get: function () {
+    return dbClient;
+  }
+});
+Object.defineProperty(exports, 'defaultGuardrails', {
+  enumerable: true,
+  get: function () {
+    return defaultGuardrails;
+  }
+});
+Object.defineProperty(exports, 'httpClient', {
+  enumerable: true,
+  get: function () {
+    return httpClient;
+  }
+});
+Object.defineProperty(exports, 'httpServer', {
+  enumerable: true,
+  get: function () {
+    return httpServer;
+  }
+});
+Object.defineProperty(exports, 'identify', {
+  enumerable: true,
+  get: function () {
+    return identify;
+  }
+});
+Object.defineProperty(exports, 'mergeAttrs', {
+  enumerable: true,
+  get: function () {
+    return mergeAttrs;
+  }
+});
+Object.defineProperty(exports, 'mergeServiceResource', {
+  enumerable: true,
+  get: function () {
+    return mergeServiceResource;
+  }
+});
+Object.defineProperty(exports, 'request', {
+  enumerable: true,
+  get: function () {
+    return request;
+  }
+});
+Object.defineProperty(exports, 'safeSetAttributes', {
+  enumerable: true,
+  get: function () {
+    return safeSetAttributes;
+  }
+});
+Object.defineProperty(exports, 'setDevice', {
+  enumerable: true,
+  get: function () {
+    return setDevice;
+  }
+});
+Object.defineProperty(exports, 'setError', {
+  enumerable: true,
+  get: function () {
+    return setError;
+  }
+});
+Object.defineProperty(exports, 'setException', {
+  enumerable: true,
+  get: function () {
+    return setException;
+  }
+});
+Object.defineProperty(exports, 'setSession', {
+  enumerable: true,
+  get: function () {
+    return setSession;
+  }
+});
+Object.defineProperty(exports, 'setUser', {
+  enumerable: true,
+  get: function () {
+    return setUser;
+  }
+});
+Object.defineProperty(exports, 'transaction', {
+  enumerable: true,
+  get: function () {
+    return transaction;
+  }
+});
+Object.defineProperty(exports, 'validateAttribute', {
+  enumerable: true,
+  get: function () {
+    return validateAttribute;
+  }
+});
+//# sourceMappingURL=attributes-D3etyRVc.cjs.map