autotel 2.1.0

package/dist/instrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/instrumentation.ts"],"names":[],"mappings":"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","file":"instrumentation.js","sourcesContent":["import { NodeSDK } from '@opentelemetry/sdk-node';\nimport { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';\nimport { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';\nimport { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';\nimport { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';\nimport { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';\nimport { TailSamplingSpanProcessor } from './tail-sampling-processor';\nimport { getLogger } from './init';\nimport {\n  resourceFromAttributes,\n  detectResources,\n  processDetector,\n  hostDetector,\n  type Resource,\n  type ResourceDetector,\n} from '@opentelemetry/resources';\nimport {\n  ATTR_SERVICE_NAME,\n  ATTR_SERVICE_VERSION,\n} from '@opentelemetry/semantic-conventions/incubating';\nimport { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';\nimport { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';\n\n/**\n * Parse OTLP headers string into object format\n * @param headersString - Headers as \"key1=value1,key2=value2\" or \"Authorization=Basic ...\"\n * @returns Headers object for OTLP exporters\n */\nfunction parseOtlpHeaders(headersString?: string): Record<string, string> {\n  if (!headersString) return {};\n\n  const headers: Record<string, string> = {};\n  const pairs = headersString.split(',');\n\n  for (const pair of pairs) {\n    const [key, ...valueParts] = pair.split('=');\n    if (key && valueParts.length > 0) {\n      headers[key.trim()] = valueParts.join('=').trim();\n    }\n  }\n\n  return headers;\n}\n\n/**\n * Parse resource attributes string into object format\n * @param attributesString - Attributes as \"key1=value1,key2=value2\"\n * @returns Resource attributes object\n */\nfunction parseResourceAttributes(\n  attributesString?: string,\n): Record<string, string> {\n  if (!attributesString) return {};\n\n  const attributes: Record<string, string> = {};\n  const pairs = attributesString.split(',');\n\n  for (const pair of pairs) {\n    const [key, ...valueParts] = pair.split('=');\n    if (key && valueParts.length > 0) {\n      attributes[key.trim()] = valueParts.join('=').trim();\n    }\n  }\n\n  return attributes;\n}\n\nexport interface InstrumentationConfig {\n  serviceName: string;\n  serviceVersion?: string;\n  deploymentEnvironment?: string;\n  otlpEndpoint?: string;\n  /** OTLP headers for authentication (e.g., Grafana Cloud) */\n  otlpHeaders?: string;\n  /** Resource attributes as comma-separated key=value pairs */\n  resourceAttributes?: string;\n  /** Enable async resource detection for process/host info (default: false) */\n  detectResources?: boolean;\n  /**\n   * Use selective instrumentation instead of full auto-instrumentation\n   * **Default: true** (performance-first)\n   *\n   * When true, auto-instrumentation is disabled. You can manually add\n   * specific instrumentations via the `instrumentations` field.\n   * This reduces overhead from ~81% to near-zero based on Platformatic benchmarks.\n   *\n   * Set to false to enable full auto-instrumentation (not recommended for production).\n   *\n   * @see https://blogger.platformatic.dev/the-hidden-cost-of-context\n   */\n  selectiveInstrumentation?: boolean;\n\n  /**\n   * Custom instrumentations to use (only when selectiveInstrumentation is true)\n   * @example\n   * ```typescript\n   * import { HttpInstrumentation } from '@opentelemetry/instrumentation-http'\n   *\n   * initInstrumentation({\n   *   serviceName: 'api',\n   *   selectiveInstrumentation: true,\n   *   instrumentations: [new HttpInstrumentation()]\n   * })\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  instrumentations?: any[];\n}\n\n/**\n * Initialize OpenTelemetry instrumentation with OTLP exporters\n *\n * This sets up:\n * - Traces (OTLP HTTP)\n * - Metrics (OTLP HTTP)\n * - Logs (OTLP HTTP)\n * - Auto-instrumentation for common Node.js libraries\n *\n * @example\n * // Call this at the very start of your application\n * import { initInstrumentation } from '@your-org/otel-decorators'\n *\n * initInstrumentation({\n *   serviceName: 'my-service' }\n *   serviceVersion: '1.0.0',\n *   deploymentEnvironment: 'production',\n *   otlpEndpoint: 'http://localhost:4318'\n * })\n *\n * // Or with async resource detection (top-level await required)\n * await initInstrumentation({\n *   serviceName: 'my-service' }\n *   detectResources: true\n * })\n */\n// Enables graceful shutdown and prevents SDK leaks on hot-reload\nlet currentSDK: NodeSDK | null = null;\nlet shutdownHandlerRegistered = false;\n\n/**\n * Shutdown the OpenTelemetry SDK gracefully\n * Call this before process exit or during hot-reloads\n */\nexport async function shutdownInstrumentation(sdk?: NodeSDK): Promise<void> {\n  const sdkToShutdown = sdk || currentSDK;\n  if (!sdkToShutdown) {\n    getLogger().warn('No SDK to shutdown');\n    return;\n  }\n\n  try {\n    await sdkToShutdown.shutdown();\n    getLogger().info('OpenTelemetry terminated successfully');\n    if (sdkToShutdown === currentSDK) {\n      currentSDK = null;\n    }\n  } catch (error) {\n    getLogger().error(\n      'Error terminating OpenTelemetry',\n      error instanceof Error ? error : undefined,\n    );\n    throw error;\n  }\n}\n\nexport async function initInstrumentation(\n  config: InstrumentationConfig,\n): Promise<NodeSDK> {\n  // Prevents resource leaks on hot-reload or multiple init calls\n  if (currentSDK) {\n    getLogger().info(\n      'Shutting down existing OpenTelemetry SDK before reinitializing...',\n    );\n    await shutdownInstrumentation(currentSDK);\n  }\n\n  // Parse OTLP headers and resource attributes\n  const otlpHeaders = parseOtlpHeaders(config.otlpHeaders);\n  const customResourceAttributes = parseResourceAttributes(\n    config.resourceAttributes,\n  );\n\n  let resource: Resource;\n\n  // Dynamically load optional resource detectors\n  const detectors: ResourceDetector[] = [processDetector, hostDetector];\n  try {\n    const awsDetectors = await import('@opentelemetry/resource-detector-aws');\n    detectors.push(\n      awsDetectors.awsEc2Detector,\n      awsDetectors.awsEcsDetector,\n      awsDetectors.awsEksDetector,\n    );\n  } catch {\n    // ignore\n  }\n  try {\n    const gcpDetectors = await import('@opentelemetry/resource-detector-gcp');\n    detectors.push(gcpDetectors.gcpDetector);\n  } catch {\n    // ignore\n  }\n  try {\n    const containerDetectors = await import(\n      '@opentelemetry/resource-detector-container'\n    );\n    detectors.push(containerDetectors.containerDetector);\n  } catch {\n    // ignore\n  }\n\n  if (config.detectResources) {\n    const detectedResource = await detectResources({\n      detectors,\n    });\n\n    resource = detectedResource.merge(\n      resourceFromAttributes({\n        [ATTR_SERVICE_NAME]: config.serviceName,\n        [ATTR_SERVICE_VERSION]: config.serviceVersion || '1.0.0',\n        'deployment.environment': config.deploymentEnvironment || 'development',\n        ...customResourceAttributes, // Merge custom resource attributes\n      }),\n    );\n  } else {\n    resource = resourceFromAttributes({\n      [ATTR_SERVICE_NAME]: config.serviceName,\n      [ATTR_SERVICE_VERSION]: config.serviceVersion || '1.0.0',\n      'deployment.environment': config.deploymentEnvironment || 'development',\n      ...customResourceAttributes, // Merge custom resource attributes\n    });\n  }\n\n  // Default to selective (near-zero overhead) vs full auto (~81% overhead)\n  const instrumentations =\n    config.selectiveInstrumentation === false\n      ? [getNodeAutoInstrumentations()]\n      : config.instrumentations || [];\n\n  const traceExporter = new OTLPTraceExporter({\n    url: `${config.otlpEndpoint || 'http://localhost:4318'}/v1/traces`,\n    headers: otlpHeaders,\n  });\n\n  // Enables tail sampling via sampling.tail.keep attribute\n  const spanProcessor = new TailSamplingSpanProcessor(\n    new BatchSpanProcessor(traceExporter),\n  );\n\n  const sdk = new NodeSDK({\n    resource,\n    spanProcessor, // Use our wrapped processor instead of traceExporter directly\n    metricReader: new PeriodicExportingMetricReader({\n      exporter: new OTLPMetricExporter({\n        url: `${config.otlpEndpoint || 'http://localhost:4318'}/v1/metrics`,\n        headers: otlpHeaders,\n      }),\n    }),\n    logRecordProcessors: [\n      new BatchLogRecordProcessor(\n        new OTLPLogExporter({\n          url: `${config.otlpEndpoint || 'http://localhost:4318'}/v1/logs`,\n          headers: otlpHeaders,\n        }),\n      ),\n    ],\n    instrumentations,\n  });\n\n  try {\n    await sdk.start();\n    getLogger().info('OpenTelemetry instrumentation started successfully');\n  } catch (error) {\n    getLogger().error(\n      'Failed to start OpenTelemetry SDK',\n      error instanceof Error ? error : undefined,\n    );\n    throw error;\n  }\n\n  // Track current SDK for shutdown handler\n  currentSDK = sdk;\n\n  if (!shutdownHandlerRegistered) {\n    shutdownHandlerRegistered = true;\n\n    const shutdownHandler = () => {\n      shutdownInstrumentation()\n        .then(() => {\n          // eslint-disable-next-line unicorn/no-process-exit\n          process.exit(0);\n        })\n        .catch((error) => {\n          getLogger().error(\n            'Shutdown error',\n            error instanceof Error ? error : undefined,\n          );\n          // eslint-disable-next-line unicorn/no-process-exit\n          process.exit(1);\n        });\n    };\n\n    process.on('SIGTERM', shutdownHandler);\n    process.on('SIGINT', shutdownHandler);\n  }\n\n  return sdk;\n}\n"]}

package/dist/logger.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var chunk4OAT42CA_cjs = require('./chunk-4OAT42CA.cjs');
+require('./chunk-Y4Y2S7BM.cjs');
+require('./chunk-URRW6M2C.cjs');
+require('./chunk-G7VZBCD6.cjs');
+
+
+
+Object.defineProperty(exports, "LOG_LEVEL", {
+  enumerable: true,
+  get: function () { return chunk4OAT42CA_cjs.LOG_LEVEL; }
+});
+Object.defineProperty(exports, "LoggedOperation", {
+  enumerable: true,
+  get: function () { return chunk4OAT42CA_cjs.LoggedOperation; }
+});
+//# sourceMappingURL=logger.cjs.map
+//# sourceMappingURL=logger.cjs.map

package/dist/logger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"logger.cjs"}

package/dist/logger.d.cts

@@ -0,0 +1,146 @@
+export { Logger as PinoLogger } from 'pino';
+
+/**
+ * Logger types and utilities for autotel
+ *
+ * **Recommended Approach:** Bring your own logger (Pino, Winston, Bunyan, etc.)
+ *
+ * Simply create your logger instance and pass it to `init()`.
+ * Autotel automatically instruments Pino and Winston to:
+ * - Inject trace context (traceId, spanId) into log records
+ * - Record errors in the active span
+ * - Bridge logs to OpenTelemetry Logs API for OTLP export
+ *
+ * @example Using Pino (recommended, auto-instrumented)
+ * ```typescript
+ * import pino from 'pino';  // npm install pino
+ * import { init } from 'autotel';
+ *
+ * const logger = pino({ level: 'info' });
+ * init({ service: 'my-app', logger });
+ *
+ * // Logs automatically include traceId/spanId and export via OTLP!
+ * logger.info('User created', { userId: '123' });
+ * ```
+ *
+ * @example Using Winston (auto-instrumented)
+ * ```typescript
+ * import winston from 'winston';  // npm install winston
+ * import { init } from 'autotel';
+ *
+ * const logger = winston.createLogger({
+ *   level: 'info',
+ *   format: winston.format.json(),
+ *   transports: [new winston.transports.Console()]
+ * });
+ * init({ service: 'my-app', logger });
+ * ```
+ *
+ * @example Using Bunyan (manual instrumentation)
+ * ```typescript
+ * import bunyan from 'bunyan';  // npm install bunyan @opentelemetry/instrumentation-bunyan
+ * import { init } from 'autotel';
+ * import { BunyanInstrumentation } from '@opentelemetry/instrumentation-bunyan';
+ *
+ * const logger = bunyan.createLogger({ name: 'my-app' });
+ * init({
+ *   service: 'my-app',
+ *   logger,
+ *   instrumentations: [new BunyanInstrumentation()]
+ * });
+ * ```
+ *
+ * @example Custom logger (any logger with 4 methods)
+ * ```typescript
+ * const logger = {
+ *   info: (msg, extra) => console.log(msg, extra),
+ *   warn: (msg, extra) => console.warn(msg, extra),
+ *   error: (msg, err, extra) => console.error(msg, err, extra),
+ *   debug: (msg, extra) => console.debug(msg, extra),
+ * };
+ * init({ service: 'my-app', logger });
+ * ```
+ */
+/**
+ * Log level constants
+ */
+declare const LOG_LEVEL: {
+    readonly DEBUG: "debug";
+    readonly INFO: "info";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+};
+type LogLevel = (typeof LOG_LEVEL)[keyof typeof LOG_LEVEL];
+/**
+ * Logger configuration (for reference - not needed with BYOL approach)
+ */
+interface LoggerConfig {
+    service: string;
+    level?: LogLevel;
+    pretty?: boolean;
+    redact?: string[] | false;
+}
+/**
+ * Simple logger interface - minimal contract for any logger
+ *
+ * Bring your own Pino, Winston, or any logger with these 4 methods.
+ * Autotel automatically instruments Pino and Winston loggers to:
+ * - Inject trace context (traceId, spanId) into log records
+ * - Record errors in the active span
+ * - Bridge logs to OpenTelemetry Logs API for OTLP export
+ *
+ * @example Using Pino
+ * ```typescript
+ * import pino from 'pino';
+ * const logger = pino({ level: 'info' });
+ * init({ service: 'my-app', logger });
+ * ```
+ *
+ * @example Using Winston
+ * ```typescript
+ * import winston from 'winston';
+ * const logger = winston.createLogger({ level: 'info' });
+ * init({ service: 'my-app', logger });
+ * ```
+ */
+interface Logger {
+    info(message: string, extra?: Record<string, unknown>): void;
+    warn(message: string, extra?: Record<string, unknown>): void;
+    error(message: string, error?: Error, extra?: Record<string, unknown>): void;
+    debug(message: string, extra?: Record<string, unknown>): void;
+}
+/**
+ * Alias for Logger interface (backwards compatibility)
+ * @deprecated Use Logger instead
+ */
+type ILogger = Logger;
+
+interface LoggedOperationOptions {
+    /** Operation name for tracing (e.g., 'user.createUser') */
+    operationName: string;
+}
+/**
+ * TS5+ Standard Decorator for logging and tracing operations
+ * Uses TC39 Stage 3 decorator syntax
+ *
+ * This is the traditional per-method decorator approach.
+ * For zero-boilerplate solution, see @Instrumented class decorator.
+ *
+ * @example
+ * // Simple usage
+ * class OrderService {
+ *   constructor(private readonly deps: { log: Logger }) {}
+ *
+ *   @LoggedOperation('order.create')
+ *   async createOrder(data: CreateOrderData) {
+ *     this.deps.logger.info('Creating order', data)
+ *   }
+ * }
+ *
+ * // Advanced usage (future-proof for options)
+ * @LoggedOperation({ operationName: 'order.create' })
+ * async createOrder(data: CreateOrderData) { }
+ */
+declare function LoggedOperation(operationNameOrOptions: string | LoggedOperationOptions): <This, Args extends unknown[], Return>(originalMethod: (this: This, ...args: Args) => Promise<Return>, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Promise<Return>>) => (this: This, ...args: Args) => Promise<Return>;
+
+export { type ILogger, LOG_LEVEL, type LogLevel, LoggedOperation, type LoggedOperationOptions, type Logger, type LoggerConfig };

package/dist/logger.d.ts

@@ -0,0 +1,146 @@
+export { Logger as PinoLogger } from 'pino';
+
+/**
+ * Logger types and utilities for autotel
+ *
+ * **Recommended Approach:** Bring your own logger (Pino, Winston, Bunyan, etc.)
+ *
+ * Simply create your logger instance and pass it to `init()`.
+ * Autotel automatically instruments Pino and Winston to:
+ * - Inject trace context (traceId, spanId) into log records
+ * - Record errors in the active span
+ * - Bridge logs to OpenTelemetry Logs API for OTLP export
+ *
+ * @example Using Pino (recommended, auto-instrumented)
+ * ```typescript
+ * import pino from 'pino';  // npm install pino
+ * import { init } from 'autotel';
+ *
+ * const logger = pino({ level: 'info' });
+ * init({ service: 'my-app', logger });
+ *
+ * // Logs automatically include traceId/spanId and export via OTLP!
+ * logger.info('User created', { userId: '123' });
+ * ```
+ *
+ * @example Using Winston (auto-instrumented)
+ * ```typescript
+ * import winston from 'winston';  // npm install winston
+ * import { init } from 'autotel';
+ *
+ * const logger = winston.createLogger({
+ *   level: 'info',
+ *   format: winston.format.json(),
+ *   transports: [new winston.transports.Console()]
+ * });
+ * init({ service: 'my-app', logger });
+ * ```
+ *
+ * @example Using Bunyan (manual instrumentation)
+ * ```typescript
+ * import bunyan from 'bunyan';  // npm install bunyan @opentelemetry/instrumentation-bunyan
+ * import { init } from 'autotel';
+ * import { BunyanInstrumentation } from '@opentelemetry/instrumentation-bunyan';
+ *
+ * const logger = bunyan.createLogger({ name: 'my-app' });
+ * init({
+ *   service: 'my-app',
+ *   logger,
+ *   instrumentations: [new BunyanInstrumentation()]
+ * });
+ * ```
+ *
+ * @example Custom logger (any logger with 4 methods)
+ * ```typescript
+ * const logger = {
+ *   info: (msg, extra) => console.log(msg, extra),
+ *   warn: (msg, extra) => console.warn(msg, extra),
+ *   error: (msg, err, extra) => console.error(msg, err, extra),
+ *   debug: (msg, extra) => console.debug(msg, extra),
+ * };
+ * init({ service: 'my-app', logger });
+ * ```
+ */
+/**
+ * Log level constants
+ */
+declare const LOG_LEVEL: {
+    readonly DEBUG: "debug";
+    readonly INFO: "info";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+};
+type LogLevel = (typeof LOG_LEVEL)[keyof typeof LOG_LEVEL];
+/**
+ * Logger configuration (for reference - not needed with BYOL approach)
+ */
+interface LoggerConfig {
+    service: string;
+    level?: LogLevel;
+    pretty?: boolean;
+    redact?: string[] | false;
+}
+/**
+ * Simple logger interface - minimal contract for any logger
+ *
+ * Bring your own Pino, Winston, or any logger with these 4 methods.
+ * Autotel automatically instruments Pino and Winston loggers to:
+ * - Inject trace context (traceId, spanId) into log records
+ * - Record errors in the active span
+ * - Bridge logs to OpenTelemetry Logs API for OTLP export
+ *
+ * @example Using Pino
+ * ```typescript
+ * import pino from 'pino';
+ * const logger = pino({ level: 'info' });
+ * init({ service: 'my-app', logger });
+ * ```
+ *
+ * @example Using Winston
+ * ```typescript
+ * import winston from 'winston';
+ * const logger = winston.createLogger({ level: 'info' });
+ * init({ service: 'my-app', logger });
+ * ```
+ */
+interface Logger {
+    info(message: string, extra?: Record<string, unknown>): void;
+    warn(message: string, extra?: Record<string, unknown>): void;
+    error(message: string, error?: Error, extra?: Record<string, unknown>): void;
+    debug(message: string, extra?: Record<string, unknown>): void;
+}
+/**
+ * Alias for Logger interface (backwards compatibility)
+ * @deprecated Use Logger instead
+ */
+type ILogger = Logger;
+
+interface LoggedOperationOptions {
+    /** Operation name for tracing (e.g., 'user.createUser') */
+    operationName: string;
+}
+/**
+ * TS5+ Standard Decorator for logging and tracing operations
+ * Uses TC39 Stage 3 decorator syntax
+ *
+ * This is the traditional per-method decorator approach.
+ * For zero-boilerplate solution, see @Instrumented class decorator.
+ *
+ * @example
+ * // Simple usage
+ * class OrderService {
+ *   constructor(private readonly deps: { log: Logger }) {}
+ *
+ *   @LoggedOperation('order.create')
+ *   async createOrder(data: CreateOrderData) {
+ *     this.deps.logger.info('Creating order', data)
+ *   }
+ * }
+ *
+ * // Advanced usage (future-proof for options)
+ * @LoggedOperation({ operationName: 'order.create' })
+ * async createOrder(data: CreateOrderData) { }
+ */
+declare function LoggedOperation(operationNameOrOptions: string | LoggedOperationOptions): <This, Args extends unknown[], Return>(originalMethod: (this: This, ...args: Args) => Promise<Return>, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Promise<Return>>) => (this: This, ...args: Args) => Promise<Return>;
+
+export { type ILogger, LOG_LEVEL, type LogLevel, LoggedOperation, type LoggedOperationOptions, type Logger, type LoggerConfig };

package/dist/logger.js

@@ -0,0 +1,6 @@
+export { LOG_LEVEL, LoggedOperation } from './chunk-5GWX5LFW.js';
+import './chunk-KVGNW3FC.js';
+import './chunk-P6JUDYNO.js';
+import './chunk-Z6ZWNWWR.js';
+//# sourceMappingURL=logger.js.map
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"logger.js"}

package/dist/metric-helpers.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var chunkNC52UBR2_cjs = require('./chunk-NC52UBR2.cjs');
+require('./chunk-Y4Y2S7BM.cjs');
+require('./chunk-URRW6M2C.cjs');
+require('./chunk-G7VZBCD6.cjs');
+
+
+
+Object.defineProperty(exports, "createCounter", {
+  enumerable: true,
+  get: function () { return chunkNC52UBR2_cjs.createCounter; }
+});
+Object.defineProperty(exports, "createHistogram", {
+  enumerable: true,
+  get: function () { return chunkNC52UBR2_cjs.createHistogram; }
+});
+Object.defineProperty(exports, "createObservableGauge", {
+  enumerable: true,
+  get: function () { return chunkNC52UBR2_cjs.createObservableGauge; }
+});
+Object.defineProperty(exports, "createUpDownCounter", {
+  enumerable: true,
+  get: function () { return chunkNC52UBR2_cjs.createUpDownCounter; }
+});
+Object.defineProperty(exports, "getMeter", {
+  enumerable: true,
+  get: function () { return chunkNC52UBR2_cjs.getMeter; }
+});
+//# sourceMappingURL=metric-helpers.cjs.map
+//# sourceMappingURL=metric-helpers.cjs.map

package/dist/metric-helpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"metric-helpers.cjs"}

package/dist/metric-helpers.d.cts

@@ -0,0 +1,13 @@
+import { Meter, Counter, Histogram, UpDownCounter, ObservableGauge } from '@opentelemetry/api';
+
+declare function getMeter(): Meter;
+type CounterOptions = Parameters<Meter['createCounter']>[1];
+type HistogramOptions = Parameters<Meter['createHistogram']>[1];
+type UpDownCounterOptions = Parameters<Meter['createUpDownCounter']>[1];
+type ObservableGaugeOptions = Parameters<Meter['createObservableGauge']>[1];
+declare function createCounter(name: string, options?: CounterOptions): Counter;
+declare function createHistogram(name: string, options?: HistogramOptions): Histogram;
+declare function createUpDownCounter(name: string, options?: UpDownCounterOptions): UpDownCounter;
+declare function createObservableGauge(name: string, options?: ObservableGaugeOptions): ObservableGauge;
+
+export { createCounter, createHistogram, createObservableGauge, createUpDownCounter, getMeter };

package/dist/metric-helpers.d.ts

@@ -0,0 +1,13 @@
+import { Meter, Counter, Histogram, UpDownCounter, ObservableGauge } from '@opentelemetry/api';
+
+declare function getMeter(): Meter;
+type CounterOptions = Parameters<Meter['createCounter']>[1];
+type HistogramOptions = Parameters<Meter['createHistogram']>[1];
+type UpDownCounterOptions = Parameters<Meter['createUpDownCounter']>[1];
+type ObservableGaugeOptions = Parameters<Meter['createObservableGauge']>[1];
+declare function createCounter(name: string, options?: CounterOptions): Counter;
+declare function createHistogram(name: string, options?: HistogramOptions): Histogram;
+declare function createUpDownCounter(name: string, options?: UpDownCounterOptions): UpDownCounter;
+declare function createObservableGauge(name: string, options?: ObservableGaugeOptions): ObservableGauge;
+
+export { createCounter, createHistogram, createObservableGauge, createUpDownCounter, getMeter };

package/dist/metric-helpers.js

@@ -0,0 +1,6 @@
+export { createCounter, createHistogram, createObservableGauge, createUpDownCounter, getMeter } from './chunk-W7LHZVQF.js';
+import './chunk-KVGNW3FC.js';
+import './chunk-P6JUDYNO.js';
+import './chunk-Z6ZWNWWR.js';
+//# sourceMappingURL=metric-helpers.js.map
+//# sourceMappingURL=metric-helpers.js.map

package/dist/metric-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"metric-helpers.js"}

package/dist/metric-testing.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var chunkYTXEZ4SD_cjs = require('./chunk-YTXEZ4SD.cjs');
+require('./chunk-G7VZBCD6.cjs');
+
+
+
+Object.defineProperty(exports, "assertEventTracked", {
+  enumerable: true,
+  get: function () { return chunkYTXEZ4SD_cjs.assertEventTracked; }
+});
+Object.defineProperty(exports, "assertOutcomeTracked", {
+  enumerable: true,
+  get: function () { return chunkYTXEZ4SD_cjs.assertOutcomeTracked; }
+});
+Object.defineProperty(exports, "createMetricsCollector", {
+  enumerable: true,
+  get: function () { return chunkYTXEZ4SD_cjs.createMetricsCollector; }
+});
+//# sourceMappingURL=metric-testing.cjs.map
+//# sourceMappingURL=metric-testing.cjs.map

package/dist/metric-testing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"metric-testing.cjs"}

package/dist/metric-testing.d.cts

@@ -0,0 +1,110 @@
+import { EventAttributes, FunnelStatus, OutcomeStatus } from './event-subscriber.cjs';
+
+/**
+ * Testing utilities for Metrics
+ *
+ * Provides in-memory collection of metrics for testing purposes.
+ */
+
+interface MetricsEvent {
+    event: string;
+    attributes?: EventAttributes;
+    service: string;
+    timestamp: number;
+}
+interface MetricsFunnelStep {
+    funnel: string;
+    status: FunnelStatus;
+    attributes?: EventAttributes;
+    service: string;
+    timestamp: number;
+}
+interface MetricsOutcome {
+    operation: string;
+    status: OutcomeStatus;
+    attributes?: EventAttributes;
+    service: string;
+    timestamp: number;
+}
+interface MetricsValue {
+    metric: string;
+    value: number;
+    attributes?: EventAttributes;
+    service: string;
+    timestamp: number;
+}
+/**
+ * In-memory metrics collector for testing
+ */
+interface MetricsCollector {
+    /** Get all collected events */
+    getEvents(): MetricsEvent[];
+    /** Get all collected funnel steps */
+    getFunnelSteps(): MetricsFunnelStep[];
+    /** Get all collected outcomes */
+    getOutcomes(): MetricsOutcome[];
+    /** Get all collected values */
+    getValues(): MetricsValue[];
+    /** Clear all collected metrics */
+    clear(): void;
+    /** Record an event (internal use) */
+    recordEvent(event: MetricsEvent): void;
+    /** Record a funnel step (internal use) */
+    recordFunnelStep(step: MetricsFunnelStep): void;
+    /** Record an outcome (internal use) */
+    recordOutcome(outcome: MetricsOutcome): void;
+    /** Record a value (internal use) */
+    recordValue(value: MetricsValue): void;
+}
+/**
+ * Create an in-memory metrics collector for testing
+ *
+ * @example
+ * ```typescript
+ * const collector = createMetricsCollector()
+ *
+ * const metrics = new Metric('test-service', { collector })
+ * metrics.trackEvent('order.completed', { orderId: '123' })
+ *
+ * const event =collector.getEvents()
+ * expect(events).toHaveLength(1)
+ * expect(events[0].event).toBe('order.completed')
+ * ```
+ */
+declare function createMetricsCollector(): MetricsCollector;
+/**
+ * Assert that a metric event was tracked
+ *
+ * @example
+ * ```typescript
+ * assertEventTracked({
+ *   collector,
+ *   eventName: 'order.completed',
+ *   attributes: { orderId: '123' }
+ * })
+ * ```
+ */
+declare function assertEventTracked(options: {
+    collector: MetricsCollector;
+    eventName: string;
+    attributes?: Record<string, unknown>;
+}): void;
+/**
+ * Assert that an outcome was tracked
+ *
+ * @example
+ * ```typescript
+ * assertOutcomeTracked({
+ *   collector,
+ *   operation: 'payment.process',
+ *   status: 'success'
+ * })
+ * ```
+ */
+declare function assertOutcomeTracked(options: {
+    collector: MetricsCollector;
+    operation: string;
+    status: 'success' | 'failure' | 'partial';
+}): void;
+
+export { type MetricsCollector, type MetricsEvent, type MetricsFunnelStep, type MetricsOutcome, type MetricsValue, assertEventTracked, assertOutcomeTracked, createMetricsCollector };