refactor: make MetricsExporter and Builder non-plural

Make metrics more consistent with other signals

Author: pitoniak32

examples/metrics-advanced/src/main.rs

@@ -45,7 +45,7 @@ fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
     };
 
     // Build exporter using Delta Temporality.
-    let exporter = opentelemetry_stdout::MetricsExporterBuilder::default()
+    let exporter = opentelemetry_stdout::MetricExporterBuilder::default()
         .with_temporality(Temporality::Delta)
         .build();
 

examples/metrics-basic/src/main.rs

@@ -6,7 +6,7 @@ use std::error::Error;
 use std::vec;
 
 fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
-    let exporter = opentelemetry_stdout::MetricsExporterBuilder::default()
+    let exporter = opentelemetry_stdout::MetricExporterBuilder::default()
         // Build exporter using Delta Temporality (Defaults to Temporality::Cumulative)
         // .with_temporality(data::Temporality::Delta)
         .build();

examples/self-diagnostics/src/main.rs

@@ -1,7 +1,7 @@
 use opentelemetry::global::{self, set_error_handler, Error as OtelError};
 use opentelemetry::KeyValue;
 use opentelemetry_appender_tracing::layer;
-use opentelemetry_otlp::{LogExporter, MetricsExporter, WithExportConfig};
+use opentelemetry_otlp::{LogExporter, MetricExporter, WithExportConfig};
 use opentelemetry_sdk::metrics::PeriodicReader;
 use tracing_subscriber::filter::{EnvFilter, LevelFilter};
 use tracing_subscriber::fmt;
@@ -109,7 +109,7 @@ fn init_logger_provider() -> opentelemetry_sdk::logs::LoggerProvider {
 }
 
 fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
-    let exporter = MetricsExporter::builder()
+    let exporter = MetricExporter::builder()
         .with_http()
         .with_endpoint("http://localhost:4318/v1/metrics")
         .build()

opentelemetry-otlp/examples/basic-otlp-http/src/main.rs

@@ -7,7 +7,7 @@ use opentelemetry::{
 };
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
 use opentelemetry_otlp::WithExportConfig;
-use opentelemetry_otlp::{LogExporter, MetricsExporter, Protocol, SpanExporter};
+use opentelemetry_otlp::{LogExporter, MetricExporter, Protocol, SpanExporter};
 use opentelemetry_sdk::{
     logs::LoggerProvider,
     metrics::{PeriodicReader, SdkMeterProvider},
@@ -66,7 +66,7 @@ fn init_tracer_provider() -> Result<sdktrace::TracerProvider, TraceError> {
 }
 
 fn init_metrics() -> Result<opentelemetry_sdk::metrics::SdkMeterProvider, MetricError> {
-    let exporter = MetricsExporter::builder()
+    let exporter = MetricExporter::builder()
         .with_http()
         .with_protocol(Protocol::HttpBinary) //can be changed to `Protocol::HttpJson` to export in JSON format
         .with_endpoint("http://localhost:4318/v1/metrics")

opentelemetry-otlp/examples/basic-otlp/README.md

@@ -120,7 +120,7 @@ SpanEvent #0
 ### Metric
 
 ```text
-2024-05-22T20:25:42.908Z    info    MetricsExporter {"kind": "exporter", "data_type": "metrics", "name": "logging", "resource metrics": 1, "metrics": 1, "data points": 1}
+2024-05-22T20:25:42.908Z    info    MetricExporter {"kind": "exporter", "data_type": "metrics", "name": "logging", "resource metrics": 1, "metrics": 1, "data points": 1}
 2024-05-22T20:25:42.908Z    info    ResourceMetrics #0
 Resource SchemaURL:
 Resource attributes:

opentelemetry-otlp/examples/basic-otlp/src/main.rs

@@ -5,7 +5,7 @@ use opentelemetry::trace::{TraceContextExt, TraceError, Tracer};
 use opentelemetry::KeyValue;
 use opentelemetry::{global, InstrumentationScope};
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
-use opentelemetry_otlp::{LogExporter, MetricsExporter, SpanExporter, WithExportConfig};
+use opentelemetry_otlp::{LogExporter, MetricExporter, SpanExporter, WithExportConfig};
 use opentelemetry_sdk::logs::LoggerProvider;
 use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};
 use opentelemetry_sdk::trace::Config;
@@ -34,7 +34,7 @@ fn init_tracer_provider() -> Result<sdktrace::TracerProvider, TraceError> {
 }
 
 fn init_metrics() -> Result<opentelemetry_sdk::metrics::SdkMeterProvider, MetricError> {
-    let exporter = MetricsExporter::builder().with_tonic().build()?;
+    let exporter = MetricExporter::builder().with_tonic().build()?;
 
     let reader = PeriodicReader::builder(exporter, runtime::Tokio).build();
 

opentelemetry-otlp/src/exporter/http/mod.rs

@@ -83,7 +83,7 @@ impl Default for HttpConfig {
 ///
 /// // Create a metrics exporter you can use when configuring meter providers
 /// # #[cfg(feature="metrics")]
-/// let metrics_exporter = opentelemetry_otlp::MetricsExporter::builder()
+/// let metrics_exporter = opentelemetry_otlp::MetricExporter::builder()
 ///     .with_http()
 ///     .with_temporality(Temporality::default())
 ///     .build()?;
@@ -221,7 +221,7 @@ impl HttpExporterBuilder {
     pub fn build_metrics_exporter(
         mut self,
         temporality: opentelemetry_sdk::metrics::data::Temporality,
-    ) -> opentelemetry::metrics::MetricResult<crate::MetricsExporter> {
+    ) -> opentelemetry::metrics::MetricResult<crate::MetricExporter> {
         use crate::{
             OTEL_EXPORTER_OTLP_METRICS_ENDPOINT, OTEL_EXPORTER_OTLP_METRICS_HEADERS,
             OTEL_EXPORTER_OTLP_METRICS_TIMEOUT,
@@ -234,7 +234,7 @@ impl HttpExporterBuilder {
             OTEL_EXPORTER_OTLP_METRICS_HEADERS,
         )?;
 
-        Ok(crate::MetricsExporter::new(client, temporality))
+        Ok(crate::MetricExporter::new(client, temporality))
     }
 }
 

opentelemetry-otlp/src/exporter/tonic/mod.rs

@@ -90,7 +90,7 @@ impl TryFrom<Compression> for tonic::codec::CompressionEncoding {
 ///
 /// // Create a metric exporter you can use when configuring meter providers
 /// # #[cfg(feature="metrics")]
-/// let metric_exporter = opentelemetry_otlp::MetricsExporter::builder()
+/// let metric_exporter = opentelemetry_otlp::MetricExporter::builder()
 ///     .with_tonic()
 ///     .with_temporality(Temporality::default())
 ///     .build()?;
@@ -274,8 +274,8 @@ impl TonicExporterBuilder {
     pub(crate) fn build_metrics_exporter(
         self,
         temporality: opentelemetry_sdk::metrics::data::Temporality,
-    ) -> opentelemetry::metrics::MetricResult<crate::MetricsExporter> {
-        use crate::MetricsExporter;
+    ) -> opentelemetry::metrics::MetricResult<crate::MetricExporter> {
+        use crate::MetricExporter;
         use metrics::TonicMetricsClient;
 
         let (channel, interceptor, compression) = self.build_channel(
@@ -287,7 +287,7 @@ impl TonicExporterBuilder {
 
         let client = TonicMetricsClient::new(channel, interceptor, compression);
 
-        Ok(MetricsExporter::new(client, temporality))
+        Ok(MetricExporter::new(client, temporality))
     }
 
     /// Build a new tonic span exporter

opentelemetry-otlp/src/lib.rs

@@ -25,7 +25,7 @@
 //! telemetry.
 //!
 //! You will have to build a OTLP exporter first. Create the correct exporter based on the signal
-//! you are looking to export `SpanExporter::builder()`, `MetricsExporter::builder()`,
+//! you are looking to export `SpanExporter::builder()`, `MetricExporter::builder()`,
 //! `LogExporter::builder()` respectively for traces, metrics, and logs.
 //!
 //! Once you have the exporter, you can create your `Provider` by starting with `TracerProvider::builder()`,
@@ -124,7 +124,7 @@
 //!
 //! Generally there are two parts of configuration. One is the exporter, the other is the provider.
 //! Users can configure the exporter using [SpanExporter::builder()] for traces,
-//! and [MetricsExporter::builder()] + [opentelemetry_sdk::metrics::PeriodicReader::builder()] for metrics.
+//! and [MetricExporter::builder()] + [opentelemetry_sdk::metrics::PeriodicReader::builder()] for metrics.
 //! Once you have an exporter, you can add it to either a [opentelemetry_sdk::trace::TracerProvider::builder()] for traces,
 //! or [opentelemetry_sdk::metrics::SdkMeterProvider::builder()] for metrics.
 //!
@@ -171,7 +171,7 @@
 //!
 //!     # #[cfg(all(feature = "metrics", feature = "grpc-tonic"))]
 //!     # {
-//!     let exporter = opentelemetry_otlp::MetricsExporter::builder()
+//!     let exporter = opentelemetry_otlp::MetricExporter::builder()
 //!        .with_tonic()
 //!        .with_endpoint("http://localhost:4318/v1/metrics")
 //!        .with_protocol(Protocol::Grpc)
@@ -240,7 +240,7 @@ pub use crate::span::{
 #[cfg(feature = "metrics")]
 #[cfg(any(feature = "http-proto", feature = "http-json", feature = "grpc-tonic"))]
 pub use crate::metric::{
-    MetricsExporter, OTEL_EXPORTER_OTLP_METRICS_COMPRESSION, OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
+    MetricExporter, OTEL_EXPORTER_OTLP_METRICS_COMPRESSION, OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
     OTEL_EXPORTER_OTLP_METRICS_HEADERS, OTEL_EXPORTER_OTLP_METRICS_TIMEOUT,
 };
 

opentelemetry-otlp/src/metric.rs

@@ -1,6 +1,6 @@
 //! OTEL metric exporter
 //!
-//! Defines a [MetricsExporter] to send metric data to backend via OTLP protocol.
+//! Defines a [MetricExporter] to send metric data to backend via OTLP protocol.
 //!
 
 #[cfg(any(feature = "http-proto", feature = "http-json", feature = "grpc-tonic"))]
@@ -39,81 +39,81 @@ pub const OTEL_EXPORTER_OTLP_METRICS_COMPRESSION: &str = "OTEL_EXPORTER_OTLP_MET
 pub const OTEL_EXPORTER_OTLP_METRICS_HEADERS: &str = "OTEL_EXPORTER_OTLP_METRICS_HEADERS";
 
 #[derive(Debug, Default, Clone)]
-pub struct MetricsExporterBuilder<C> {
+pub struct MetricExporterBuilder<C> {
     client: C,
     temporality: Temporality,
 }
 
-impl MetricsExporterBuilder<NoExporterBuilderSet> {
+impl MetricExporterBuilder<NoExporterBuilderSet> {
     pub fn new() -> Self {
-        MetricsExporterBuilder::default()
+        MetricExporterBuilder::default()
     }
 }
 
-impl<C> MetricsExporterBuilder<C> {
+impl<C> MetricExporterBuilder<C> {
     #[cfg(feature = "grpc-tonic")]
-    pub fn with_tonic(self) -> MetricsExporterBuilder<TonicExporterBuilderSet> {
-        MetricsExporterBuilder {
+    pub fn with_tonic(self) -> MetricExporterBuilder<TonicExporterBuilderSet> {
+        MetricExporterBuilder {
             client: TonicExporterBuilderSet(TonicExporterBuilder::default()),
             temporality: self.temporality,
         }
     }
 
     #[cfg(any(feature = "http-proto", feature = "http-json"))]
-    pub fn with_http(self) -> MetricsExporterBuilder<HttpExporterBuilderSet> {
-        MetricsExporterBuilder {
+    pub fn with_http(self) -> MetricExporterBuilder<HttpExporterBuilderSet> {
+        MetricExporterBuilder {
             client: HttpExporterBuilderSet(HttpExporterBuilder::default()),
             temporality: self.temporality,
         }
     }
 
-    pub fn with_temporality(self, temporality: Temporality) -> MetricsExporterBuilder<C> {
-        MetricsExporterBuilder {
+    pub fn with_temporality(self, temporality: Temporality) -> MetricExporterBuilder<C> {
+        MetricExporterBuilder {
             client: self.client,
             temporality,
         }
     }
 }
 
 #[cfg(feature = "grpc-tonic")]
-impl MetricsExporterBuilder<TonicExporterBuilderSet> {
-    pub fn build(self) -> MetricResult<MetricsExporter> {
+impl MetricExporterBuilder<TonicExporterBuilderSet> {
+    pub fn build(self) -> MetricResult<MetricExporter> {
         let exporter = self.client.0.build_metrics_exporter(self.temporality)?;
         Ok(exporter)
     }
 }
 
 #[cfg(any(feature = "http-proto", feature = "http-json"))]
-impl MetricsExporterBuilder<HttpExporterBuilderSet> {
-    pub fn build(self) -> MetricResult<MetricsExporter> {
+impl MetricExporterBuilder<HttpExporterBuilderSet> {
+    pub fn build(self) -> MetricResult<MetricExporter> {
         let exporter = self.client.0.build_metrics_exporter(self.temporality)?;
         Ok(exporter)
     }
 }
 
 #[cfg(feature = "grpc-tonic")]
-impl HasExportConfig for MetricsExporterBuilder<TonicExporterBuilderSet> {
+impl HasExportConfig for MetricExporterBuilder<TonicExporterBuilderSet> {
     fn export_config(&mut self) -> &mut crate::ExportConfig {
         &mut self.client.0.exporter_config
     }
 }
 
 #[cfg(any(feature = "http-proto", feature = "http-json"))]
-impl HasExportConfig for MetricsExporterBuilder<HttpExporterBuilderSet> {
+impl HasExportConfig for MetricExporterBuilder<HttpExporterBuilderSet> {
     fn export_config(&mut self) -> &mut crate::ExportConfig {
         &mut self.client.0.exporter_config
     }
 }
 
 #[cfg(feature = "grpc-tonic")]
-impl HasTonicConfig for MetricsExporterBuilder<TonicExporterBuilderSet> {
+impl HasTonicConfig for MetricExporterBuilder<TonicExporterBuilderSet> {
     fn tonic_config(&mut self) -> &mut crate::TonicConfig {
         &mut self.client.0.tonic_config
     }
 }
 
 #[cfg(any(feature = "http-proto", feature = "http-json"))]
-impl HasHttpConfig for MetricsExporterBuilder<HttpExporterBuilderSet> {
+impl HasHttpConfig for MetricExporterBuilder<HttpExporterBuilderSet> {
     fn http_client_config(&mut self) -> &mut crate::exporter::http::HttpConfig {
         &mut self.client.0.http_config
     }
@@ -127,19 +127,19 @@ pub trait MetricsClient: fmt::Debug + Send + Sync + 'static {
 }
 
 /// Export metrics in OTEL format.
-pub struct MetricsExporter {
+pub struct MetricExporter {
     client: Box<dyn MetricsClient>,
     temporality: Temporality,
 }
 
-impl Debug for MetricsExporter {
+impl Debug for MetricExporter {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("MetricsExporter").finish()
+        f.debug_struct("MetricExporter").finish()
     }
 }
 
 #[async_trait]
-impl PushMetricsExporter for MetricsExporter {
+impl PushMetricsExporter for MetricExporter {
     async fn export(&self, metrics: &mut ResourceMetrics) -> MetricResult<()> {
         self.client.export(metrics).await
     }
@@ -158,15 +158,15 @@ impl PushMetricsExporter for MetricsExporter {
     }
 }
 
-impl MetricsExporter {
-    /// Obtain a builder to configure a [MetricsExporter].
-    pub fn builder() -> MetricsExporterBuilder<NoExporterBuilderSet> {
-        MetricsExporterBuilder::default()
+impl MetricExporter {
+    /// Obtain a builder to configure a [MetricExporter].
+    pub fn builder() -> MetricExporterBuilder<NoExporterBuilderSet> {
+        MetricExporterBuilder::default()
     }
 
     /// Create a new metrics exporter
-    pub fn new(client: impl MetricsClient, temporality: Temporality) -> MetricsExporter {
-        MetricsExporter {
+    pub fn new(client: impl MetricsClient, temporality: Temporality) -> MetricExporter {
+        MetricExporter {
             client: Box::new(client),
             temporality,
         }