use std::sync::atomic::{AtomicBool, Ordering};
use base64::Engine as _;
use opentelemetry::Context;
use opentelemetry::trace::{TraceContextExt as _, TracerProvider as _};
use opentelemetry_aws::detector::LambdaResourceDetector;
use opentelemetry_aws::trace::XrayIdGenerator;
use opentelemetry_aws::trace::xray_propagator::span_context_from_str;
use opentelemetry_proto::tonic::collector::trace::v1::ExportTraceServiceRequest;
use opentelemetry_proto::transform::common::tonic::ResourceAttributesWithSchema;
use opentelemetry_proto::transform::trace::tonic::group_spans_by_resource_and_scope;
use opentelemetry_sdk::Resource;
use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult};
use opentelemetry_sdk::trace::{Sampler, SdkTracerProvider, SpanData, SpanExporter};
use prost::Message as _;
use tracing_opentelemetry::OpenTelemetrySpanExt as _;
use crate::RuntimeError;
static COLD_START: AtomicBool = AtomicBool::new(true);
const UDP_HEADER: &[u8] = b"{\"format\":\"json\",\"version\":1}\nT1S";
#[derive(Debug)]
struct UdpOtlpExporter {
socket: std::net::UdpSocket,
resource: ResourceAttributesWithSchema,
}
impl UdpOtlpExporter {
fn new(endpoint: &str) -> std::io::Result<Self> {
let socket = std::net::UdpSocket::bind("0.0.0.0:0")?;
socket.connect(endpoint)?;
Ok(Self {
socket,
resource: (&Resource::builder_empty().build()).into(),
})
}
fn datagram(&self, batch: Vec<SpanData>) -> Vec<u8> {
let request = ExportTraceServiceRequest {
resource_spans: group_spans_by_resource_and_scope(batch, &self.resource),
};
let mut out = UDP_HEADER.to_vec();
out.extend(
base64::engine::general_purpose::STANDARD
.encode(request.encode_to_vec())
.into_bytes(),
);
out
}
}
impl SpanExporter for UdpOtlpExporter {
fn export(
&self,
batch: Vec<SpanData>,
) -> impl std::future::Future<Output = OTelSdkResult> + Send {
let result = self
.socket
.send(&self.datagram(batch))
.map(|_| ())
.map_err(|error| OTelSdkError::InternalFailure(error.to_string()));
std::future::ready(result)
}
fn set_resource(&mut self, resource: &Resource) {
self.resource = resource.into();
}
}
pub fn tracer_provider(
endpoint: &str,
service_fallback: &str,
) -> Result<SdkTracerProvider, RuntimeError> {
let service_name = std::env::var("OTEL_SERVICE_NAME")
.or_else(|_| std::env::var("AWS_LAMBDA_FUNCTION_NAME"))
.unwrap_or_else(|_| service_fallback.to_owned());
let resource = Resource::builder()
.with_detector(Box::new(LambdaResourceDetector))
.with_service_name(service_name)
.build();
let exporter = UdpOtlpExporter::new(endpoint)
.map_err(|error| RuntimeError::other("opening the X-Ray agent socket", error))?;
Ok(SdkTracerProvider::builder()
.with_simple_exporter(exporter)
.with_id_generator(XrayIdGenerator::default())
.with_sampler(Sampler::AlwaysOn)
.with_resource(resource)
.build())
}
#[must_use]
pub fn agent_endpoint() -> String {
std::env::var("AWS_XRAY_DAEMON_ADDRESS").unwrap_or_else(|_| "127.0.0.1:2000".to_owned())
}
pub fn init(service_fallback: &str) -> Result<SdkTracerProvider, RuntimeError> {
use tracing_subscriber::layer::SubscriberExt as _;
use tracing_subscriber::util::SubscriberInitExt as _;
let provider = tracer_provider(&agent_endpoint(), service_fallback)?;
tracing_subscriber::registry()
.with(super::logs::level_from_env())
.with(super::logs::runtime_span_filter())
.with(super::logs::text_layer())
.with(
tracing_opentelemetry::layer()
.with_tracer(provider.tracer("davidrs"))
.with_context_activation(false),
)
.try_init()
.map_err(|error| {
crate::RuntimeError::other("installing the telemetry subscriber", error)
})?;
Ok(provider)
}
pub fn join_trace(span: &tracing::Span, xray_trace_header: Option<&str>) {
if span.is_disabled() {
return;
}
span.record("otel.kind", "SERVER");
span.set_attribute("faas.coldstart", COLD_START.swap(false, Ordering::Relaxed));
if let Some(parent) = xray_trace_header.and_then(span_context_from_str)
&& let Err(error) = span.set_parent(Context::new().with_remote_span_context(parent))
{
tracing::warn!(%error, "could not join the X-Ray trace");
}
}
pub fn record_status(span: &tracing::Span, status: u16) {
span.set_attribute("http.response.status_code", i64::from(status));
}