autotel 4.1.0 → 4.2.1

package/src/rate-limiter.test.ts

@@ -1,199 +0,0 @@
-/**
- * Tests for token bucket rate limiter
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { TokenBucketRateLimiter } from './rate-limiter';
-
-describe('TokenBucketRateLimiter', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  describe('tryConsume()', () => {
-    it('should allow events within rate limit', () => {
-      const limiter = new TokenBucketRateLimiter({
-        maxEventsPerSecond: 10,
-        burstCapacity: 20,
-      });
-
-      // Should allow first 20 events (burst capacity)
-      for (let i = 0; i < 20; i++) {
-        expect(limiter.tryConsume()).toBe(true);
-      }
-
-      // 21st event should be rejected
-      expect(limiter.tryConsume()).toBe(false);
-    });
-
-    it('should refill tokens over time', () => {
-      const limiter = new TokenBucketRateLimiter({
-        maxEventsPerSecond: 10, // 10 events/sec = 1 event/100ms
-        burstCapacity: 10,
-      });
-
-      // Consume all tokens
-      for (let i = 0; i < 10; i++) {
-        expect(limiter.tryConsume()).toBe(true);
-      }
-
-      // Should be rate limited
-      expect(limiter.tryConsume()).toBe(false);
-
-      // Advance time by 100ms (1 token should be added)
-      vi.advanceTimersByTime(100);
-
-      // Should allow 1 more event
-      expect(limiter.tryConsume()).toBe(true);
-      expect(limiter.tryConsume()).toBe(false);
-
-      // Advance time by 500ms (5 tokens should be added)
-      vi.advanceTimersByTime(500);
-
-      // Should allow 5 more events
-      for (let i = 0; i < 5; i++) {
-        expect(limiter.tryConsume()).toBe(true);
-      }
-      expect(limiter.tryConsume()).toBe(false);
-    });
-
-    it('should not exceed max tokens', () => {
-      const limiter = new TokenBucketRateLimiter({
-        maxEventsPerSecond: 10,
-        burstCapacity: 20,
-      });
-
-      // Wait a long time
-      vi.advanceTimersByTime(10_000);
-
-      // Should only have 20 tokens (burstCapacity), not more
-      expect(limiter.getAvailableTokens()).toBe(20);
-    });
-
-    it('should consume multiple tokens at once', () => {
-      const limiter = new TokenBucketRateLimiter({
-        maxEventsPerSecond: 100,
-        burstCapacity: 200,
-      });
-
-      // Consume 50 tokens at once
-      expect(limiter.tryConsume(50)).toBe(true);
-      expect(limiter.getAvailableTokens()).toBe(150);
-
-      // Consume another 150 tokens
-      expect(limiter.tryConsume(150)).toBe(true);
-      expect(limiter.getAvailableTokens()).toBe(0);
-
-      // Should reject request for 1 token
-      expect(limiter.tryConsume(1)).toBe(false);
-    });
-  });
-
-  describe('waitForToken()', () => {
-    it('should wait until token is available', async () => {
-      const limiter = new TokenBucketRateLimiter({
-        maxEventsPerSecond: 10, // 1 token every 100ms
-        burstCapacity: 1,
-      });
-
-      // Consume the only token
-      expect(limiter.tryConsume()).toBe(true);
-      expect(limiter.tryConsume()).toBe(false);
-
-      // Wait for next token
-      const promise = limiter.waitForToken();
-
-      // Advance time by 100ms
-      vi.advanceTimersByTime(100);
-
-      // Should resolve after 100ms
-      await promise;
-
-      // Token should be consumed
-      expect(limiter.tryConsume()).toBe(false);
-    });
-
-    it('should calculate correct wait time for multiple tokens', async () => {
-      const limiter = new TokenBucketRateLimiter({
-        maxEventsPerSecond: 10, // 1 token every 100ms
-        burstCapacity: 10,
-      });
-
-      // Consume all tokens
-      expect(limiter.tryConsume(10)).toBe(true);
-
-      // Request 5 tokens (should wait 500ms)
-      const promise = limiter.waitForToken(5);
-
-      // Advance by 400ms (not enough)
-      vi.advanceTimersByTime(400);
-
-      // Promise should not resolve yet
-      let resolved = false;
-      promise.then(() => {
-        resolved = true;
-      });
-
-      await vi.runAllTimersAsync();
-
-      // Should be resolved now
-      expect(resolved).toBe(true);
-    });
-  });
-
-  describe('getAvailableTokens()', () => {
-    it('should return current token count', () => {
-      const limiter = new TokenBucketRateLimiter({
-        maxEventsPerSecond: 100,
-        burstCapacity: 200,
-      });
-
-      expect(limiter.getAvailableTokens()).toBe(200);
-
-      limiter.tryConsume(50);
-      expect(limiter.getAvailableTokens()).toBe(150);
-
-      // Advance time by 100ms (10 tokens added)
-      vi.advanceTimersByTime(100);
-      expect(limiter.getAvailableTokens()).toBe(160);
-    });
-  });
-
-  describe('reset()', () => {
-    it('should reset to full capacity', () => {
-      const limiter = new TokenBucketRateLimiter({
-        maxEventsPerSecond: 10,
-        burstCapacity: 20,
-      });
-
-      // Consume all tokens
-      limiter.tryConsume(20);
-      expect(limiter.getAvailableTokens()).toBe(0);
-
-      // Reset
-      limiter.reset();
-      expect(limiter.getAvailableTokens()).toBe(20);
-    });
-  });
-
-  describe('Burst capacity', () => {
-    it('should default to 2x rate if not specified', () => {
-      const limiter = new TokenBucketRateLimiter({
-        maxEventsPerSecond: 50,
-        // burstCapacity not specified
-      });
-
-      // Should have 100 tokens (2x rate)
-      expect(limiter.getAvailableTokens()).toBe(100);
-    });
-
-    it('should allow custom burst capacity', () => {
-      const limiter = new TokenBucketRateLimiter({
-        maxEventsPerSecond: 50,
-        burstCapacity: 500, // 10x rate
-      });
-
-      expect(limiter.getAvailableTokens()).toBe(500);
-    });
-  });
-});

package/src/rate-limiter.ts

@@ -1,98 +0,0 @@
-/**
- * Token bucket rate limiter for event subscribers
- *
- * Prevents overwhelming downstream events platforms with too many events.
- * Uses token bucket algorithm for smooth rate limiting with burst capacity.
- */
-
-export interface RateLimiterConfig {
-  /** Maximum events per second (default: 100) */
-  maxEventsPerSecond: number;
-  /** Burst capacity - max events in a single burst (default: 2x rate) */
-  burstCapacity?: number;
-}
-
-/**
- * Token bucket rate limiter
- *
- * Allows bursts up to burstCapacity, then smooths to maxEventsPerSecond.
- * Thread-safe for async operations.
- */
-export class TokenBucketRateLimiter {
-  private tokens: number;
-  private readonly maxTokens: number;
-  private readonly refillRate: number; // tokens per millisecond
-  private lastRefill: number;
-
-  constructor(config: RateLimiterConfig) {
-    this.maxTokens = config.burstCapacity || config.maxEventsPerSecond * 2;
-    this.tokens = this.maxTokens; // Start with full bucket
-    this.refillRate = config.maxEventsPerSecond / 1000; // Convert to per-ms
-    this.lastRefill = Date.now();
-  }
-
-  /**
-   * Try to consume a token (allow an event)
-   * Returns true if allowed, false if rate limit exceeded
-   */
-  tryConsume(count = 1): boolean {
-    this.refill();
-
-    if (this.tokens >= count) {
-      this.tokens -= count;
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Wait until a token is available (async rate limiting)
-   * Returns a promise that resolves when the event can be processed
-   */
-  async waitForToken(count = 1): Promise<void> {
-    this.refill();
-
-    if (this.tokens >= count) {
-      this.tokens -= count;
-      return;
-    }
-
-    // Calculate wait time until we have enough tokens
-    const tokensNeeded = count - this.tokens;
-    const waitMs = Math.ceil(tokensNeeded / this.refillRate);
-
-    await new Promise((resolve) => setTimeout(resolve, waitMs));
-
-    // After waiting, try again (recursive)
-    return this.waitForToken(count);
-  }
-
-  /**
-   * Refill tokens based on elapsed time
-   */
-  private refill(): void {
-    const now = Date.now();
-    const elapsed = now - this.lastRefill;
-    const tokensToAdd = elapsed * this.refillRate;
-
-    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
-    this.lastRefill = now;
-  }
-
-  /**
-   * Get current available tokens (for testing/debugging)
-   */
-  getAvailableTokens(): number {
-    this.refill();
-    return Math.floor(this.tokens);
-  }
-
-  /**
-   * Reset the rate limiter (for testing)
-   */
-  reset(): void {
-    this.tokens = this.maxTokens;
-    this.lastRefill = Date.now();
-  }
-}

package/src/redact-values.test.ts

@@ -1,90 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { createStringRedactor } from './redact-values';
-import type { StringRedactor } from './redact-values';
-
-describe('createStringRedactor', () => {
-  describe('default preset', () => {
-    let redact: StringRedactor;
-
-    beforeEach(() => {
-      redact = createStringRedactor('default');
-    });
-
-    it('smart-masks emails', () => {
-      expect(redact('Contact user@example.com for info')).toBe(
-        'Contact u***@***.com for info',
-      );
-    });
-
-    it('smart-masks international phone numbers (country code + last 2 digits)', () => {
-      expect(redact('Call +33 1 23 45 67 89 now')).toBe('Call +33******89 now');
-    });
-
-    it('smart-masks phone numbers with parens (last 2 digits)', () => {
-      expect(redact('Call (415) 555-1234 now')).toBe('Call ********34 now');
-    });
-
-    it('smart-masks common US phone formats', () => {
-      expect(redact('Call 555-123-4567 now')).toBe('Call ********67 now');
-      expect(redact('Call 5551234567 now')).toBe('Call ********67 now');
-    });
-
-    it('does not mistake bare digit runs for phone numbers', () => {
-      // UUIDs, order ids etc. should pass through untouched.
-      expect(redact('Order: 12345678 ok')).toBe('Order: 12345678 ok');
-    });
-
-    it('smart-masks credit card numbers (last four digits preserved)', () => {
-      expect(redact('Card: 4111-1111-1111-1111')).toBe('Card: ****1111');
-    });
-
-    it('returns input unchanged when no patterns match', () => {
-      expect(redact('hello world')).toBe('hello world');
-    });
-  });
-
-  describe('strict preset', () => {
-    let redact: StringRedactor;
-
-    beforeEach(() => {
-      redact = createStringRedactor('strict');
-    });
-
-    it('smart-masks JWTs', () => {
-      const jwt =
-        'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.abc123_-def';
-      expect(redact(`Token: ${jwt}`)).toBe('Token: eyJ***.***');
-    });
-
-    it('smart-masks bearer tokens', () => {
-      expect(redact('Authorization: Bearer abc123.xyz')).toBe(
-        'Authorization: Bearer ***',
-      );
-    });
-  });
-
-  describe('custom config', () => {
-    it('accepts custom config with custom patterns', () => {
-      const redact = createStringRedactor({
-        valuePatterns: [{ name: 'customId', pattern: /CUST-\d{8}/g }],
-        replacement: '***',
-      });
-      expect(redact('Customer CUST-12345678 logged in')).toBe(
-        'Customer *** logged in',
-      );
-    });
-
-    it('uses custom replacement string', () => {
-      const redact = createStringRedactor({
-        valuePatterns: [
-          {
-            name: 'email',
-            pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/gi,
-          },
-        ],
-        replacement: '<HIDDEN>',
-      });
-      expect(redact('Email: test@example.com')).toBe('Email: <HIDDEN>');
-    });
-  });
-});

package/src/redact-values.ts

@@ -1,34 +0,0 @@
-/** Standalone string redaction for use outside the span processor pipeline. */
-
-import {
-  REDACTOR_PRESETS,
-  type AttributeRedactorConfig,
-  type AttributeRedactorPreset,
-  type ValuePatternConfig,
-} from './attribute-redacting-processor';
-
-export type StringRedactor = (value: string) => string;
-export function createStringRedactor(
-  config: AttributeRedactorConfig | AttributeRedactorPreset,
-): StringRedactor {
-  const resolved =
-    typeof config === 'string' ? REDACTOR_PRESETS[config] : config;
-  const valuePatterns: ValuePatternConfig[] = resolved.valuePatterns ?? [];
-  const defaultReplacement = resolved.replacement ?? '[REDACTED]';
-
-  return (value: string): string => {
-    let result = value;
-    for (const { pattern, replacement, mask } of valuePatterns) {
-      pattern.lastIndex = 0;
-      // Smart masks (e.g. email → a***@***.com) take precedence over the
-      // static replacement so callers see the same output as the
-      // span-attribute redactor does.
-      if (mask) {
-        result = result.replaceAll(pattern, (match) => mask(match));
-      } else {
-        result = result.replaceAll(pattern, replacement ?? defaultReplacement);
-      }
-    }
-    return result;
-  };
-}

package/src/register.ts

@@ -1,37 +0,0 @@
-/**
- * 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
- */
-
-import { register } from 'node:module';
-
-// Use the official OpenTelemetry instrumentation hook which wraps import-in-the-middle
-// This ensures proper integration with OTel's instrumentation system
-register('@opentelemetry/instrumentation/hook.mjs', import.meta.url);