revert unwanted example change

Author: cijothomas

examples/metrics-basic/Cargo.toml

@@ -11,9 +11,6 @@ opentelemetry_sdk = { path = "../../opentelemetry-sdk", features = ["metrics", "
 opentelemetry-stdout = { path = "../../opentelemetry-stdout", features = ["metrics"]}
 tokio = { workspace = true, features = ["full"] }
 serde_json = { workspace = true }
-tracing = { workspace = true, features = ["std"]}
-tracing-core = { workspace = true }
-tracing-subscriber = { version = "0.3.18", features = ["env-filter","registry", "std"]}
 
 [features]
 default = ["otel_unstable"]

examples/metrics-basic/src/main.rs

@@ -1,25 +1,17 @@
 use opentelemetry::global;
 use opentelemetry::KeyValue;
 use opentelemetry_sdk::metrics::data::Temporality;
-use opentelemetry_sdk::metrics::PeriodicReaderWithOwnThread;
 use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};
 use opentelemetry_sdk::{runtime, Resource};
-use tracing_subscriber::fmt;
-use tracing_subscriber::layer::SubscriberExt;
-use tracing_subscriber::util::SubscriberInitExt;
-use tracing_subscriber::EnvFilter;
-use tracing_subscriber::Layer;
 use std::error::Error;
-use std::time::Duration;
+use std::vec;
 
 fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
     let exporter = opentelemetry_stdout::MetricExporterBuilder::default()
         // Build exporter using Delta Temporality (Defaults to Temporality::Cumulative)
         .with_temporality(Temporality::Delta)
         .build();
-    let reader = PeriodicReaderWithOwnThread::builder(exporter)
-        .with_interval(Duration::from_secs(10))
-        .build();
+    let reader = PeriodicReader::builder(exporter, runtime::Tokio).build();
     let provider = SdkMeterProvider::builder()
         .with_reader(reader)
         .with_resource(Resource::new([KeyValue::new(
@@ -33,16 +25,24 @@ fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-tracing_subscriber::registry()
-    .with(fmt::layer().with_thread_names(true))
-    .init();
-
     // Initialize the MeterProvider with the stdout Exporter.
     let meter_provider = init_meter_provider();
 
     // Create a meter from the above MeterProvider.
     let meter = global::meter("mylibraryname");
 
+    // Create a Counter Instrument.
+    let counter = meter.u64_counter("my_counter").build();
+
+    // Record measurements using the Counter instrument.
+    counter.add(
+        10,
+        &[
+            KeyValue::new("mykey1", "myvalue1"),
+            KeyValue::new("mykey2", "myvalue2"),
+        ],
+    );
+
     // Create a ObservableCounter instrument and register a callback that reports the measurement.
     let _observable_counter = meter
         .u64_observable_counter("my_observable_counter")
@@ -59,20 +59,84 @@ tracing_subscriber::registry()
         })
         .build();
 
-    // Create a Counter Instrument.
-    let counter = meter.u64_counter("my_counter").build();
+    // Create a UpCounter Instrument.
+    let updown_counter = meter.i64_up_down_counter("my_updown_counter").build();
 
-    loop {
-        // Record measurements using the Counter instrument.
-        counter.add(
-            10,
-            &[
-                KeyValue::new("mykey1", "myvalue1"),
-                KeyValue::new("mykey2", "myvalue2"),
-            ],
-        );
-        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-    }
+    // Record measurements using the UpCounter instrument.
+    updown_counter.add(
+        -10,
+        &[
+            KeyValue::new("mykey1", "myvalue1"),
+            KeyValue::new("mykey2", "myvalue2"),
+        ],
+    );
+
+    // Create a Observable UpDownCounter instrument and register a callback that reports the measurement.
+    let _observable_up_down_counter = meter
+        .i64_observable_up_down_counter("my_observable_updown_counter")
+        .with_description("My observable updown counter example description")
+        .with_unit("myunit")
+        .with_callback(|observer| {
+            observer.observe(
+                100,
+                &[
+                    KeyValue::new("mykey1", "myvalue1"),
+                    KeyValue::new("mykey2", "myvalue2"),
+                ],
+            )
+        })
+        .build();
+
+    // Create a Histogram Instrument.
+    let histogram = meter
+        .f64_histogram("my_histogram")
+        .with_description("My histogram example description")
+        // Setting boundaries is optional. By default, the boundaries are set to
+        // [0.0, 5.0, 10.0, 25.0, 50.0, 75.0, 100.0, 250.0, 500.0, 750.0, 1000.0, 2500.0, 5000.0, 7500.0, 10000.0]
+        .with_boundaries(vec![0.0, 5.0, 10.0, 15.0, 20.0, 25.0])
+        .build();
+
+    // Record measurements using the histogram instrument.
+    histogram.record(
+        10.5,
+        &[
+            KeyValue::new("mykey1", "myvalue1"),
+            KeyValue::new("mykey2", "myvalue2"),
+        ],
+    );
+
+    // Note that there is no ObservableHistogram instrument.
+
+    // Create a Gauge Instrument.
+    let gauge = meter
+        .f64_gauge("my_gauge")
+        .with_description("A gauge set to 1.0")
+        .with_unit("myunit")
+        .build();
+
+    gauge.record(
+        1.0,
+        &[
+            KeyValue::new("mykey1", "myvalue1"),
+            KeyValue::new("mykey2", "myvalue2"),
+        ],
+    );
+
+    // Create a ObservableGauge instrument and register a callback that reports the measurement.
+    let _observable_gauge = meter
+        .f64_observable_gauge("my_observable_gauge")
+        .with_description("An observable gauge set to 1.0")
+        .with_unit("myunit")
+        .with_callback(|observer| {
+            observer.observe(
+                1.0,
+                &[
+                    KeyValue::new("mykey1", "myvalue1"),
+                    KeyValue::new("mykey2", "myvalue2"),
+                ],
+            )
+        })
+        .build();
 
     // Metrics are exported by default every 30 seconds when using stdout exporter,
     // however shutting down the MeterProvider here instantly flushes