Span Processors

/**
 * Interface for span processing implementations
 */
interface SpanProcessor {
  /**
   * Forces the processor to flush any pending spans
   * @returns Promise that resolves when flush is complete
   */
  forceFlush(): Promise<void>;
  
  /**
   * Called when a span is started
   * @param span - The span that was started
   * @param parentContext - The parent context
   */
  onStart(span: Span, parentContext: Context): void;
  
  /**
   * Called when a span ends
   * @param span - The span that ended (as ReadableSpan)
   */
  onEnd(span: ReadableSpan): void;
  
  /**
   * Shutdown the processor
   * @returns Promise that resolves when shutdown is complete
   */
  shutdown(): Promise<void>;
}

/**
 * Span processor that immediately exports spans (not recommended for production)
 */
class SimpleSpanProcessor implements SpanProcessor {
  /**
   * @param exporter - The span exporter to send spans to
   */
  constructor(exporter: SpanExporter);
  
  /**
   * Forces flush of the underlying exporter
   * @returns Promise that resolves when exporter flush completes
   */
  forceFlush(): Promise<void>;
  
  /**
   * No-op: does nothing when span starts
   */
  onStart(span: Span, parentContext: Context): void;
  
  /**
   * Immediately exports the span if it was sampled
   * @param span - The span to potentially export
   */
  onEnd(span: ReadableSpan): void;
  
  /**
   * Shuts down the underlying exporter
   * @returns Promise that resolves when exporter shutdown completes
   */
  shutdown(): Promise<void>;
}

import { BasicTracerProvider, SimpleSpanProcessor, ConsoleSpanExporter } from '@opentelemetry/sdk-trace-base';

// Basic setup with immediate export (development only)
const provider = new BasicTracerProvider({
  spanProcessors: [
    new SimpleSpanProcessor(new ConsoleSpanExporter())
  ]
});

// Multiple processors for different exporters
const provider = new BasicTracerProvider({
  spanProcessors: [
    new SimpleSpanProcessor(new ConsoleSpanExporter()),
    new SimpleSpanProcessor(new InMemorySpanExporter())
  ]
});

/**
 * Batch span processor with configurable batching behavior
 */
class BatchSpanProcessor implements SpanProcessor {
  /**
   * @param exporter - The span exporter to send batched spans to
   * @param config - Configuration for batching behavior
   */
  constructor(exporter: SpanExporter, config?: BufferConfig);
  
  /**
   * Forces flush of all pending spans within the configured timeout
   * @returns Promise that resolves when flush completes
   */
  forceFlush(): Promise<void>;
  
  /**
   * No-op: does nothing when span starts
   */
  onStart(span: Span, parentContext: Context): void;
  
  /**
   * Adds span to buffer for batched export if sampled
   * @param span - The span to add to the batch
   */
  onEnd(span: ReadableSpan): void;
  
  /**
   * Shuts down the processor and flushes remaining spans
   * @returns Promise that resolves when shutdown completes
   */
  shutdown(): Promise<void>;
}

/**
 * Configuration interface for batch processors
 */
interface BufferConfig {
  /** Maximum batch size for exports (default: 512, env: OTEL_BSP_MAX_EXPORT_BATCH_SIZE) */
  maxExportBatchSize?: number;
  
  /** Delay between exports in milliseconds (default: 5000, env: OTEL_BSP_SCHEDULE_DELAY) */
  scheduledDelayMillis?: number;
  
  /** Export timeout in milliseconds (default: 30000, env: OTEL_BSP_EXPORT_TIMEOUT) */
  exportTimeoutMillis?: number;
  
  /** Maximum queue size before dropping spans (default: 2048, env: OTEL_BSP_MAX_QUEUE_SIZE) */
  maxQueueSize?: number;
}

import { BasicTracerProvider, BatchSpanProcessor, ConsoleSpanExporter } from '@opentelemetry/sdk-trace-base';

// Basic batching with default configuration
const provider = new BasicTracerProvider({
  spanProcessors: [
    new BatchSpanProcessor(new ConsoleSpanExporter())
  ]
});

// Custom batch configuration
const provider = new BasicTracerProvider({
  spanProcessors: [
    new BatchSpanProcessor(new ConsoleSpanExporter(), {
      maxExportBatchSize: 100,     // Smaller batches
      scheduledDelayMillis: 2000,  // More frequent exports
      exportTimeoutMillis: 10000,  // Shorter timeout
      maxQueueSize: 1000           // Smaller queue
    })
  ]
});

// High-throughput configuration
const provider = new BasicTracerProvider({
  spanProcessors: [
    new BatchSpanProcessor(new ConsoleSpanExporter(), {
      maxExportBatchSize: 1000,    // Larger batches
      scheduledDelayMillis: 10000, // Less frequent exports
      maxQueueSize: 4096           // Larger queue
    })
  ]
});

/**
 * No-operation span processor for testing or disabled scenarios
 */
class NoopSpanProcessor implements SpanProcessor {
  /**
   * No-op: does nothing when span starts
   */
  onStart(span: Span, context: Context): void;
  
  /**
   * No-op: does nothing when span ends
   */
  onEnd(span: ReadableSpan): void;
  
  /**
   * No-op: immediately resolves
   * @returns Promise that resolves immediately
   */
  shutdown(): Promise<void>;
  
  /**
   * No-op: immediately resolves
   * @returns Promise that resolves immediately
   */
  forceFlush(): Promise<void>;
}

import { BasicTracerProvider, NoopSpanProcessor } from '@opentelemetry/sdk-trace-base';

// Disable span processing for testing
const provider = new BasicTracerProvider({
  spanProcessors: [new NoopSpanProcessor()]
});

// Conditional processing based on environment
const processors = process.env.NODE_ENV === 'test' 
  ? [new NoopSpanProcessor()]
  : [new BatchSpanProcessor(new ConsoleSpanExporter())];

const provider = new BasicTracerProvider({
  spanProcessors: processors
});

/**
 * Internal processor that forwards events to multiple processors
 */
class MultiSpanProcessor implements SpanProcessor {
  constructor(spanProcessors: SpanProcessor[]);
  
  /**
   * Calls forceFlush on all processors and waits for all to complete
   */
  forceFlush(): Promise<void>;
  
  /**
   * Calls onStart on all processors
   */
  onStart(span: Span, context: Context): void;
  
  /**
   * Calls onEnd on all processors
   */
  onEnd(span: ReadableSpan): void;
  
  /**
   * Calls shutdown on all processors and waits for all to complete
   */
  shutdown(): Promise<void>;
}

import { 
  BasicTracerProvider, 
  BatchSpanProcessor, 
  SimpleSpanProcessor,
  ConsoleSpanExporter,
  InMemorySpanExporter 
} from '@opentelemetry/sdk-trace-base';

// Multiple processors for different purposes  
const provider = new BasicTracerProvider({
  spanProcessors: [
    // Batch export for production telemetry (example uses external package)
    // new BatchSpanProcessor(new JaegerExporter({
    //   endpoint: 'http://jaeger:14268/api/traces'
    // })),
    
    // Immediate console output for debugging (dev only)
    ...(process.env.NODE_ENV === 'development' ? [
      new SimpleSpanProcessor(new ConsoleSpanExporter())
    ] : []),
    
    // In-memory storage for testing/metrics
    new BatchSpanProcessor(new InMemorySpanExporter())
  ]
});

// Processor with different configurations per environment
function createProvider(environment: string) {
  const baseConfig = {
    resource: new Resource({
      'service.name': 'my-service',
      'deployment.environment': environment
    })
  };

  switch (environment) {
    case 'production':
      return new BasicTracerProvider({
        ...baseConfig,
        spanProcessors: [
          // Example with external exporter (requires separate package)
          // new BatchSpanProcessor(new JaegerExporter(), {
          //   maxExportBatchSize: 512,
          //   scheduledDelayMillis: 5000
          // })
          new BatchSpanProcessor(new ConsoleSpanExporter(), {
            maxExportBatchSize: 512,
            scheduledDelayMillis: 5000
          })
        ]
      });
      
    case 'staging':
      return new BasicTracerProvider({
        ...baseConfig,
        spanProcessors: [
          new BatchSpanProcessor(new ConsoleSpanExporter(), {
            maxExportBatchSize: 100,
            scheduledDelayMillis: 2000
          }),
          new SimpleSpanProcessor(new ConsoleSpanExporter())
        ]
      });
      
    case 'development':
      return new BasicTracerProvider({
        ...baseConfig,
        spanProcessors: [
          new SimpleSpanProcessor(new ConsoleSpanExporter()),
          new BatchSpanProcessor(new InMemorySpanExporter())
        ]
      });
      
    case 'test':
      return new BasicTracerProvider({
        ...baseConfig,
        spanProcessors: [new NoopSpanProcessor()]
      });
      
    default:
      throw new Error(`Unknown environment: ${environment}`);
  }
}

// Graceful shutdown with processor management
class TracingService {
  private provider: BasicTracerProvider;
  
  constructor(environment: string) {
    this.provider = createProvider(environment);
  }
  
  async shutdown() {
    try {
      // Force flush all pending spans
      await this.provider.forceFlush();
      
      // Shutdown all processors
      await this.provider.shutdown();
      
      console.log('Tracing service shut down gracefully');
    } catch (error) {
      console.error('Error during tracing shutdown:', error);
    }
  }
}