use std::borrow::Cow;
use std::collections::HashMap;
use std::fmt;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;
use opentelemetry::propagation::TextMapCompositePropagator;
use opentelemetry::trace::TracerProvider as _;
use opentelemetry::{InstrumentationScope, KeyValue, Value};
use opentelemetry_sdk::runtime::Tokio;
use opentelemetry_sdk::trace::span_processor_with_async_runtime::BatchSpanProcessor;
use opentelemetry_sdk::trace::{
BatchConfigBuilder, Sampler, SdkTracer, SdkTracerProvider, SpanExporter, SpanProcessor,
};
use opentelemetry_sdk::Resource;
use super::{build_propagator, AttrValue, BoxedPropagator, SamplerKind, TracingConfig};
use crate::core::{Error, Result};
#[derive(Clone)]
pub struct TracingHandle {
inner: Arc<HandleInner>,
}
struct HandleInner {
provider: Option<SdkTracerProvider>,
propagator: Arc<TextMapCompositePropagator>,
service_name: String,
shutdown: AtomicBool,
}
impl Drop for HandleInner {
fn drop(&mut self) {
if self.shutdown.load(Ordering::SeqCst) {
return;
}
if let Some(provider) = self.provider.take() {
let _ = std::thread::Builder::new()
.name("grow-tracing-shutdown".into())
.spawn(move || {
let _ = provider.shutdown();
});
}
}
}
impl fmt::Debug for TracingHandle {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("TracingHandle")
.field("service_name", &self.inner.service_name)
.field("shutdown", &self.inner.shutdown.load(Ordering::SeqCst))
.finish()
}
}
impl TracingHandle {
pub fn new(
provider: SdkTracerProvider,
propagator: Arc<TextMapCompositePropagator>,
service_name: impl Into<String>,
) -> Self {
TracingHandle {
inner: Arc::new(HandleInner {
provider: Some(provider),
propagator,
service_name: service_name.into(),
shutdown: AtomicBool::new(false),
}),
}
}
fn provider_ref(&self) -> &SdkTracerProvider {
self.inner
.provider
.as_ref()
.expect("provider present until drop")
}
pub fn tracer_provider(&self) -> SdkTracerProvider {
self.provider_ref().clone()
}
pub fn propagator(&self) -> Arc<TextMapCompositePropagator> {
Arc::clone(&self.inner.propagator)
}
pub fn service_name(&self) -> &str {
&self.inner.service_name
}
pub fn tracer(&self, name: impl Into<Cow<'static, str>>, version: Option<&str>) -> SdkTracer {
let mut scope = InstrumentationScope::builder(name.into());
if let Some(v) = version {
scope = scope.with_version(v.to_string());
}
self.provider_ref().tracer_with_scope(scope.build())
}
pub async fn force_flush(&self, timeout: Option<Duration>) -> Result<()> {
let provider = self.tracer_provider();
let task = tokio::task::spawn_blocking(move || provider.force_flush());
let joined = match timeout {
None => task.await,
Some(t) => tokio::time::timeout(t, task).await.map_err(|_| {
Error::timeout(format!("tracing flush did not finish within {t:?}"))
})?,
};
flatten("tracing flush", joined)
}
pub async fn shutdown(&self) -> Result<()> {
if self.inner.shutdown.swap(true, Ordering::SeqCst) {
return Ok(());
}
let provider = self.tracer_provider();
let joined = tokio::task::spawn_blocking(move || provider.shutdown()).await;
flatten("tracing shutdown", joined)
}
pub fn is_shutdown(&self) -> bool {
self.inner.shutdown.load(Ordering::SeqCst)
}
}
fn flatten<E: fmt::Display>(
what: &str,
joined: std::result::Result<std::result::Result<(), E>, tokio::task::JoinError>,
) -> Result<()> {
match joined {
Ok(Ok(())) => Ok(()),
Ok(Err(e)) => Err(Error::unavailable(format!("{what} failed: {e}"))),
Err(e) => Err(Error::unavailable(format!("{what} failed: {e}"))),
}
}
pub fn otel_value(value: &AttrValue) -> Value {
use opentelemetry::{Array, StringValue};
match value {
AttrValue::String(s) => Value::String(s.clone().into()),
AttrValue::Bool(b) => Value::Bool(*b),
AttrValue::Number(n) => match n.as_i64() {
Some(i) => Value::I64(i),
None => Value::F64(n.as_f64().unwrap_or(f64::NAN)),
},
AttrValue::Array(items) => {
let all = |f: fn(&AttrValue) -> bool| !items.is_empty() && items.iter().all(f);
if all(|v| v.is_string()) {
Value::Array(Array::String(
items
.iter()
.filter_map(|v| v.as_str())
.map(|s| StringValue::from(s.to_string()))
.collect(),
))
} else if all(|v| v.is_i64()) {
Value::Array(Array::I64(
items.iter().filter_map(|v| v.as_i64()).collect(),
))
} else if all(|v| v.is_number()) {
Value::Array(Array::F64(
items.iter().filter_map(|v| v.as_f64()).collect(),
))
} else if all(|v| v.is_boolean()) {
Value::Array(Array::Bool(
items.iter().filter_map(|v| v.as_bool()).collect(),
))
} else {
Value::String(value.to_string().into())
}
}
other => Value::String(other.to_string().into()),
}
}
pub fn otel_attributes<'a>(
attrs: impl IntoIterator<Item = (&'a String, &'a AttrValue)>,
) -> Vec<KeyValue> {
attrs
.into_iter()
.map(|(k, v)| KeyValue::new(k.clone(), otel_value(v)))
.collect()
}
pub fn build_sampler(kind: SamplerKind, ratio: f64) -> Sampler {
match kind {
SamplerKind::AlwaysOn => Sampler::AlwaysOn,
SamplerKind::AlwaysOff => Sampler::AlwaysOff,
SamplerKind::TraceIdRatio => Sampler::TraceIdRatioBased(ratio),
SamplerKind::ParentBasedAlwaysOn => Sampler::ParentBased(Box::new(Sampler::AlwaysOn)),
SamplerKind::ParentBasedAlwaysOff => Sampler::ParentBased(Box::new(Sampler::AlwaysOff)),
SamplerKind::ParentBasedTraceIdRatio => {
Sampler::ParentBased(Box::new(Sampler::TraceIdRatioBased(ratio)))
}
}
}
pub fn build_resource(config: &TracingConfig) -> Resource {
let mut attrs = otel_attributes(&config.resource_attributes);
if let Some(v) = &config.service_version {
attrs.push(KeyValue::new("service.version", v.clone()));
}
if let Some(env) = &config.environment {
attrs.push(KeyValue::new("deployment.environment", env.clone()));
attrs.push(KeyValue::new("deployment.environment.name", env.clone()));
}
Resource::builder()
.with_attributes(attrs)
.with_service_name(config.service_name.clone())
.build()
}
pub fn init_tracing_with<E, F>(config: TracingConfig, exporter_factory: F) -> Result<TracingHandle>
where
E: SpanExporter + 'static,
F: FnOnce(&TracingConfig) -> Result<E>,
{
init_tracing_with_propagators(config, exporter_factory, HashMap::new())
}
pub fn init_tracing_with_propagators<E, F>(
config: TracingConfig,
exporter_factory: F,
extra_propagators: HashMap<String, BoxedPropagator>,
) -> Result<TracingHandle>
where
E: SpanExporter + 'static,
F: FnOnce(&TracingConfig) -> Result<E>,
{
let options = PipelineOptions {
propagators: extra_propagators,
..PipelineOptions::default()
};
init_tracing_with_pipeline(config, exporter_factory, options)
}
pub fn init_tracing_with_sampler<E, F>(
config: TracingConfig,
exporter_factory: F,
sampler: Sampler,
) -> Result<TracingHandle>
where
E: SpanExporter + 'static,
F: FnOnce(&TracingConfig) -> Result<E>,
{
init_tracing_with_pipeline(
config,
exporter_factory,
PipelineOptions::default().with_sampler(sampler),
)
}
#[derive(Default)]
#[non_exhaustive]
pub struct PipelineOptions {
pub sampler: Option<Sampler>,
pub span_processors: Vec<Box<dyn SpanProcessor>>,
pub propagators: HashMap<String, BoxedPropagator>,
}
impl fmt::Debug for PipelineOptions {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut names: Vec<&String> = self.propagators.keys().collect();
names.sort();
f.debug_struct("PipelineOptions")
.field("sampler", &self.sampler)
.field("span_processors", &self.span_processors)
.field("propagators", &names)
.finish()
}
}
impl PipelineOptions {
pub fn new() -> Self {
PipelineOptions::default()
}
pub fn with_sampler(mut self, sampler: Sampler) -> Self {
self.sampler = Some(sampler);
self
}
pub fn with_span_processor(mut self, processor: impl SpanProcessor + 'static) -> Self {
self.span_processors.push(Box::new(processor));
self
}
pub fn with_propagator(mut self, name: impl Into<String>, propagator: BoxedPropagator) -> Self {
self.propagators.insert(name.into(), propagator);
self
}
}
pub fn init_tracing_with_pipeline<E, F>(
config: TracingConfig,
exporter_factory: F,
options: PipelineOptions,
) -> Result<TracingHandle>
where
E: SpanExporter + 'static,
F: FnOnce(&TracingConfig) -> Result<E>,
{
config.validate()?;
tokio::runtime::Handle::try_current()
.map_err(|_| Error::config("init_tracing must be called inside a tokio runtime"))?;
let propagator = Arc::new(build_propagator(&config.propagators, options.propagators)?);
let exporter = exporter_factory(&config)?;
let batch = BatchConfigBuilder::default()
.with_max_queue_size(config.batch.max_queue_size)
.with_max_export_batch_size(config.batch.max_export_batch_size)
.with_scheduled_delay(config.batch.scheduled_delay)
.with_max_export_timeout(config.batch.export_timeout)
.build();
let processor = BatchSpanProcessor::builder(exporter, Tokio)
.with_batch_config(batch)
.build();
let sampler = options
.sampler
.unwrap_or_else(|| build_sampler(config.sampler, config.sampler_ratio));
let mut builder = SdkTracerProvider::builder()
.with_span_processor(processor)
.with_sampler(sampler)
.with_resource(build_resource(&config));
for extra in options.span_processors {
builder = builder.with_span_processor(BoxedSpanProcessor(extra));
}
let provider = builder.build();
if config.set_global {
opentelemetry::global::set_tracer_provider(provider.clone());
opentelemetry::global::set_text_map_propagator(SharedPropagator(Arc::clone(&propagator)));
}
Ok(TracingHandle::new(
provider,
propagator,
config.service_name,
))
}
#[derive(Debug)]
struct BoxedSpanProcessor(Box<dyn SpanProcessor>);
impl SpanProcessor for BoxedSpanProcessor {
fn on_start(&self, span: &mut opentelemetry_sdk::trace::Span, cx: &opentelemetry::Context) {
self.0.on_start(span, cx)
}
fn on_end(&self, span: opentelemetry_sdk::trace::SpanData) {
self.0.on_end(span)
}
fn force_flush(&self) -> opentelemetry_sdk::error::OTelSdkResult {
self.0.force_flush()
}
fn shutdown_with_timeout(&self, timeout: Duration) -> opentelemetry_sdk::error::OTelSdkResult {
self.0.shutdown_with_timeout(timeout)
}
fn shutdown(&self) -> opentelemetry_sdk::error::OTelSdkResult {
self.0.shutdown()
}
fn set_resource(&mut self, resource: &Resource) {
self.0.set_resource(resource)
}
}
#[derive(Debug)]
struct SharedPropagator(Arc<TextMapCompositePropagator>);
impl opentelemetry::propagation::TextMapPropagator for SharedPropagator {
fn inject_context(
&self,
cx: &opentelemetry::Context,
injector: &mut dyn opentelemetry::propagation::Injector,
) {
self.0.inject_context(cx, injector)
}
fn extract_with_context(
&self,
cx: &opentelemetry::Context,
extractor: &dyn opentelemetry::propagation::Extractor,
) -> opentelemetry::Context {
self.0.extract_with_context(cx, extractor)
}
fn fields(&self) -> opentelemetry::propagation::text_map_propagator::FieldIter<'_> {
self.0.fields()
}
}