Function init_telemetry

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

Initialize telemetry for a Lambda function.

This function sets up OpenTelemetry for use in a Lambda function:

1. Creates a tracer provider with the given configuration
2. Sets it as the global tracer provider
3. Registers the internal extension if running in async/finalize mode
4. Configures the tracing subscriber with appropriate formatting

The function automatically handles:

• Propagation context setup
• Resource attribute management
• Extension registration based on mode
• Logging format configuration

Examples

Using with Tower middleware:

use lambda_otel_lite::{init_telemetry, TelemetryConfig, OtelTracingLayer};
use lambda_runtime::{service_fn, Error, LambdaEvent, Runtime};
use tower::ServiceBuilder;
use aws_lambda_events::apigw::ApiGatewayV2httpRequest;
use serde_json::json;

async fn function_handler(event: LambdaEvent<ApiGatewayV2httpRequest>) -> Result<serde_json::Value, Error> {
    Ok(json!({ "statusCode": 200 }))
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Initialize telemetry with default configuration
    let completion_handler = init_telemetry(TelemetryConfig::default()).await?;
     
    // Build service with OpenTelemetry tracing middleware
    let service = ServiceBuilder::new()
        .layer(OtelTracingLayer::new(completion_handler)
            .with_name("my-handler"))
        .service_fn(function_handler);
     
    Runtime::new(service).run().await
}

Using with traced handler:

use lambda_otel_lite::{init_telemetry, traced_handler, TelemetryConfig, TracedHandlerOptions};
use lambda_runtime::{service_fn, Error, LambdaEvent, Runtime};
use aws_lambda_events::apigw::ApiGatewayV2httpRequest;
use serde_json::json;

async fn function_handler(event: LambdaEvent<ApiGatewayV2httpRequest>) -> Result<serde_json::Value, Error> {
    Ok(json!({ "statusCode": 200 }))
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Initialize telemetry with default configuration
    let completion_handler = init_telemetry(TelemetryConfig::default()).await?;

    // Create the Lambda service with tracing
    let func = service_fn(move |event| {
        traced_handler(
            TracedHandlerOptions::default()
                .with_name("my-handler")
                .with_event(event),
            completion_handler.clone(),
            function_handler,
        )
    });

    Runtime::new(func).run().await
}

Environment Variables

• RUST_LOG or AWS_LAMBDA_LOG_LEVEL: Controls log filtering
• AWS_LAMBDA_LOG_FORMAT: Set to “JSON” for JSON formatted logs

Arguments

• config - Configuration for telemetry initialization

Returns

Returns a TelemetryCompletionHandler for managing telemetry completion

Errors

Returns an error if:

• Failed to build tracer provider
• Failed to register extension
• Failed to set up tracing subscriber