Crate opentelemetry_datadog[−][src]
OpenTelemetry Datadog Exporter
An OpenTelemetry datadog exporter implementation
See the Datadog Docs for information on how to run the datadog-agent
Quirks
There are currently some incompatibilities between Datadog and OpenTelemetry, and this manifests as minor quirks to this exporter.
Firstly Datadog uses operation_name to describe what OpenTracing would call a component. Or to put it another way, in OpenTracing the operation / span name’s are relatively granular and might be used to identify a specific endpoint. In datadog, however, they are less granular - it is expected in Datadog that a service will have single primary span name that is the root of all traces within that service, with an additional piece of metadata called resource_name providing granularity. See here
The Datadog Golang API takes the approach of using a resource.name
OpenTelemetry attribute to set the
resource_name. See here
Unfortunately, this breaks compatibility with other OpenTelemetry exporters which expect a more granular operation name - as per the OpenTracing specification.
This exporter therefore takes a different approach of naming the span with the name of the tracing provider, and using the span name to set the resource_name. This should in most cases lead to the behaviour that users expect.
Datadog additionally has a span_type string that alters the rendering of the spans in the web UI.
This can be set as the span.type
OpenTelemetry span attribute.
For standard values see here
Performance
For optimal performance, a batch exporter is recommended as the simple exporter will export
each span synchronously on drop. You can enable the rt-tokio
, rt-tokio-current-thread
or rt-async-std
features and specify a runtime on the pipeline to have a batch exporter
configured for you automatically.
[dependencies]
opentelemetry = { version = "*", features = ["rt-tokio"] }
opentelemetry-datadog = "*"
let tracer = opentelemetry_datadog::new_pipeline() .install_batch(opentelemetry::runtime::Tokio)?;
Bring your own http client
Users can choose appropriate http clients to align with their runtime.
Based on the feature enabled. The default http client will be different. If user doesn’t specific
features or enabled reqwest-blocking-client
feature. The blocking reqwest http client will be used as
default client. If reqwest-client
feature is enabled. The async reqwest http client will be used. If
surf-client
feature is enabled. The surf http client will be used.
Note that async http clients may need specific runtime otherwise it will panic. User should make sure the http client is running in appropriate runime.
Users can always use their own http clients by implementing HttpClient
trait.
Kitchen Sink Full Configuration
Example showing how to override all configuration options. See the
DatadogPipelineBuilder
docs for details of each option.
use opentelemetry::{KeyValue, trace::Tracer}; use opentelemetry::sdk::{trace::{self, IdGenerator, Sampler}, Resource}; use opentelemetry::sdk::export::trace::ExportResult; use opentelemetry::global::shutdown_tracer_provider; use opentelemetry_datadog::{new_pipeline, ApiVersion, Error}; use opentelemetry_http::{HttpClient, HttpError}; use async_trait::async_trait; use bytes::Bytes; use futures_util::io::AsyncReadExt as _; use http::{Request, Response}; use std::convert::TryInto as _; // `reqwest` and `surf` are supported through features, if you prefer an // alternate http client you can add support by implementing `HttpClient` as // shown here. #[derive(Debug)] struct IsahcClient(isahc::HttpClient); async fn body_to_bytes(mut body: isahc::Body) -> Result<Bytes, HttpError> { let mut bytes = Vec::with_capacity(body.len().unwrap_or(0).try_into()?); let _ = body.read_to_end(&mut bytes).await?; Ok(bytes.into()) } #[async_trait] impl HttpClient for IsahcClient { async fn send(&self, request: Request<Vec<u8>>) -> Result<Response<Bytes>, HttpError> { let response = self.0.send_async(request).await?; Ok(Response::builder() .status(response.status()) .body(body_to_bytes(response.into_body()).await?)?) } } fn main() -> Result<(), opentelemetry::trace::TraceError> { let tracer = new_pipeline() .with_service_name("my_app") .with_version(ApiVersion::Version05) .with_agent_endpoint("http://localhost:8126") .with_trace_config( trace::config() .with_sampler(Sampler::AlwaysOn) .with_id_generator(IdGenerator::default()) ) .install_batch(opentelemetry::runtime::Tokio)?; tracer.in_span("doing_work", |cx| { // Traced app logic here... }); shutdown_tracer_provider(); // sending remaining spans before exit Ok(()) }
Structs
DatadogExporter | Datadog span exporter |
DatadogPipelineBuilder | Builder for |
DatadogPropagator | Extracts and injects |
Enums
ApiVersion | Version of datadog trace ingestion API |
Error | Wrap type for errors from opentelemetry datadog exporter |
Functions
new_pipeline | Create a new Datadog exporter pipeline builder. |