Add basic stress test for tracing (#1286)

Author: cijothomas

opentelemetry/src/lib.rs

@@ -63,8 +63,6 @@
 //!
 //! # Metrics
 //!
-//! Note: the metrics specification is **still in progress** and **subject to major
-//! changes**.
 //!
 //! The [`metrics`] module includes types for recording measurements about a
 //! service at runtime.

opentelemetry/src/metrics/meter.rs

@@ -66,7 +66,7 @@ pub trait MeterProvider {
     ) -> Meter;
 }
 
-/// Provides access to instrument instances for recording metrics.
+/// Provides access to instrument instances for recording measurements.
 ///
 /// ```
 /// use opentelemetry::{global, KeyValue};
@@ -99,7 +99,7 @@ pub trait MeterProvider {
 ///     ].as_ref()
 /// );
 ///
-/// // u6 oberservable counter
+/// // u6 observable counter
 /// let observable_u4_counter = meter.u64_observable_counter("my_observable_u64_counter").init();
 ///
 /// // Register a callback to this meter for an asynchronous instrument to record measurements
@@ -114,7 +114,7 @@ pub trait MeterProvider {
 ///     )
 /// });
 ///
-/// // f64 oberservable counter
+/// // f64 observable counter
 /// let observable_f64_counter = meter.f64_observable_counter("my_observable_f64_counter").init();
 ///
 /// // Register a callback to this meter for an asynchronous instrument to record measurements
@@ -153,7 +153,7 @@ pub trait MeterProvider {
 ///     ].as_ref(),
 /// );
 ///
-/// // i64 oberservable updown counter
+/// // i64 observable updown counter
 /// let observable_i64_up_down_counter = meter.i64_observable_up_down_counter("my_observable_i64_updown_counter").init();
 ///
 /// // Register a callback to this meter for an asynchronous instrument to record measurements
@@ -168,7 +168,7 @@ pub trait MeterProvider {
 ///     )
 /// });
 ///
-/// // f64 oberservable updown counter
+/// // f64 observable updown counter
 /// let observable_f64_up_down_counter = meter.f64_observable_up_down_counter("my_observable_f64_updown_counter").init();
 ///
 /// // Register a callback to this meter for an asynchronous instrument to record measurements
@@ -183,7 +183,7 @@ pub trait MeterProvider {
 ///     )
 /// });
 ///
-/// // Oberservable f64 gauge
+/// // Observable f64 gauge
 /// let f64_gauge = meter.f64_observable_gauge("my_f64_gauge").init();
 ///
 /// // Register a callback to this meter for an asynchronous instrument to record measurements
@@ -198,7 +198,7 @@ pub trait MeterProvider {
 ///     )
 /// });
 ///
-/// // Oberservable i64 gauge
+/// // Observable i64 gauge
 /// let i64_gauge = meter.i64_observable_gauge("my_i64_gauge").init();
 ///
 /// // Register a callback to this meter for an asynchronous instrument to record measurements
@@ -213,7 +213,7 @@ pub trait MeterProvider {
 ///     )
 /// });
 ///
-/// // Oberservable u64 gauge
+/// // Observable u64 gauge
 /// let u64_gauge = meter.u64_observable_gauge("my_u64_gauge").init();
 ///
 /// // Register a callback to this meter for an asynchronous instrument to record measurements

opentelemetry/src/trace/mod.rs

@@ -81,7 +81,7 @@
 //!
 //! Exporting spans often involves sending data over a network or performing
 //! other I/O tasks. OpenTelemetry allows you to schedule these tasks using
-//! whichever runtime you area already using such as [Tokio] or [async-std].
+//! whichever runtime you are already using such as [Tokio] or [async-std].
 //! When using an async runtime it's best to use the batch span processor
 //! where the spans will be sent in batches as opposed to being sent once ended,
 //! which often ends up being more efficient.

stress/Cargo.toml

@@ -14,12 +14,17 @@ name = "logs"
 path = "src/logs.rs"
 doc = false
 
+[[bin]] # Bin to run the traces stress tests
+name = "traces"
+path = "src/traces.rs"
+doc = false
+
 [dependencies]
 ctrlc = "3.2.5"
 lazy_static = "1.4.0"
 num_cpus = "1.15.0"
-opentelemetry = { path = "../opentelemetry", features = ["metrics", "logs"] }
-opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["metrics", "logs"] }
+opentelemetry = { path = "../opentelemetry", features = ["metrics", "logs", "trace"] }
+opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["metrics", "logs", "trace"] }
 opentelemetry-appender-tracing = { path = "../opentelemetry-appender-tracing"}
 opentelemetry-stdout = { path = "../opentelemetry-stdout", features = ["logs"]}
 rand = { version = "0.8.4", features = ["small_rng"] }

stress/README.md

@@ -29,12 +29,10 @@ Press (Ctrl + C) to quit the tests.
 Example output:
 
 ```text
-Throughput: 4813019.00 requests/sec
-Throughput: 4805997.50 requests/sec
-Throughput: 4796934.50 requests/sec
-Throughput: 4817836.50 requests/sec
-Throughput: 4812457.00 requests/sec
-Throughput: 4773890.50 requests/sec
-Throughput: 4760047.00 requests/sec
-Throughput: 4851061.50 requests/sec
+Number of threads: 4
+Throughput: 4,714,600 iterations/sec
+Throughput: 4,840,200 iterations/sec
+Throughput: 3,905,200 iterations/sec
+Throughput: 4,106,600 iterations/sec
+Throughput: 5,075,400 iterations/sec
 ```

stress/src/throughput.rs

@@ -27,7 +27,7 @@ where
     })
     .expect("Error setting Ctrl-C handler");
     let num_threads = num_cpus::get_physical();
-    println!("Number threads: {}", num_threads);
+    println!("Number of threads: {}", num_threads);
     let mut handles = Vec::with_capacity(num_threads);
     let func_arc = Arc::new(func);
     let mut worker_stats_vec: Vec<WorkerStats> = Vec::new();

stress/src/traces.rs

@@ -0,0 +1,31 @@
+use lazy_static::lazy_static;
+use opentelemetry::{
+    trace::{Span, SpanBuilder, Tracer, TracerProvider as _},
+    KeyValue,
+};
+use opentelemetry_sdk::trace as sdktrace;
+
+mod throughput;
+
+lazy_static! {
+    static ref PROVIDER: sdktrace::TracerProvider = sdktrace::TracerProvider::builder()
+        .with_config(sdktrace::config().with_sampler(sdktrace::Sampler::AlwaysOn))
+        .build();
+    static ref TRACER: sdktrace::Tracer = PROVIDER.tracer("stress");
+}
+
+fn main() {
+    throughput::test_throughput(test_span);
+}
+
+fn test_span() {
+    let span_builder = SpanBuilder::from_name("test_span").with_attributes(vec![
+        KeyValue::new("attribute_at_span_start1", "value1"),
+        KeyValue::new("attribute_at_span_start2", "value2"),
+    ]);
+
+    let mut span = TRACER.build(span_builder);
+    span.set_attribute(KeyValue::new("key3", "value3"));
+    span.set_attribute(KeyValue::new("key4", "value4"));
+    span.end();
+}