autotel 3.5.0 → 3.7.0

package/dist/processors.d.cts

@@ -1,171 +1,3 @@
-import { ReadableSpan, SpanProcessor } from '@opentelemetry/sdk-trace-base';
-export { BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { AttributeValue } from '@opentelemetry/api';
-import { Logger } from './logger.cjs';
-import 'pino';
-
-/**
- * Canonical Log Line Processor
- *
- * Automatically emits spans as canonical log lines (wide events) when they end.
- * Implements canonical log line" pattern: one comprehensive
- * event per request with all context.
- *
- * When a span ends, this processor creates a log record with ALL span attributes,
- * making the span itself the canonical log line that can be queried like structured data.
- *
- * @example
- * ```typescript
- * import { init } from 'autotel';
- *
- * init({
- *   service: 'my-app',
- *   canonicalLogLines: {
- *     enabled: true,
- *     rootSpansOnly: true, // One canonical log line per request
- *   },
- * });
- * ```
- */
-
-/**
- * Function to redact sensitive attribute values
- */
-type AttributeRedactorFn = (key: string, value: AttributeValue) => AttributeValue;
-interface CanonicalLogLineEvent {
-    span: ReadableSpan;
-    level: 'debug' | 'info' | 'warn' | 'error';
-    message: string;
-    event: Record<string, unknown>;
-}
-interface KeepCondition {
-    /** Keep events where HTTP status >= this value. */
-    status?: number;
-    /** Keep events where duration_ms >= this value. */
-    durationMs?: number;
-    /** Keep events matching this path pattern (simple prefix match). */
-    path?: string;
-}
-interface CanonicalLogLineOptions {
-    /** Logger to use for emitting canonical log lines (defaults to OTel Logs API) */
-    logger?: Logger;
-    /** Only emit canonical log lines for root spans (default: false) */
-    rootSpansOnly?: boolean;
-    /** Minimum log level for canonical log lines (default: 'info') */
-    minLevel?: 'debug' | 'info' | 'warn' | 'error';
-    /** Custom message format (default: uses span name) */
-    messageFormat?: (span: ReadableSpan) => string;
-    /** Whether to include resource attributes (default: true) */
-    includeResourceAttributes?: boolean;
-    /**
-     * Attribute redactor function to apply before logging.
-     * This ensures sensitive data is redacted in canonical log lines,
-     * matching the behavior of attributeRedactor in init().
-     */
-    attributeRedactor?: AttributeRedactorFn;
-    /** Predicate to decide whether to emit (runs after event is built). */
-    shouldEmit?: (ctx: CanonicalLogLineEvent) => boolean;
-    /**
-     * Declarative tail sampling conditions (OR logic). If any condition matches,
-     * the event is kept. Ignored when `shouldEmit` is provided.
-     *
-     * @example
-     * keep: [{ status: 500 }, { durationMs: 1000 }]
-     */
-    keep?: KeepCondition[];
-    /** Callback invoked after emit for custom fan-out. */
-    drain?: (ctx: CanonicalLogLineEvent) => void | Promise<void>;
-    /** Handler for drain failures. */
-    onDrainError?: (error: unknown, ctx: CanonicalLogLineEvent) => void;
-    /**
-     * Pretty-print canonical log lines to console in a tree format.
-     * Defaults to true when NODE_ENV is 'development'.
-     */
-    pretty?: boolean;
-}
-/**
- * Span processor that automatically emits spans as canonical log lines
- *
- * When a span ends, this processor creates a log record with ALL span attributes.
- * This implements the "canonical log line" pattern: one comprehensive event
- * per request with all context, queryable as structured data.
- *
- * **Key Benefits:**
- * - One log line per request with all context (wide event)
- * - High-cardinality, high-dimensionality data for powerful queries
- * - Automatic - no manual logging needed
- * - Works with any logger or OTel Logs API
- *
- * @example Basic usage
- * ```typescript
- * import { init } from 'autotel';
- *
- * init({
- *   service: 'checkout-api',
- *   canonicalLogLines: {
- *     enabled: true,
- *     rootSpansOnly: true, // One canonical log line per request
- *   },
- * });
- * ```
- *
- * @example With custom logger
- * ```typescript
- * import pino from 'pino';
- * import { init } from 'autotel';
- *
- * const logger = pino();
- * init({
- *   service: 'my-app',
- *   logger,
- *   canonicalLogLines: {
- *     enabled: true,
- *     logger, // Use Pino for canonical log lines
- *     rootSpansOnly: true,
- *   },
- * });
- * ```
- *
- * @example Custom message format
- * ```typescript
- * init({
- *   service: 'my-app',
- *   canonicalLogLines: {
- *     enabled: true,
- *     messageFormat: (span) => {
- *       const status = span.status.code === 2 ? 'ERROR' : 'SUCCESS';
- *       return `${span.name} [${status}]`;
- *     },
- *   },
- * });
- * ```
- */
-declare class CanonicalLogLineProcessor implements SpanProcessor {
-    private logger?;
-    private rootSpansOnly;
-    private minLevel;
-    private messageFormat;
-    private includeResourceAttributes;
-    private attributeRedactor?;
-    private shouldEmit?;
-    private drain?;
-    private onDrainError?;
-    private pretty;
-    private getOTelLogger;
-    constructor(options?: CanonicalLogLineOptions);
-    private buildKeepPredicate;
-    onStart(): void;
-    onEnd(span: ReadableSpan): void;
-    private buildCanonicalLogLine;
-    private redactAttributes;
-    private emitViaLogger;
-    private emitViaOTel;
-    private getLogLevel;
-    private shouldLog;
-    private getSeverityNumber;
-    private reportInternalWarning;
-    forceFlush(): Promise<void>;
-    shutdown(): Promise<void>;
-}
-
-export { type CanonicalLogLineOptions, CanonicalLogLineProcessor };
+import { n as CanonicalLogLineProcessor, t as CanonicalLogLineOptions } from "./canonical-log-line-processor-xvjMgtpF.cjs";
+import { BatchSpanProcessor, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+export { BatchSpanProcessor, type CanonicalLogLineOptions, CanonicalLogLineProcessor, SimpleSpanProcessor };

package/dist/processors.d.ts

@@ -1,171 +1,3 @@
-import { ReadableSpan, SpanProcessor } from '@opentelemetry/sdk-trace-base';
-export { BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { AttributeValue } from '@opentelemetry/api';
-import { Logger } from './logger.js';
-import 'pino';
-
-/**
- * Canonical Log Line Processor
- *
- * Automatically emits spans as canonical log lines (wide events) when they end.
- * Implements canonical log line" pattern: one comprehensive
- * event per request with all context.
- *
- * When a span ends, this processor creates a log record with ALL span attributes,
- * making the span itself the canonical log line that can be queried like structured data.
- *
- * @example
- * ```typescript
- * import { init } from 'autotel';
- *
- * init({
- *   service: 'my-app',
- *   canonicalLogLines: {
- *     enabled: true,
- *     rootSpansOnly: true, // One canonical log line per request
- *   },
- * });
- * ```
- */
-
-/**
- * Function to redact sensitive attribute values
- */
-type AttributeRedactorFn = (key: string, value: AttributeValue) => AttributeValue;
-interface CanonicalLogLineEvent {
-    span: ReadableSpan;
-    level: 'debug' | 'info' | 'warn' | 'error';
-    message: string;
-    event: Record<string, unknown>;
-}
-interface KeepCondition {
-    /** Keep events where HTTP status >= this value. */
-    status?: number;
-    /** Keep events where duration_ms >= this value. */
-    durationMs?: number;
-    /** Keep events matching this path pattern (simple prefix match). */
-    path?: string;
-}
-interface CanonicalLogLineOptions {
-    /** Logger to use for emitting canonical log lines (defaults to OTel Logs API) */
-    logger?: Logger;
-    /** Only emit canonical log lines for root spans (default: false) */
-    rootSpansOnly?: boolean;
-    /** Minimum log level for canonical log lines (default: 'info') */
-    minLevel?: 'debug' | 'info' | 'warn' | 'error';
-    /** Custom message format (default: uses span name) */
-    messageFormat?: (span: ReadableSpan) => string;
-    /** Whether to include resource attributes (default: true) */
-    includeResourceAttributes?: boolean;
-    /**
-     * Attribute redactor function to apply before logging.
-     * This ensures sensitive data is redacted in canonical log lines,
-     * matching the behavior of attributeRedactor in init().
-     */
-    attributeRedactor?: AttributeRedactorFn;
-    /** Predicate to decide whether to emit (runs after event is built). */
-    shouldEmit?: (ctx: CanonicalLogLineEvent) => boolean;
-    /**
-     * Declarative tail sampling conditions (OR logic). If any condition matches,
-     * the event is kept. Ignored when `shouldEmit` is provided.
-     *
-     * @example
-     * keep: [{ status: 500 }, { durationMs: 1000 }]
-     */
-    keep?: KeepCondition[];
-    /** Callback invoked after emit for custom fan-out. */
-    drain?: (ctx: CanonicalLogLineEvent) => void | Promise<void>;
-    /** Handler for drain failures. */
-    onDrainError?: (error: unknown, ctx: CanonicalLogLineEvent) => void;
-    /**
-     * Pretty-print canonical log lines to console in a tree format.
-     * Defaults to true when NODE_ENV is 'development'.
-     */
-    pretty?: boolean;
-}
-/**
- * Span processor that automatically emits spans as canonical log lines
- *
- * When a span ends, this processor creates a log record with ALL span attributes.
- * This implements the "canonical log line" pattern: one comprehensive event
- * per request with all context, queryable as structured data.
- *
- * **Key Benefits:**
- * - One log line per request with all context (wide event)
- * - High-cardinality, high-dimensionality data for powerful queries
- * - Automatic - no manual logging needed
- * - Works with any logger or OTel Logs API
- *
- * @example Basic usage
- * ```typescript
- * import { init } from 'autotel';
- *
- * init({
- *   service: 'checkout-api',
- *   canonicalLogLines: {
- *     enabled: true,
- *     rootSpansOnly: true, // One canonical log line per request
- *   },
- * });
- * ```
- *
- * @example With custom logger
- * ```typescript
- * import pino from 'pino';
- * import { init } from 'autotel';
- *
- * const logger = pino();
- * init({
- *   service: 'my-app',
- *   logger,
- *   canonicalLogLines: {
- *     enabled: true,
- *     logger, // Use Pino for canonical log lines
- *     rootSpansOnly: true,
- *   },
- * });
- * ```
- *
- * @example Custom message format
- * ```typescript
- * init({
- *   service: 'my-app',
- *   canonicalLogLines: {
- *     enabled: true,
- *     messageFormat: (span) => {
- *       const status = span.status.code === 2 ? 'ERROR' : 'SUCCESS';
- *       return `${span.name} [${status}]`;
- *     },
- *   },
- * });
- * ```
- */
-declare class CanonicalLogLineProcessor implements SpanProcessor {
-    private logger?;
-    private rootSpansOnly;
-    private minLevel;
-    private messageFormat;
-    private includeResourceAttributes;
-    private attributeRedactor?;
-    private shouldEmit?;
-    private drain?;
-    private onDrainError?;
-    private pretty;
-    private getOTelLogger;
-    constructor(options?: CanonicalLogLineOptions);
-    private buildKeepPredicate;
-    onStart(): void;
-    onEnd(span: ReadableSpan): void;
-    private buildCanonicalLogLine;
-    private redactAttributes;
-    private emitViaLogger;
-    private emitViaOTel;
-    private getLogLevel;
-    private shouldLog;
-    private getSeverityNumber;
-    private reportInternalWarning;
-    forceFlush(): Promise<void>;
-    shutdown(): Promise<void>;
-}
-
-export { type CanonicalLogLineOptions, CanonicalLogLineProcessor };
+import { n as CanonicalLogLineProcessor, t as CanonicalLogLineOptions } from "./canonical-log-line-processor-BcRuAdRk.js";
+import { BatchSpanProcessor, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+export { BatchSpanProcessor, type CanonicalLogLineOptions, CanonicalLogLineProcessor, SimpleSpanProcessor };

package/dist/processors.js

@@ -1,4 +1,4 @@
-export { CanonicalLogLineProcessor } from './chunk-3QXBFGKP.js';
-export { BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
-//# sourceMappingURL=processors.js.map
-//# sourceMappingURL=processors.js.map
+import { t as CanonicalLogLineProcessor } from "./canonical-log-line-processor-DbBQT5vY.js";
+import { BatchSpanProcessor, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+
+export { BatchSpanProcessor, CanonicalLogLineProcessor, SimpleSpanProcessor };

package/dist/register.cjs

@@ -1,9 +1,38 @@
-'use strict';
+let node_module = require("node:module");
 
-var module$1 = require('module');
+//#region src/register.ts
+/**
+* ESM instrumentation registration for Node.js 18.19+
+*
+* This module registers the OpenTelemetry ESM loader hook using the modern
+* node:module register() API. This eliminates the need for NODE_OPTIONS or
+* --experimental-loader flags.
+*
+* Usage in instrumentation.mjs:
+* ```typescript
+* import 'autotel/register';  // MUST be first import!
+* import { init } from 'autotel';
+*
+* init({
+*   service: 'my-app',
+*   instrumentations: [...],  // or autoInstrumentations: ['express', 'http', 'pino']
+* });
+* ```
+*
+* Then run:
+* ```bash
+* node --import ./instrumentation.mjs src/index.js
+* # or with tsx:
+* tsx --import ./instrumentation.mjs src/index.ts
+* ```
+*
+* No NODE_OPTIONS or --experimental-loader needed!
+*
+* @requires Node.js 18.19.0 or later
+* @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md
+* @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options
+*/
+(0, node_module.register)("@opentelemetry/instrumentation/hook.mjs", require("url").pathToFileURL(__filename).href);
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-// src/register.ts
-module$1.register("@opentelemetry/instrumentation/hook.mjs", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('register.cjs', document.baseURI).href)));
-//# sourceMappingURL=register.cjs.map
+//#endregion
 //# sourceMappingURL=register.cjs.map

package/dist/register.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/register.ts"],"names":["register"],"mappings":";;;;;;AAoCAA,iBAAA,CAAS,yCAAA,EAA2C,8PAAe,CAAA","file":"register.cjs","sourcesContent":["/**\n * ESM instrumentation registration for Node.js 18.19+\n *\n * This module registers the OpenTelemetry ESM loader hook using the modern\n * node:module register() API. This eliminates the need for NODE_OPTIONS or\n * --experimental-loader flags.\n *\n * Usage in instrumentation.mjs:\n * ```typescript\n * import 'autotel/register';  // MUST be first import!\n * import { init } from 'autotel';\n *\n * init({\n *   service: 'my-app',\n *   instrumentations: [...],  // or autoInstrumentations: ['express', 'http', 'pino']\n * });\n * ```\n *\n * Then run:\n * ```bash\n * node --import ./instrumentation.mjs src/index.js\n * # or with tsx:\n * tsx --import ./instrumentation.mjs src/index.ts\n * ```\n *\n * No NODE_OPTIONS or --experimental-loader needed!\n *\n * @requires Node.js 18.19.0 or later\n * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md\n * @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options\n */\n\nimport { register } from 'node:module';\n\n// Use the official OpenTelemetry instrumentation hook which wraps import-in-the-middle\n// This ensures proper integration with OTel's instrumentation system\nregister('@opentelemetry/instrumentation/hook.mjs', import.meta.url);\n"]}
+{"version":3,"file":"register.cjs","names":[],"sources":["../src/register.ts"],"sourcesContent":["/**\n * ESM instrumentation registration for Node.js 18.19+\n *\n * This module registers the OpenTelemetry ESM loader hook using the modern\n * node:module register() API. This eliminates the need for NODE_OPTIONS or\n * --experimental-loader flags.\n *\n * Usage in instrumentation.mjs:\n * ```typescript\n * import 'autotel/register';  // MUST be first import!\n * import { init } from 'autotel';\n *\n * init({\n *   service: 'my-app',\n *   instrumentations: [...],  // or autoInstrumentations: ['express', 'http', 'pino']\n * });\n * ```\n *\n * Then run:\n * ```bash\n * node --import ./instrumentation.mjs src/index.js\n * # or with tsx:\n * tsx --import ./instrumentation.mjs src/index.ts\n * ```\n *\n * No NODE_OPTIONS or --experimental-loader needed!\n *\n * @requires Node.js 18.19.0 or later\n * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md\n * @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options\n */\n\nimport { register } from 'node:module';\n\n// Use the official OpenTelemetry instrumentation hook which wraps import-in-the-middle\n// This ensures proper integration with OTel's instrumentation system\nregister('@opentelemetry/instrumentation/hook.mjs', import.meta.url);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAoCS,wFAA0D"}

package/dist/register.d.cts

@@ -1,2 +1 @@
-
-export {  }
+export { };

package/dist/register.d.ts

@@ -1,2 +1 @@
-
-export {  }
+export { };

package/dist/register.js

@@ -1,6 +1,39 @@
-import { register } from 'module';
+import { register } from "node:module";
 
-// src/register.ts
+//#region src/register.ts
+/**
+* ESM instrumentation registration for Node.js 18.19+
+*
+* This module registers the OpenTelemetry ESM loader hook using the modern
+* node:module register() API. This eliminates the need for NODE_OPTIONS or
+* --experimental-loader flags.
+*
+* Usage in instrumentation.mjs:
+* ```typescript
+* import 'autotel/register';  // MUST be first import!
+* import { init } from 'autotel';
+*
+* init({
+*   service: 'my-app',
+*   instrumentations: [...],  // or autoInstrumentations: ['express', 'http', 'pino']
+* });
+* ```
+*
+* Then run:
+* ```bash
+* node --import ./instrumentation.mjs src/index.js
+* # or with tsx:
+* tsx --import ./instrumentation.mjs src/index.ts
+* ```
+*
+* No NODE_OPTIONS or --experimental-loader needed!
+*
+* @requires Node.js 18.19.0 or later
+* @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md
+* @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options
+*/
 register("@opentelemetry/instrumentation/hook.mjs", import.meta.url);
-//# sourceMappingURL=register.js.map
+
+//#endregion
+export {  };
 //# sourceMappingURL=register.js.map

package/dist/register.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/register.ts"],"names":[],"mappings":";;;AAoCA,QAAA,CAAS,yCAAA,EAA2C,YAAY,GAAG,CAAA","file":"register.js","sourcesContent":["/**\n * ESM instrumentation registration for Node.js 18.19+\n *\n * This module registers the OpenTelemetry ESM loader hook using the modern\n * node:module register() API. This eliminates the need for NODE_OPTIONS or\n * --experimental-loader flags.\n *\n * Usage in instrumentation.mjs:\n * ```typescript\n * import 'autotel/register';  // MUST be first import!\n * import { init } from 'autotel';\n *\n * init({\n *   service: 'my-app',\n *   instrumentations: [...],  // or autoInstrumentations: ['express', 'http', 'pino']\n * });\n * ```\n *\n * Then run:\n * ```bash\n * node --import ./instrumentation.mjs src/index.js\n * # or with tsx:\n * tsx --import ./instrumentation.mjs src/index.ts\n * ```\n *\n * No NODE_OPTIONS or --experimental-loader needed!\n *\n * @requires Node.js 18.19.0 or later\n * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md\n * @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options\n */\n\nimport { register } from 'node:module';\n\n// Use the official OpenTelemetry instrumentation hook which wraps import-in-the-middle\n// This ensures proper integration with OTel's instrumentation system\nregister('@opentelemetry/instrumentation/hook.mjs', import.meta.url);\n"]}
+{"version":3,"file":"register.js","names":[],"sources":["../src/register.ts"],"sourcesContent":["/**\n * ESM instrumentation registration for Node.js 18.19+\n *\n * This module registers the OpenTelemetry ESM loader hook using the modern\n * node:module register() API. This eliminates the need for NODE_OPTIONS or\n * --experimental-loader flags.\n *\n * Usage in instrumentation.mjs:\n * ```typescript\n * import 'autotel/register';  // MUST be first import!\n * import { init } from 'autotel';\n *\n * init({\n *   service: 'my-app',\n *   instrumentations: [...],  // or autoInstrumentations: ['express', 'http', 'pino']\n * });\n * ```\n *\n * Then run:\n * ```bash\n * node --import ./instrumentation.mjs src/index.js\n * # or with tsx:\n * tsx --import ./instrumentation.mjs src/index.ts\n * ```\n *\n * No NODE_OPTIONS or --experimental-loader needed!\n *\n * @requires Node.js 18.19.0 or later\n * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md\n * @see https://nodejs.org/api/module.html#moduleregisterspecifier-parenturl-options\n */\n\nimport { register } from 'node:module';\n\n// Use the official OpenTelemetry instrumentation hook which wraps import-in-the-middle\n// This ensures proper integration with OTel's instrumentation system\nregister('@opentelemetry/instrumentation/hook.mjs', import.meta.url);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAS,2CAA2C,OAAO,KAAK,GAAG"}

package/dist/registry-DfXA3R1L.js

@@ -0,0 +1,184 @@
+//#region src/attributes/registry.ts
+/**
+* OpenTelemetry attribute registry
+* Central source of truth for attribute keys, types, and metadata
+*/
+const UserAttributes = {
+	id: "user.id",
+	email: "user.email",
+	name: "user.name",
+	fullName: "user.full_name",
+	hash: "user.hash",
+	roles: "user.roles"
+};
+const SessionAttributes = {
+	id: "session.id",
+	previousId: "session.previous_id"
+};
+const DeviceAttributes = {
+	id: "device.id",
+	manufacturer: "device.manufacturer",
+	modelIdentifier: "device.model.identifier",
+	modelName: "device.model.name"
+};
+const HTTPAttributes = {
+	connectionState: "http.connection.state",
+	requestMethod: "http.request.method",
+	requestMethodOriginal: "http.request.method_original",
+	requestResendCount: "http.request.resend_count",
+	requestSize: "http.request.size",
+	requestBodySize: "http.request.body.size",
+	responseSize: "http.response.size",
+	responseBodySize: "http.response.body.size",
+	responseStatusCode: "http.response.status_code",
+	route: "http.route"
+};
+const DBAttributes = {
+	clientConnectionPoolName: "db.client.connection.pool.name",
+	clientConnectionState: "db.client.connection.state",
+	collectionName: "db.collection.name",
+	namespace: "db.namespace",
+	operationBatchSize: "db.operation.batch.size",
+	operationName: "db.operation.name",
+	querySummary: "db.query.summary",
+	queryText: "db.query.text",
+	responseReturnedRows: "db.response.returned_rows",
+	responseStatusCode: "db.response.status_code",
+	systemName: "db.system.name",
+	statement: "db.statement"
+};
+const ServiceAttributes = {
+	name: "service.name",
+	instance: "service.instance.id",
+	version: "service.version"
+};
+const NetworkAttributes = {
+	peerAddress: "network.peer.address",
+	peerPort: "network.peer.port",
+	transport: "network.transport",
+	type: "network.type",
+	protocolName: "network.protocol.name",
+	protocolVersion: "network.protocol.version"
+};
+const ServerAddressAttributes = {
+	address: "server.address",
+	port: "server.port",
+	socketAddress: "server.socket.address"
+};
+const URLAttributes = {
+	scheme: "url.scheme",
+	full: "url.full",
+	path: "url.path",
+	query: "url.query",
+	fragment: "url.fragment"
+};
+const ErrorAttributes = {
+	type: "error.type",
+	message: "error.message",
+	stackTrace: "error.stack",
+	code: "error.code"
+};
+const ExceptionAttributes = {
+	escaped: "exception.escaped",
+	message: "exception.message",
+	stackTrace: "exception.stacktrace",
+	type: "exception.type",
+	moduleName: "exception.module"
+};
+const ProcessAttributes = {
+	pid: "process.pid",
+	executablePath: "process.executable.path",
+	command: "process.command",
+	owner: "process.owner",
+	commandArgs: "process.command_args"
+};
+const ThreadAttributes = {
+	id: "thread.id",
+	name: "thread.name"
+};
+const ContainerAttributes = {
+	id: "container.id",
+	name: "container.name",
+	image: "container.image.name",
+	tag: "container.image.tag"
+};
+const K8sAttributes = {
+	podName: "k8s.pod.name",
+	namespaceName: "k8s.namespace.name",
+	deploymentName: "k8s.deployment.name",
+	state: "k8s.state.name"
+};
+const CloudAttributes = {
+	provider: "cloud.provider",
+	accountId: "cloud.account.id",
+	region: "cloud.region",
+	availabilityZone: "cloud.availability_zone",
+	platform: "cloud.platform"
+};
+const FaaSAttributes = {
+	name: "faas.name",
+	version: "faas.version",
+	instance: "faas.instance",
+	execution: "faas.execution",
+	coldstart: "faas.coldstart"
+};
+const FeatureFlagAttributes = {
+	key: "feature.flag.key",
+	provider: "feature.flag.provider_name",
+	variant: "feature.flag.variant.name"
+};
+const MessagingAttributes = {
+	system: "messaging.system",
+	destination: "messaging.destination.name",
+	operation: "messaging.operation",
+	messageId: "messaging.message.id",
+	conversationId: "messaging.conversation_id",
+	batchMessageCount: "messaging.batch.message_count",
+	consumerGroup: "messaging.consumer.group"
+};
+const GenAIAttributes = {
+	system: "gen.ai.system",
+	requestModel: "gen.ai.request.model",
+	responseModel: "gen.ai.response.model",
+	operationName: "gen.ai.operation.name",
+	usagePromptTokens: "gen.ai.usage.prompt_tokens",
+	usageCompletionTokens: "gen.ai.usage.completion_tokens",
+	provider: "gen.ai.provider"
+};
+const RPCAttributes = {
+	system: "rpc.system",
+	service: "rpc.service",
+	method: "rpc.method",
+	grpcStatusCode: "rpc.grpc.status_code"
+};
+const GraphQLAttributes = {
+	document: "graphql.document",
+	operationName: "graphql.operation.name",
+	operationType: "graphql.operation.type"
+};
+const OTelAttributes = {
+	libraryName: "otel.library.name",
+	libraryVersion: "otel.library.version",
+	statusCode: "otel.status_code"
+};
+const CodeAttributes = {
+	namespace: "code.namespace",
+	filepath: "code.filepath",
+	function: "code.function",
+	class: "code.class",
+	method: "code.method",
+	column: "code.column",
+	lineNumber: "code.lineno",
+	repository: "code.repository",
+	revision: "code.revision"
+};
+const TLSAttributes = {
+	protocolVersion: "tls.protocol.version",
+	cipher: "tls.cipher",
+	curveName: "tls.curve.name",
+	resumed: "tls.resumed"
+};
+
+//#endregion
+export { ThreadAttributes as C, TLSAttributes as S, UserAttributes as T, ProcessAttributes as _, DeviceAttributes as a, ServiceAttributes as b, FaaSAttributes as c, GraphQLAttributes as d, HTTPAttributes as f, OTelAttributes as g, NetworkAttributes as h, DBAttributes as i, FeatureFlagAttributes as l, MessagingAttributes as m, CodeAttributes as n, ErrorAttributes as o, K8sAttributes as p, ContainerAttributes as r, ExceptionAttributes as s, CloudAttributes as t, GenAIAttributes as u, RPCAttributes as v, URLAttributes as w, SessionAttributes as x, ServerAddressAttributes as y };
+//# sourceMappingURL=registry-DfXA3R1L.js.map