Enum ProcessorMode

pub enum ProcessorMode {
    Sync,
    Async,
    Finalize,
}

Controls how spans are processed and exported.

This enum determines when and how OpenTelemetry spans are flushed from the buffer to the configured exporter. Each mode offers different tradeoffs between latency, reliability, and flexibility.

Modes

• Sync: Immediate flush in handler thread

  • Spans are flushed before handler returns
  • Direct export without extension coordination
  • May be more efficient for small payloads and low memory configurations
  • Guarantees span delivery before response

• Async: Flush via Lambda extension

  • Spans are flushed after handler returns
  • Requires coordination with extension process
  • Additional overhead from IPC with extension
  • Provides retry capabilities through extension

• Finalize: Delegated to processor

  • Spans handled by configured processor
  • Compatible with BatchSpanProcessor
  • Best for custom export strategies
  • Full control over export timing

Configuration

The mode can be configured in two ways:

1. Using the LAMBDA_EXTENSION_SPAN_PROCESSOR_MODE environment variable:

   • “sync” for Sync mode (default)
   • “async” for Async mode
   • “finalize” for Finalize mode

2. Programmatically through TelemetryConfig:

   use lambda_otel_lite::{ProcessorMode, TelemetryConfig};
    
   let config = TelemetryConfig::builder()
       .processor_mode(ProcessorMode::Async)
       .build();

The environment variable takes precedence over programmatic configuration.

Example

use lambda_otel_lite::ProcessorMode;
use std::env;

// Set mode via environment variable
env::set_var("LAMBDA_EXTENSION_SPAN_PROCESSOR_MODE", "async");

// Get mode from environment
let mode = ProcessorMode::resolve(None);
assert!(matches!(mode, ProcessorMode::Async));

// Programmatically provide a default but let environment override it
let mode = ProcessorMode::resolve(Some(ProcessorMode::Sync));
assert!(matches!(mode, ProcessorMode::Async)); // Environment still takes precedence

Variants

Sync

Synchronous flush in handler thread. Best for development and debugging.

Async

Asynchronous flush via extension. Best for production use to minimize latency.

Finalize

Let processor handle flushing. Best with BatchSpanProcessor for custom export strategies.

Implementations

impl ProcessorMode

pub fn resolve(config_mode: Option<ProcessorMode>) -> Self

Resolve processor mode from environment variable or provided configuration.

If LAMBDA_EXTENSION_SPAN_PROCESSOR_MODE environment variable is set, it takes precedence. Otherwise, uses the provided mode or defaults to Sync mode if neither is set.

Trait Implementations

impl Clone for ProcessorMode

fn clone(&self) -> ProcessorMode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProcessorMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for ProcessorMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for ProcessorMode

fn eq(&self, other: &ProcessorMode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ProcessorMode