Function init_telemetry

pub async fn init_telemetry(
    config: TelemetryConfig,
) -> Result<(Tracer, TelemetryCompletionHandler), Error>

Initialize OpenTelemetry for AWS Lambda with the provided configuration.

Arguments

• config - Configuration for telemetry initialization

Returns

Returns a tuple containing:

• A tracer instance for manual instrumentation
• A completion handler for managing span export timing

Errors

Returns error if:

• Extension registration fails (async/finalize modes)
• Tracer provider initialization fails
• Environment variable parsing fails

Examples

Basic usage with default configuration:

use lambda_otel_lite::telemetry::{init_telemetry, TelemetryConfig};

// Initialize with default configuration
let (_, telemetry) = init_telemetry(TelemetryConfig::default()).await?;

Custom configuration:

use lambda_otel_lite::telemetry::{init_telemetry, TelemetryConfig};
use opentelemetry::KeyValue;
use opentelemetry_sdk::Resource;

// Create custom resource
let resource = Resource::builder()
    .with_attributes(vec![
        KeyValue::new("service.name", "payment-api"),
        KeyValue::new("service.version", "1.2.3"),
    ])
    .build();

// Initialize with custom configuration
let (_, telemetry) = init_telemetry(
    TelemetryConfig::builder()
        .resource(resource)
        .build()
).await?;

Advanced usage with BatchSpanProcessor (required for async exporters):

use lambda_otel_lite::{init_telemetry, TelemetryConfig};
use opentelemetry_otlp::{WithExportConfig, WithHttpConfig, Protocol};
use opentelemetry_sdk::trace::BatchSpanProcessor;
use lambda_runtime::Error;

let batch_exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    .with_http_client(reqwest::Client::new())
    .with_protocol(Protocol::HttpBinary)
    .build()?;

let (provider, completion) = init_telemetry(
    TelemetryConfig::builder()
        .with_span_processor(BatchSpanProcessor::builder(batch_exporter).build())
        .build()
).await?;

Using LambdaSpanProcessor with blocking http client:

use lambda_otel_lite::{init_telemetry, TelemetryConfig, LambdaSpanProcessor};
use opentelemetry_otlp::{WithExportConfig, WithHttpConfig, Protocol};
use lambda_runtime::Error;

let lambda_exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    .with_http_client(reqwest::blocking::Client::new())
    .with_protocol(Protocol::HttpBinary)
    .build()?;

let (provider, completion) = init_telemetry(
    TelemetryConfig::builder()
        .with_span_processor(
            LambdaSpanProcessor::builder()
                .exporter(lambda_exporter)
                .max_batch_size(512)
                .max_queue_size(2048)
                .build()
        )
        .build()
).await?;