opentelemetry-rust VS tracing

Why are you accusing me of posting an LLM reply?

I just shared that I enjoyed using and contributing to OpenTelemetry. I never used an LLM. Do I really need to prove that I'm human?

- a couple PRs I posted to Rust impl: https://github.com/open-telemetry/opentelemetry-rust/pulls?q...

I believe if you set up an Open Telemetry tracer, you can use the Datadog Lambda Extension to send those traces (as well as logs and some additional lambda metrics) to Datadog.

A lot of APM products these days support OpenTelemetry in addition to their custom APM agents. You could try using https://github.com/open-telemetry/opentelemetry-rust paired with an APM provider that works with OpenTelemetry.

(Source: https://github.com/open-telemetry/opentelemetry-rust/blob/main/examples/http/src/client.rs)

Here’s a recent example: https://github.com/open-telemetry/opentelemetry-rust/pull/881

dd-trace-layer is a middleware for sending Datadog's trace. It's based on Tower and OpenTelemetry Rust.

I plan to use OpenTelemetry for my async project, but I'm a bit unclear about whether to use the `tracing`, native `opentelemetry` or even the `tracing-opentelemetry` crate? Both tracing and opentelemetry support instrumenting async/await code. What is the relationship between tracing and opentelemetry? If Otel is trying to standardize a spec for observability across languages and vendors and supports async/await rust code, what's the motivation to learn the `tracing` crate's API at this time?

The git repository called opentelemetry-rust contains implementations of several crates that expand the opentelemetry ecosystem. There you can find common instrumentations, exporters, and subscribers use them in a Rust program.

Not sure about the Aspecto exporter you are using but the last time I tried to use the Jaeger one it seemed fundamentally broken if you had even a moderate amount of spans in a way that keeps popping up and the developers keep closing with various suggestions for workarounds (on the issues of previous people encountering it) that did not work for me ( https://github.com/open-telemetry/opentelemetry-rust/issues/851 ).

You could give open telemetry a try. I've been meaning to check it out, but haven't had a chance yet. https://github.com/open-telemetry/opentelemetry-rust

We’ll use Axum with Tokio to build a web backend, Tracing for logging, and Serde for serialization and deserialization.

I'm using Tokio's tracing library which provides the ability to plug layers into the writer. One of those layers happens to be an OTel layer. With OpenTelemetry, I can define endpoints where I'm going to send my traces. Normally, I'd send over HTTP or gRPC and the standard ports, but there is an additional crate I'm using that is not maintained by Datadog but it is community-supported. That crate is called opentelemetry-datadog and it helps establish the pipeline, service name, endpoint, and API version that the Datadog extension will recognize.

The video description is as follows:

In this stream, we peel back the crust on the tracing crate — https://github.com/tokio-rs/tracing/ — and explore its interface, structure, and mechanisms. We talk about spans, events, their attributes and fields, and how to think about them in async code. We also dig into what subscribers are, how they pick up events, and how you can construct your own subscribers through the layer abstraction. For more details about tracing, see https://docs.rs/tracing/latest/tracing/.

> What's been your biggest issues around ergonomics/amenities for OpenTelemetry?

I can't speak generally, but in the Rust ecosystem the various crates don't play well together. Here's one example: <https://github.com/tokio-rs/tracing/issues/2648> There are four crates involved (tracing-attributes, tracing-opentelemetry, opentelemetry, and opentelemetry-datadog) and none of them fit properly into any of the others.

The tracing (logging) mechanism in an asynchronous codebase (tracing).

Tracing is Tokio's alternative for async code.

At a technical level, in Rust, both [tracing]https://crates.io/crates/tracing) and log are entire ecosystems (though for the latter at least there's also third party logging frameworks), and there's at least a bridge from log to tracing.

I am using https://github.com/tokio-rs/tracing for logging purposes in my application. I would like to develop a feature wherein logs should be saved to a database table (via sea-orm). Something similar is this, but it does not solve my needs fully.

I've used the tracing infrastructure with tracing_flame to profile some hot paths in async code: https://github.com/tokio-rs/tracing/tree/master/tracing-flame