autotel 4.0.0 → 4.2.0

package/src/yaml-config.test.ts

@@ -1,337 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import {
-  loadYamlConfigFromFile,
-  loadYamlConfig,
-  hasYamlConfig,
-} from './yaml-config';
-import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-import { AdaptiveSampler } from './sampling';
-
-describe('yaml-config', () => {
-  const testDir = path.join(tmpdir(), `autotel-yaml-test-${Date.now()}`);
-
-  beforeEach(() => {
-    mkdirSync(testDir, { recursive: true });
-    // Reset environment variables
-    delete process.env.AUTOTEL_CONFIG_FILE;
-    delete process.env.TEST_SERVICE_NAME;
-    delete process.env.TEST_ENDPOINT;
-    delete process.env.UNDEFINED_VAR;
-  });
-
-  afterEach(() => {
-    // Cleanup test directory
-    try {
-      rmSync(testDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe('loadYamlConfigFromFile', () => {
-    it('should parse basic YAML config', () => {
-      const yaml = `
-service:
-  name: test-service
-  version: 1.0.0
-  environment: production
-debug: true
-`;
-      const filePath = path.join(testDir, 'test.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.service).toBe('test-service');
-      expect(config.version).toBe('1.0.0');
-      expect(config.environment).toBe('production');
-      expect(config.debug).toBe(true);
-    });
-
-    it('should parse exporter configuration', () => {
-      const yaml = `
-exporter:
-  endpoint: http://localhost:4318
-  protocol: grpc
-  headers:
-    x-api-key: secret-key
-    x-custom: value
-`;
-      const filePath = path.join(testDir, 'exporter.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.endpoint).toBe('http://localhost:4318');
-      expect(config.protocol).toBe('grpc');
-      expect(config.headers).toEqual({
-        'x-api-key': 'secret-key',
-        'x-custom': 'value',
-      });
-    });
-
-    it('should parse resource attributes', () => {
-      const yaml = `
-resource:
-  deployment.environment: production
-  team: backend
-  version: 2.0.0
-`;
-      const filePath = path.join(testDir, 'resource.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.resourceAttributes).toEqual({
-        'deployment.environment': 'production',
-        team: 'backend',
-        version: '2.0.0',
-      });
-    });
-
-    it('should parse autoInstrumentations as array', () => {
-      const yaml = `
-autoInstrumentations:
-  - express
-  - http
-  - pino
-`;
-      const filePath = path.join(testDir, 'autoInstrumentations.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.autoInstrumentations).toEqual(['express', 'http', 'pino']);
-    });
-
-    it('should parse autoInstrumentations as object', () => {
-      const yaml = `
-autoInstrumentations:
-  express:
-    enabled: true
-  http:
-    enabled: false
-`;
-      const filePath = path.join(testDir, 'autoInstrumentations-obj.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.autoInstrumentations).toEqual({
-        express: { enabled: true },
-        http: { enabled: false },
-      });
-    });
-
-    it('should substitute environment variables', () => {
-      process.env.TEST_SERVICE_NAME = 'from-env';
-      process.env.TEST_ENDPOINT = 'http://env-endpoint:4318';
-
-      const yaml = `
-service:
-  name: \${env:TEST_SERVICE_NAME}
-exporter:
-  endpoint: \${env:TEST_ENDPOINT}
-`;
-      const filePath = path.join(testDir, 'env-test.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.service).toBe('from-env');
-      expect(config.endpoint).toBe('http://env-endpoint:4318');
-    });
-
-    it('should use default value when env var not set', () => {
-      const yaml = `
-service:
-  name: \${env:UNDEFINED_VAR:-default-service}
-  environment: \${env:NODE_ENV:-development}
-`;
-      const filePath = path.join(testDir, 'default-test.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.service).toBe('default-service');
-      // NODE_ENV might be set in test environment, so just check it's a string
-      expect(typeof config.environment).toBe('string');
-    });
-
-    it('should handle nested env var substitution', () => {
-      process.env.TEST_SERVICE_NAME = 'nested-service';
-
-      const yaml = `
-service:
-  name: \${env:TEST_SERVICE_NAME}
-exporter:
-  headers:
-    x-api-key: \${env:TEST_API_KEY:-fallback-key}
-`;
-      const filePath = path.join(testDir, 'nested-env.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.service).toBe('nested-service');
-      expect(config.headers).toEqual({
-        'x-api-key': 'fallback-key',
-      });
-    });
-
-    it('should warn on missing env var without default', () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-      const yaml = `
-service:
-  name: \${env:DEFINITELY_NOT_SET}
-`;
-      const filePath = path.join(testDir, 'missing-env.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      // Empty string from missing env var results in undefined (filtered out as falsy)
-      expect(config.service).toBeUndefined();
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('DEFINITELY_NOT_SET'),
-      );
-
-      warnSpy.mockRestore();
-    });
-
-    it('should throw on invalid YAML', () => {
-      const yaml = `
-service:
-  name: test
-  invalid yaml: [unclosed
-`;
-      const filePath = path.join(testDir, 'invalid.yaml');
-      writeFileSync(filePath, yaml);
-
-      expect(() => loadYamlConfigFromFile(filePath)).toThrow();
-    });
-
-    it('should throw on non-existent file', () => {
-      expect(() => loadYamlConfigFromFile('/non/existent/path.yaml')).toThrow();
-    });
-
-    it('should map sampling preset to config.sampling shorthand', () => {
-      const yaml = `
-sampling:
-  preset: production
-`;
-      const filePath = path.join(testDir, 'sampling-preset.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.sampling).toBe('production');
-      expect(config.sampler).toBeUndefined();
-    });
-
-    it('should prefer sampling preset over typed sampler config', () => {
-      const yaml = `
-sampling:
-  preset: off
-  type: adaptive
-  baseline_rate: 0.5
-`;
-      const filePath = path.join(testDir, 'sampling-preset-precedence.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.sampling).toBe('off');
-      expect(config.sampler).toBeUndefined();
-    });
-
-    it('should warn when preset is combined with ignored override fields', () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-      const yaml = `
-sampling:
-  preset: production
-  type: adaptive
-  baseline_rate: 0.5
-  slow_threshold_ms: 250
-`;
-      const filePath = path.join(testDir, 'sampling-preset-warning.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-
-      expect(config.sampling).toBe('production');
-      expect(config.sampler).toBeUndefined();
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining(
-          'sampling.preset="production" ignores these YAML fields',
-        ),
-      );
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('type, baseline_rate, slow_threshold_ms'),
-      );
-
-      warnSpy.mockRestore();
-    });
-
-    it('should still build sampler from typed YAML config without preset', () => {
-      const yaml = `
-sampling:
-  type: adaptive
-  baseline_rate: 0.25
-`;
-      const filePath = path.join(testDir, 'sampling-adaptive.yaml');
-      writeFileSync(filePath, yaml);
-
-      const config = loadYamlConfigFromFile(filePath);
-      expect(config.sampler).toBeInstanceOf(AdaptiveSampler);
-      expect(config.sampling).toBeUndefined();
-    });
-  });
-
-  describe('loadYamlConfig', () => {
-    it('should return null when no config file exists', () => {
-      // No AUTOTEL_CONFIG_FILE set and no autotel.yaml in cwd
-      const result = loadYamlConfig();
-      // Result depends on whether autotel.yaml exists in cwd
-      // This test just verifies the function doesn't throw
-      expect(result === null || typeof result === 'object').toBe(true);
-    });
-
-    it('should load from AUTOTEL_CONFIG_FILE env var', () => {
-      const yaml = `
-service:
-  name: from-env-path
-`;
-      const filePath = path.join(testDir, 'env-config.yaml');
-      writeFileSync(filePath, yaml);
-      process.env.AUTOTEL_CONFIG_FILE = filePath;
-
-      const config = loadYamlConfig();
-      expect(config).not.toBeNull();
-      expect(config?.service).toBe('from-env-path');
-    });
-
-    it('should warn when AUTOTEL_CONFIG_FILE points to non-existent file', () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-      process.env.AUTOTEL_CONFIG_FILE = '/non/existent/file.yaml';
-
-      const config = loadYamlConfig();
-      expect(config).toBeNull();
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Config file not found'),
-      );
-
-      warnSpy.mockRestore();
-    });
-  });
-
-  describe('hasYamlConfig', () => {
-    it('should return false when no config exists', () => {
-      // Delete any AUTOTEL_CONFIG_FILE
-      delete process.env.AUTOTEL_CONFIG_FILE;
-      // This test depends on cwd not having autotel.yaml
-      // Just verify it returns a boolean
-      expect(typeof hasYamlConfig()).toBe('boolean');
-    });
-
-    it('should return true when AUTOTEL_CONFIG_FILE exists', () => {
-      const filePath = path.join(testDir, 'has-config.yaml');
-      writeFileSync(filePath, 'service:\n  name: test\n');
-      process.env.AUTOTEL_CONFIG_FILE = filePath;
-
-      expect(hasYamlConfig()).toBe(true);
-    });
-  });
-});

package/src/yaml-config.ts

@@ -1,342 +0,0 @@
-/**
- * YAML configuration loader for autotel
- *
- * Supports:
- * - Auto-discovery of autotel.yaml in cwd
- * - AUTOTEL_CONFIG_FILE env var override
- * - Environment variable substitution: ${env:VAR} and ${env:VAR:-default}
- *
- * @example Auto-discovery
- * ```yaml
- * # autotel.yaml in project root
- * service:
- *   name: my-service
- * exporter:
- *   endpoint: ${env:OTEL_EXPORTER_OTLP_ENDPOINT:-http://localhost:4318}
- * ```
- *
- * @example Explicit path
- * ```bash
- * AUTOTEL_CONFIG_FILE=./config/otel.yaml tsx --import autotel/auto src/index.ts
- * ```
- */
-
-import { readFileSync, existsSync } from 'node:fs';
-import path from 'node:path';
-import type { AutotelConfig } from './init';
-import {
-  AdaptiveSampler,
-  AlwaysSampler,
-  NeverSampler,
-  RandomSampler,
-  type SamplingPreset,
-} from './sampling';
-
-/**
- * Lazy-load yaml parser (optional peer dependency)
- * Only loads when a YAML config file is actually found
- */
-import { requireModule } from './node-require';
-
-function loadYamlParser(): (content: string) => unknown {
-  try {
-    const mod = requireModule<{ parse: (content: string) => unknown }>('yaml');
-    return mod.parse;
-  } catch {
-    throw new Error('YAML parser not found. Install with: pnpm add yaml');
-  }
-}
-
-/**
- * YAML config structure
- * Maps to AutotelConfig with user-friendly naming
- */
-export interface YamlConfig {
-  service?: {
-    name?: string;
-    version?: string;
-    environment?: string;
-  };
-  exporter?: {
-    endpoint?: string;
-    protocol?: 'http' | 'grpc';
-    headers?: Record<string, string>;
-  };
-  resource?: Record<string, string | number | boolean>;
-  sampling?: {
-    preset?: SamplingPreset;
-    type?: 'adaptive' | 'always_on' | 'always_off' | 'ratio';
-    ratio?: number;
-    baseline_rate?: number;
-    always_sample_errors?: boolean;
-    always_sample_slow?: boolean;
-    slow_threshold_ms?: number;
-  };
-  autoInstrumentations?: string[] | Record<string, { enabled?: boolean }>;
-  debug?: boolean;
-}
-
-/**
- * Environment variable substitution regex
- * Matches ${env:VAR_NAME} and ${env:VAR_NAME:-default}
- */
-const ENV_VAR_PATTERN = /\$\{env:([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
-
-/**
- * Substitute ${env:VAR} and ${env:VAR:-default} in a string
- *
- * @param value - String potentially containing env var references
- * @returns String with env vars substituted
- *
- * @example
- * substituteEnvVars('${env:NODE_ENV:-development}')
- * // Returns 'production' if NODE_ENV=production, else 'development'
- */
-function substituteEnvVars(value: string): string {
-  return value.replaceAll(
-    ENV_VAR_PATTERN,
-    (_match, varName: string, defaultValue?: string) => {
-      const envValue = process.env[varName];
-      if (envValue !== undefined) return envValue;
-      if (defaultValue !== undefined) return defaultValue;
-      console.warn(
-        `[autotel] Environment variable ${varName} not set and no default provided`,
-      );
-      return '';
-    },
-  );
-}
-
-/**
- * Recursively substitute env vars in an object
- *
- * @param obj - Object to process
- * @returns Object with all string values having env vars substituted
- */
-function substituteEnvVarsDeep(obj: unknown): unknown {
-  if (typeof obj === 'string') {
-    return substituteEnvVars(obj);
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => substituteEnvVarsDeep(item));
-  }
-  if (obj && typeof obj === 'object') {
-    const result: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = substituteEnvVarsDeep(value);
-    }
-    return result;
-  }
-  return obj;
-}
-
-/**
- * Find YAML config file path
- *
- * Priority:
- * 1. AUTOTEL_CONFIG_FILE env var (explicit path)
- * 2. autotel.yaml in cwd (convention)
- * 3. autotel.yml in cwd (alternative extension)
- *
- * @returns File path if found, null otherwise
- */
-function findConfigFile(): string | null {
-  // Check env var first (explicit takes priority)
-  const envPath = process.env.AUTOTEL_CONFIG_FILE;
-  if (envPath) {
-    const resolved = path.resolve(envPath);
-    if (existsSync(resolved)) return resolved;
-    console.warn(`[autotel] Config file not found: ${envPath}`);
-    return null;
-  }
-
-  // Auto-discover autotel.yaml in cwd
-  const conventionPath = path.resolve(process.cwd(), 'autotel.yaml');
-  if (existsSync(conventionPath)) return conventionPath;
-
-  // Also check .yml extension
-  const altPath = path.resolve(process.cwd(), 'autotel.yml');
-  if (existsSync(altPath)) return altPath;
-
-  return null;
-}
-
-/**
- * Convert YAML config structure to AutotelConfig
- *
- * @param yaml - Parsed and env-substituted YAML config
- * @returns Partial AutotelConfig ready for merging
- */
-function yamlToAutotelConfig(yaml: YamlConfig): Partial<AutotelConfig> {
-  const config: Partial<AutotelConfig> = {};
-
-  // Service configuration
-  if (yaml.service?.name) config.service = yaml.service.name;
-  if (yaml.service?.version) config.version = yaml.service.version;
-  if (yaml.service?.environment) config.environment = yaml.service.environment;
-
-  // Exporter configuration
-  if (yaml.exporter?.endpoint) config.endpoint = yaml.exporter.endpoint;
-  if (yaml.exporter?.protocol) config.protocol = yaml.exporter.protocol;
-  if (yaml.exporter?.headers) config.headers = yaml.exporter.headers;
-
-  // Resource attributes (flattened)
-  if (yaml.resource) config.resourceAttributes = yaml.resource;
-
-  // Integrations
-  if (yaml.autoInstrumentations)
-    config.autoInstrumentations = yaml.autoInstrumentations;
-
-  // Debug mode
-  if (yaml.debug !== undefined) config.debug = yaml.debug;
-
-  // Sampling configuration
-  if (yaml.sampling?.preset) {
-    warnOnIgnoredPresetOverrides(yaml.sampling);
-    config.sampling = yaml.sampling.preset;
-  } else {
-    const sampler = createSamplerFromYaml(yaml.sampling);
-    if (sampler) config.sampler = sampler;
-  }
-
-  return config;
-}
-
-function createSamplerFromYaml(
-  sampling?: YamlConfig['sampling'],
-): AutotelConfig['sampler'] {
-  if (!sampling) return undefined;
-  if (sampling.preset) return undefined;
-
-  const type = sampling.type ?? 'adaptive';
-
-  try {
-    switch (type) {
-      case 'adaptive': {
-        return new AdaptiveSampler({
-          baselineSampleRate: sampling.baseline_rate,
-          alwaysSampleErrors: sampling.always_sample_errors,
-          alwaysSampleSlow: sampling.always_sample_slow,
-          slowThresholdMs: sampling.slow_threshold_ms,
-        });
-      }
-      case 'always_on': {
-        return new AlwaysSampler();
-      }
-      case 'always_off': {
-        return new NeverSampler();
-      }
-      case 'ratio': {
-        if (sampling.ratio === undefined) {
-          console.warn(
-            '[autotel] sampling.ratio missing in YAML sampling config. Falling back to adaptive sampler.',
-          );
-          return new AdaptiveSampler();
-        }
-        return new RandomSampler(sampling.ratio);
-      }
-      default: {
-        console.warn(
-          `[autotel] Unknown sampling type "${type}" in YAML config. Falling back to defaults.`,
-        );
-        return undefined;
-      }
-    }
-  } catch (error) {
-    console.warn(
-      `[autotel] Failed to configure sampling from YAML: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    return undefined;
-  }
-}
-
-function warnOnIgnoredPresetOverrides(
-  sampling: NonNullable<YamlConfig['sampling']>,
-): void {
-  const ignoredFields = [
-    'type',
-    'ratio',
-    'baseline_rate',
-    'always_sample_errors',
-    'always_sample_slow',
-    'slow_threshold_ms',
-  ].filter((field) => sampling[field as keyof typeof sampling] !== undefined);
-
-  if (ignoredFields.length === 0) {
-    return;
-  }
-
-  console.warn(
-    `[autotel] sampling.preset="${sampling.preset}" ignores these YAML fields: ${ignoredFields.join(', ')}. ` +
-      'Use the programmatic API with sampler or samplingPresets.*(...) for tuned presets.',
-  );
-}
-
-/**
- * Load and parse YAML config file (auto-discovery)
- *
- * Automatically finds and loads autotel.yaml or uses AUTOTEL_CONFIG_FILE.
- * Returns null if no config file found (not an error - YAML config is optional).
- *
- * @returns Partial AutotelConfig or null if no config file found
- *
- * @example
- * const yamlConfig = loadYamlConfig();
- * if (yamlConfig) {
- *   init({ ...yamlConfig, debug: true });
- * }
- */
-export function loadYamlConfig(): Partial<AutotelConfig> | null {
-  const filePath = findConfigFile();
-  if (!filePath) return null;
-
-  try {
-    const content = readFileSync(filePath, 'utf8');
-    const parseYaml = loadYamlParser();
-    const rawYaml = parseYaml(content) as YamlConfig;
-    const substituted = substituteEnvVarsDeep(rawYaml) as YamlConfig;
-    return yamlToAutotelConfig(substituted);
-  } catch (error) {
-    console.error(
-      `[autotel] Failed to load YAML config from ${filePath}:`,
-      error,
-    );
-    return null;
-  }
-}
-
-/**
- * Load YAML config from a specific file path
- *
- * Unlike loadYamlConfig(), this throws if the file cannot be read.
- *
- * @param filePath - Path to YAML config file
- * @returns Partial AutotelConfig
- * @throws Error if file cannot be read or parsed
- *
- * @example
- * import { loadYamlConfigFromFile } from 'autotel/yaml';
- * import { init } from 'autotel';
- *
- * const config = loadYamlConfigFromFile('./config/otel.yaml');
- * init({ ...config, debug: true });
- */
-export function loadYamlConfigFromFile(
-  filePath: string,
-): Partial<AutotelConfig> {
-  const resolved = path.resolve(filePath);
-  const content = readFileSync(resolved, 'utf8');
-  const parseYaml = loadYamlParser();
-  const rawYaml = parseYaml(content) as YamlConfig;
-  const substituted = substituteEnvVarsDeep(rawYaml) as YamlConfig;
-  return yamlToAutotelConfig(substituted);
-}
-
-/**
- * Check if a YAML config file exists (without loading it)
- *
- * @returns true if a config file would be found by loadYamlConfig()
- */
-export function hasYamlConfig(): boolean {
-  return findConfigFile() !== null;
-}