Merge branch 'main' into surface-http-status-errors

Author: cijothomas

.cspell.json

@@ -42,7 +42,6 @@
         "Lalit",
         "msrv",
         "Ochtman",
-        "openetelemetry",
         "opentelemetry",
         "OTLP",
         "protoc",
@@ -51,6 +50,7 @@
         "reqwest",
         "rustc",
         "Tescher",
+        "tracerprovider",
         "Zhongyang",
         "zipkin"
     ],

.github/codecov.yaml

@@ -22,9 +22,9 @@ ignore:
   - "opentelemetry-jaeger/examples"
   - "opentelemetry-zipkin/examples"
   - "opentelemetry-otlp/examples"
-  - "opentelemetry-aws/examples"
-  - "opentelemetry-datadog/examples"
-  - "opentelemetry-dynatrace/examples"
   - "opentelemetry-http/examples"
   - "opentelemetry-prometheus/examples"
-  - "opentelemetry-zpages/examples"
+  - "opentelemetry-appender-tracing/examples"
+  - "opentelemetry-appender-log/examples"
+  # stress test
+  - "stress"

CONTRIBUTING.md

@@ -126,7 +126,7 @@ For a deeper discussion, see:
 
 Currently, the Opentelemetry Rust SDK has two ways to handle errors. In the situation where errors are not allowed to return. One should call global error handler to process the errors. Otherwise, one should return the errors.
 
-The Opentelemetry Rust SDK comes with an error type `openetelemetry::Error`. For different function, one error has been defined. All error returned by trace module MUST be wrapped in `opentelemetry::trace::TraceError`. All errors returned by metrics module MUST be wrapped in `opentelemetry::metrics::MetricsError`.
+The Opentelemetry Rust SDK comes with an error type `opentelemetry::Error`. For different function, one error has been defined. All error returned by trace module MUST be wrapped in `opentelemetry::trace::TraceError`. All errors returned by metrics module MUST be wrapped in `opentelemetry::metrics::MetricsError`. All errors returned by logs module MUST be wrapped in `opentelemetry::logs::LogsError`.
 
 For users that want to implement their own exporters. It's RECOMMENDED to wrap all errors from the exporter into a crate-level error type, and implement `ExporterError` trait.
 
@@ -194,6 +194,7 @@ For GitHub groups see the [code owners](CODEOWNERS) file.
 - [Dirkjan Ochtman](https://github.com/djc)
 - [Jan Kühle](https://github.com/frigus02)
 - [Isobel Redelmeier](https://github.com/iredelmeier)
+- [Mike Goldsmith](https://github.com/MikeGoldsmith)
 
 ### Become an Approver or a Maintainer
 

Cargo.toml

@@ -5,6 +5,7 @@ members = [
     "opentelemetry-jaeger",
     "opentelemetry-jaeger/examples/actix-udp",
     "opentelemetry-jaeger/examples/remote-sampler",
+    "opentelemetry-jaeger-propagator",
     "opentelemetry-appender-log",
     "opentelemetry-appender-tracing",
     "opentelemetry-otlp",

README.md

@@ -137,7 +137,6 @@ above, please let us know! We'd love to add your project to the list!
 
 [`open-telemetry/opentelemetry-rust`]: https://github.com/open-telemetry/opentelemetry-rust
 [`opentelemetry-jaeger`]: https://crates.io/crates/opentelemetry-jaeger
-[`Jaeger`]: https://www.jaegertracing.io
 [`opentelemetry-otlp`]: https://crates.io/crates/opentelemetry-otlp
 [`opentelemetry-http`]: https://crates.io/crates/opentelemetry-http
 [`opentelemetry-prometheus`]: https://crates.io/crates/opentelemetry-prometheus
@@ -157,7 +156,7 @@ above, please let us know! We'd love to add your project to the list!
 [`actix-web-opentelemetry`]: https://crates.io/crates/actix-web-opentelemetry
 [`actix-web`]: https://crates.io/crates/actix-web
 [`opentelemetry-application-insights`]: https://crates.io/crates/opentelemetry-application-insights
-[Azure Application Insights]: https://docs.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview
+[Azure Application Insights]: https://docs.microsoft.com/azure/azure-monitor/app/app-insights-overview
 [`opentelemetry-tide`]: https://crates.io/crates/opentelemetry-tide
 [`Tide`]: https://crates.io/crates/tide
 [`opentelemetry-stackdriver`]: https://crates.io/crates/opentelemetry-stackdriver

examples/README.md

@@ -1,5 +1,5 @@
 # Examples
-This folder contains some examples that should help you get start crates from `opentelemetry-rust`.
+This directory contains some examples that should help you get start crates from `opentelemetry-rust`.
 
 ## log-basic
 **Logs**
@@ -32,9 +32,10 @@ This example uses following crates from this repo:
 **Tracing**
 
 This example uses following crates from this repo:
+
 - opentelemetry(tracing)
-- opentelemetry-jaeger
+- opentelemetry-stdout
 
 The application is built using `tokio`.
 
-Check this example if you want to understand *how to integrate tracing with opentelemetry*.
+Check this example if you want to understand *how to create spans and propagate/restore context in OpenTelemetry*.

examples/metrics-basic/src/main.rs

@@ -1,4 +1,5 @@
 use opentelemetry::metrics::Unit;
+use opentelemetry::AttributeSet;
 use opentelemetry::{metrics::MeterProvider as _, KeyValue};
 use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};
 use opentelemetry_sdk::{runtime, Resource};
@@ -52,11 +53,10 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         observer.observe_u64(
             &observable_counter,
             100,
-            [
+            AttributeSet::from(&[
                 KeyValue::new("mykey1", "myvalue1"),
                 KeyValue::new("mykey2", "myvalue2"),
-            ]
-            .as_ref(),
+            ]),
         )
     })?;
 
@@ -84,11 +84,10 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         observer.observe_i64(
             &observable_up_down_counter,
             100,
-            [
+            AttributeSet::from(&[
                 KeyValue::new("mykey1", "myvalue1"),
                 KeyValue::new("mykey2", "myvalue2"),
-            ]
-            .as_ref(),
+            ]),
         )
     })?;
 
@@ -142,11 +141,10 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         observer.observe_f64(
             &observable_gauge,
             1.0,
-            [
+            AttributeSet::from(&[
                 KeyValue::new("mykey1", "myvalue1"),
                 KeyValue::new("mykey2", "myvalue2"),
-            ]
-            .as_ref(),
+            ]),
         )
     })?;
 

examples/tracing-grpc/Cargo.toml

@@ -20,6 +20,7 @@ opentelemetry-stdout = { path = "../../opentelemetry-stdout", features = ["trace
 prost = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 tonic = { workspace = true }
+serde_json = { workspace = true }
 
 [build-dependencies]
 tonic-build = "0.9.2"

examples/tracing-grpc/README.md

@@ -1,24 +1,25 @@
 # GRPC example
 
-Example showing [Tonic] client and server interaction with OpenTelemetry context propagation.  [tracing_opentelemetry](https://docs.rs/tracing-opentelemetry/0.4.0/tracing_opentelemetry/) is used to hook into the [tracing](https://github.com/tokio-rs/tracing) ecosystem, which enables drop-in replacements for [log](https://github.com/rust-lang/log) macros and an `#[instrument]` macro that will automatically add spans to your functions.
+Example showing [Tonic] client and server interaction with OpenTelemetry context
+propagation. Traces are exported to stdout.
 
 [Tonic]: https://github.com/hyperium/tonic
 
-Examples
---------
+## Running the example
 
 ```shell
-# Run jaeger in background
-$ docker run -d -p6831:6831/udp -p6832:6832/udp -p16686:16686 jaegertracing/all-in-one:latest
-
-# Run the server
+# Run the server first
 $ cargo run --bin grpc-server
 
 # Now run the client to make a request to the server
 $ cargo run --bin grpc-client
-
-# View spans (see the image below)
-$ firefox http://localhost:16686/
 ```
 
-![Jaeger UI](trace.png)
+Observe that the traces are exported to stdout, and that they share the same
+TraceId. Also, the server span would be parented to the client span. The example
+demonstrates how to propagate and restore OpenTelemetry context when making
+out-of-process calls, so as to ensure the same trace is continued in the next
+process. The client here initiates the trace by creating the root client span,
+and it propagates its context to the server. The server, extracts the context,
+and creates its own server span using the extracted context, ensuring both spans
+are correlated.

examples/tracing-grpc/src/client.rs

@@ -4,7 +4,7 @@ use opentelemetry::{global, propagation::Injector};
 use opentelemetry_sdk::{
     propagation::TraceContextPropagator, runtime::Tokio, trace::TracerProvider,
 };
-use opentelemetry_stdout::SpanExporter;
+use opentelemetry_stdout::SpanExporterBuilder;
 
 use opentelemetry::{
     trace::{SpanKind, TraceContextExt, Tracer},
@@ -15,7 +15,15 @@ fn init_tracer() {
     global::set_text_map_propagator(TraceContextPropagator::new());
     // Install stdout exporter pipeline to be able to retrieve the collected spans.
     let provider = TracerProvider::builder()
-        .with_batch_exporter(SpanExporter::default(), Tokio)
+        .with_batch_exporter(
+            SpanExporterBuilder::default()
+                .with_encoder(|writer, data| {
+                    serde_json::to_writer_pretty(writer, &data).unwrap();
+                    Ok(())
+                })
+                .build(),
+            Tokio,
+        )
         .build();
 
     global::set_tracer_provider(provider);

examples/tracing-grpc/src/server.rs

@@ -8,14 +8,22 @@ use opentelemetry::{
 use opentelemetry_sdk::{
     propagation::TraceContextPropagator, runtime::Tokio, trace::TracerProvider,
 };
-use opentelemetry_stdout::SpanExporter;
+use opentelemetry_stdout::SpanExporterBuilder;
 use tonic::{transport::Server, Request, Response, Status};
 
 fn init_tracer() {
     global::set_text_map_propagator(TraceContextPropagator::new());
     // Install stdout exporter pipeline to be able to retrieve the collected spans.
     let provider = TracerProvider::builder()
-        .with_batch_exporter(SpanExporter::default(), Tokio)
+        .with_batch_exporter(
+            SpanExporterBuilder::default()
+                .with_encoder(|writer, data| {
+                    serde_json::to_writer_pretty(writer, &data).unwrap();
+                    Ok(())
+                })
+                .build(),
+            Tokio,
+        )
         .build();
 
     global::set_tracer_provider(provider);

examples/tracing-http-propagator/README.md

@@ -24,4 +24,4 @@ $ cargo run --bin http-server
 $ cargo run --bin http-client
 
 # The spans should be visible in stdout in the order that they were exported.
-```
+```

examples/tracing-http-propagator/src/server.rs

@@ -76,9 +76,8 @@ async fn router(req: Request<Body>) -> Result<Response<Body>, Infallible> {
 fn init_tracer() {
     global::set_text_map_propagator(TraceContextPropagator::new());
 
-    // Install stdout exporter pipeline to be able to retrieve the collected spans.
-    // For the demonstration, use `Sampler::AlwaysOn` sampler to sample all traces. In a production
-    // application, use `Sampler::ParentBased` or `Sampler::TraceIdRatioBased` with a desired ratio.
+    // Setup tracerprovider with stdout exporter
+    // that prints the spans to stdout.
     let provider = TracerProvider::builder()
         .with_simple_exporter(SpanExporter::default())
         .build();

opentelemetry-appender-log/src/lib.rs

@@ -69,3 +69,104 @@ const fn severity_of_level(level: Level) -> Severity {
         Level::Trace => Severity::Trace,
     }
 }
+
+#[cfg(all(test, feature = "testing", feature = "logs"))]
+mod tests {
+    use super::OpenTelemetryLogBridge;
+
+    use opentelemetry_sdk::{logs::LoggerProvider, testing::logs::InMemoryLogsExporter};
+
+    use log::{Level, Log};
+
+    #[test]
+    fn logbridge_with_default_metadata_is_enabled() {
+        let exporter = InMemoryLogsExporter::default();
+
+        let logger_provider = LoggerProvider::builder()
+            .with_simple_exporter(exporter)
+            .build();
+
+        let otel_log_appender = OpenTelemetryLogBridge::new(&logger_provider);
+
+        // As a result of using `with_simple_exporter` while building the logger provider,
+        // the processor used is a `SimpleLogProcessor` which has an implementation of `event_enabled`
+        // that always returns true.
+        #[cfg(feature = "logs_level_enabled")]
+        assert_eq!(
+            otel_log_appender.enabled(&log::Metadata::builder().build()),
+            true
+        );
+        #[cfg(not(feature = "logs_level_enabled"))]
+        assert_eq!(
+            otel_log_appender.enabled(&log::Metadata::builder().build()),
+            true
+        );
+    }
+
+    #[test]
+    fn logbridge_with_record_can_log() {
+        let exporter = InMemoryLogsExporter::default();
+
+        let logger_provider = LoggerProvider::builder()
+            .with_simple_exporter(exporter.clone())
+            .build();
+
+        let otel_log_appender = OpenTelemetryLogBridge::new(&logger_provider);
+
+        log::set_boxed_logger(Box::new(otel_log_appender)).unwrap();
+        log::set_max_level(Level::Trace.to_level_filter());
+
+        log::trace!("TRACE");
+        log::debug!("DEBUG");
+        log::info!("INFO");
+        log::warn!("WARN");
+        log::error!("ERROR");
+
+        let logs = exporter.get_emitted_logs().unwrap();
+
+        assert_eq!(logs.len(), 5);
+        for log in logs {
+            let body: String = match log.record.body.as_ref().unwrap() {
+                super::AnyValue::String(s) => s.to_string(),
+                _ => panic!("AnyValue::String expected"),
+            };
+            assert_eq!(body, log.record.severity_text.unwrap());
+        }
+    }
+
+    #[test]
+    fn test_flush() {
+        let exporter = InMemoryLogsExporter::default();
+
+        let logger_provider = LoggerProvider::builder()
+            .with_simple_exporter(exporter)
+            .build();
+
+        let otel_log_appender = OpenTelemetryLogBridge::new(&logger_provider);
+        otel_log_appender.flush();
+    }
+
+    #[test]
+    fn check_level_severities() {
+        assert_eq!(
+            super::severity_of_level(log::Level::Error),
+            opentelemetry::logs::Severity::Error
+        );
+        assert_eq!(
+            super::severity_of_level(log::Level::Warn),
+            opentelemetry::logs::Severity::Warn
+        );
+        assert_eq!(
+            super::severity_of_level(log::Level::Info),
+            opentelemetry::logs::Severity::Info
+        );
+        assert_eq!(
+            super::severity_of_level(log::Level::Debug),
+            opentelemetry::logs::Severity::Debug
+        );
+        assert_eq!(
+            super::severity_of_level(log::Level::Trace),
+            opentelemetry::logs::Severity::Trace
+        );
+    }
+}

opentelemetry-appender-tracing/Cargo.toml

@@ -14,10 +14,10 @@ rust-version = "1.65"
 log = { workspace = true, optional = true }
 opentelemetry = { version = "0.21", path = "../opentelemetry", features = ["logs"] }
 opentelemetry_sdk = { version = "0.21", path = "../opentelemetry-sdk", features = ["logs"] }
-tracing = { workspace = true, default-features = false, features = ["std"]}
+tracing = { workspace = true, features = ["std"]}
 tracing-core = { workspace = true }
 tracing-log = { version = "0.2", optional = true }
-tracing-subscriber = { workspace = true, default-features = false, features = ["registry", "std"] }
+tracing-subscriber = { workspace = true, features = ["registry", "std"] }
 once_cell = "1.13.0"
 
 [dev-dependencies]

opentelemetry-http/Cargo.toml

@@ -13,9 +13,9 @@ rust-version = "1.65"
 async-trait = { workspace = true }
 bytes = { workspace = true }
 http = { workspace = true }
-hyper = { workspace = true, default-features = false, features = ["http2", "client", "tcp"], optional = true }
-isahc = { workspace = true, default-features = false, optional = true }
+hyper = { workspace = true, features = ["http2", "client", "tcp"], optional = true }
+isahc = { workspace = true, optional = true }
 opentelemetry = { version = "0.21", path = "../opentelemetry", features = ["trace"] }
-reqwest = { workspace = true, default-features = false, features = ["blocking"], optional = true }
-surf = { workspace = true, default-features = false, optional = true }
-tokio = { workspace = true, default-features = false, features = ["time"], optional = true }
+reqwest = { workspace = true, features = ["blocking"], optional = true }
+surf = { workspace = true, optional = true }
+tokio = { workspace = true, features = ["time"], optional = true }

opentelemetry-jaeger-propagator/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## vNext
+
+## v0.1.0
+
+### Added
+
+- As part of the gradual deprecation of the exporter functionality of the opentelemetry-jaeger crate, move the opentelemetry-jaeger propagator functionality to a new crate named opentelemetry-jaeger-propagator [#1487](https://github.com/open-telemetry/opentelemetry-rust/pull/1487)