autotel 4.1.0 → 4.2.1

package/src/filtering-span-processor.ts

@@ -1,111 +0,0 @@
-/**
- * Filtering Span Processor
- *
- * Filters spans based on a user-provided predicate function.
- * Runs filtering on onEnd() to have access to complete span data.
- *
- * @example Filter out Next.js instrumentation spans
- * ```typescript
- * init({
- *   service: 'my-app',
- *   spanFilter: (span) => span.instrumentationScope.name !== 'next.js'
- * })
- * ```
- *
- * @example Filter out health check endpoints
- * ```typescript
- * init({
- *   service: 'my-app',
- *   spanFilter: (span) => !span.name.includes('/health')
- * })
- * ```
- */
-
-import type {
-  SpanProcessor,
-  ReadableSpan,
-} from '@opentelemetry/sdk-trace-base';
-import type { Context } from '@opentelemetry/api';
-import type { Span } from '@opentelemetry/sdk-trace-base';
-
-/**
- * Predicate function for filtering spans
- *
- * @param span - The completed span (ReadableSpan) with all attributes and metadata
- * @returns true to keep the span, false to drop it
- *
- * Available span properties for filtering:
- * - `span.name` - Span name
- * - `span.attributes` - All span attributes
- * - `span.instrumentationScope` - `{ name, version }` of the instrumentation
- * - `span.status` - Span status code and message
- * - `span.duration` - Span duration as `[seconds, nanoseconds]`
- * - `span.kind` - SpanKind (INTERNAL, SERVER, CLIENT, etc.)
- */
-export type SpanFilterPredicate = (span: ReadableSpan) => boolean;
-
-export interface FilteringSpanProcessorOptions {
-  /**
-   * Predicate function to determine if a span should be kept
-   * Return true to keep the span, false to drop it
-   */
-  filter: SpanFilterPredicate;
-}
-
-/**
- * Span processor that filters spans based on a predicate function.
- *
- * The filter is applied on onEnd() when the span has complete data including:
- * - All attributes
- * - Status code and message
- * - Duration
- * - Events and links
- * - Instrumentation scope (useful for filtering by library)
- *
- * onStart() passes through unchanged to ensure child spans can still be created.
- *
- * Error handling: If the filter predicate throws, the span is forwarded (fail-open).
- */
-export class FilteringSpanProcessor implements SpanProcessor {
-  private readonly wrappedProcessor: SpanProcessor;
-  private readonly filter: SpanFilterPredicate;
-
-  constructor(
-    wrappedProcessor: SpanProcessor,
-    options: FilteringSpanProcessorOptions,
-  ) {
-    this.wrappedProcessor = wrappedProcessor;
-    this.filter = options.filter;
-  }
-
-  /**
-   * Pass through onStart - we need spans to start so child spans work
-   */
-  onStart(span: Span, parentContext: Context): void {
-    this.wrappedProcessor.onStart(span, parentContext);
-  }
-
-  /**
-   * Apply filter predicate on span end
-   * If filter returns false, span is dropped (not forwarded)
-   */
-  onEnd(span: ReadableSpan): void {
-    try {
-      if (this.filter(span)) {
-        this.wrappedProcessor.onEnd(span);
-      }
-      // If filter returns false, span is silently dropped
-    } catch {
-      // If filter throws, forward the span (fail-open behavior)
-      this.wrappedProcessor.onEnd(span);
-    }
-  }
-
-  forceFlush(): Promise<void> {
-    return this.wrappedProcessor.forceFlush();
-  }
-
-  shutdown(): Promise<void> {
-    return this.wrappedProcessor.shutdown();
-  }
-}

package/src/flatten-attributes.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { toAttributeValue, flattenToAttributes } from './flatten-attributes';
-
-describe('toAttributeValue', () => {
-  it('returns primitives as-is', () => {
-    expect(toAttributeValue('hello')).toBe('hello');
-    expect(toAttributeValue(42)).toBe(42);
-    expect(toAttributeValue(true)).toBe(true);
-  });
-
-  it('returns homogeneous arrays as-is', () => {
-    expect(toAttributeValue(['a', 'b'])).toEqual(['a', 'b']);
-    expect(toAttributeValue([1, 2])).toEqual([1, 2]);
-    expect(toAttributeValue([true, false])).toEqual([true, false]);
-  });
-
-  it('serialises mixed arrays to JSON', () => {
-    expect(toAttributeValue([1, 'a'])).toBe('[1,"a"]');
-  });
-
-  it('converts Date to ISO string', () => {
-    const d = new Date('2025-01-01T00:00:00Z');
-    expect(toAttributeValue(d)).toBe('2025-01-01T00:00:00.000Z');
-  });
-
-  it('converts Error to its message', () => {
-    expect(toAttributeValue(new Error('boom'))).toBe('boom');
-  });
-
-  it('returns undefined for plain objects', () => {
-    expect(toAttributeValue({ a: 1 })).toBeUndefined();
-  });
-});
-
-describe('flattenToAttributes', () => {
-  it('flattens nested objects with dot-notation keys', () => {
-    expect(
-      flattenToAttributes({ user: { id: 'u1', plan: 'pro' }, count: 3 }),
-    ).toEqual({
-      'user.id': 'u1',
-      'user.plan': 'pro',
-      count: 3,
-    });
-  });
-
-  it('uses prefix when provided', () => {
-    expect(flattenToAttributes({ key: 'val' }, 'error.details')).toEqual({
-      'error.details.key': 'val',
-    });
-  });
-
-  it('skips null and undefined values', () => {
-    expect(
-      flattenToAttributes({ a: 1, b: null, c: undefined, d: 'ok' }),
-    ).toEqual({ a: 1, d: 'ok' });
-  });
-
-  it('handles circular references without stack overflow', () => {
-    const obj: Record<string, unknown> = { name: 'root' };
-    obj.self = obj;
-
-    const result = flattenToAttributes(obj);
-    expect(result).toEqual({
-      name: 'root',
-      'self.name': 'root',
-      'self.self': '<circular-reference>',
-    });
-  });
-
-  it('serialises non-plain objects to JSON', () => {
-    const result = flattenToAttributes({
-      date: new Date('2025-01-01T00:00:00Z'),
-    });
-    expect(result).toEqual({ date: '2025-01-01T00:00:00.000Z' });
-  });
-});

package/src/flatten-attributes.ts

@@ -1,80 +0,0 @@
-import type { AttributeValue } from './trace-context';
-
-/**
- * Convert an unknown value to an OTel-compatible AttributeValue.
- * Returns undefined when the value cannot be represented.
- */
-export function toAttributeValue(value: unknown): AttributeValue | undefined {
-  if (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    typeof value === 'boolean'
-  ) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    if (
-      value.every((v) => typeof v === 'string') ||
-      value.every((v) => typeof v === 'number') ||
-      value.every((v) => typeof v === 'boolean')
-    ) {
-      return value as AttributeValue;
-    }
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return '<serialization-failed>';
-    }
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (value instanceof Error) {
-    return value.message;
-  }
-  return undefined;
-}
-
-/**
- * Recursively flatten a nested object into dot-notation OTel attributes.
- * Includes circular reference protection via WeakSet.
- */
-export function flattenToAttributes(
-  fields: Record<string, unknown>,
-  prefix = '',
-): Record<string, AttributeValue> {
-  const out: Record<string, AttributeValue> = {};
-  const seen = new WeakSet<object>();
-
-  function flatten(obj: Record<string, unknown>, currentPrefix: string): void {
-    for (const [key, value] of Object.entries(obj)) {
-      if (value == null) continue;
-      const nextKey = currentPrefix ? `${currentPrefix}.${key}` : key;
-
-      const attr = toAttributeValue(value);
-      if (attr !== undefined) {
-        out[nextKey] = attr;
-        continue;
-      }
-
-      if (typeof value === 'object' && value.constructor === Object) {
-        if (seen.has(value)) {
-          out[nextKey] = '<circular-reference>';
-          continue;
-        }
-        seen.add(value);
-        flatten(value as Record<string, unknown>, nextKey);
-        continue;
-      }
-
-      try {
-        out[nextKey] = JSON.stringify(value);
-      } catch {
-        out[nextKey] = '<serialization-failed>';
-      }
-    }
-  }
-
-  flatten(fields, prefix);
-  return out;
-}

package/src/functional.strict-types.typecheck.ts

@@ -1,53 +0,0 @@
-/**
- * Strict type inference test for the bug:
- * trace() with name parameter returns unknown type
- */
-
-import { trace } from './functional';
-
-// This test file should be checked with: npx tsc --noEmit
-
-// Helper type to detect unknown - this will be 'true' if T is unknown, 'false' otherwise
-type IsUnknown<T> = unknown extends T
-  ? T extends unknown
-    ? true
-    : false
-  : false;
-
-// Test 1: With explicit TraceContext type - this should always work
-const withExplicitType = trace('test-span', () => async () => {
-  return { foo: 'bar' };
-});
-
-// Type assertion - this line should compile without error if type is inferred correctly
-const _test1: () => Promise<{ foo: string }> = withExplicitType;
-
-// Test 2: Without explicit TraceContext type - this is the bug scenario
-const withoutExplicitType = trace('test-span', () => async () => {
-  return { foo: 'bar' };
-});
-
-// Get the inner type of the Promise returned by the function
-type InnerReturnType = Awaited<ReturnType<typeof withoutExplicitType>>;
-
-// This will be 'true' if the bug exists (type is unknown)
-type IsBugPresent = IsUnknown<InnerReturnType>;
-
-// Type assertion - if the bug exists, this will fail because IsBugPresent is 'true'
-// If the bug is fixed, IsBugPresent is 'false' and this compiles
-const _bugCheck: IsBugPresent extends false ? 'fixed' : never = 'fixed';
-
-// Type assertion - if the bug exists, this line will fail compilation
-// because the return type would be () => Promise<unknown>
-const _test2: () => Promise<{ foo: string }> = withoutExplicitType;
-
-// Test 3: Alternative - check if we can access .foo on the result
-async function testAccess() {
-  const result = await withoutExplicitType();
-  // If the type is unknown, TypeScript will error on .foo access
-  // If the type is { foo: string }, this compiles fine
-  return result.foo;
-}
-
-// Prevent unused variable warnings
-export { _test1, _test2, testAccess, _bugCheck };