Remove ability to specify observable callback on Meter (#2015)

Author: cijothomas

opentelemetry-sdk/src/metrics/instrument.rs

@@ -1,10 +1,7 @@
-use std::{any::Any, borrow::Cow, collections::HashSet, hash::Hash, marker, sync::Arc};
+use std::{any::Any, borrow::Cow, collections::HashSet, hash::Hash, sync::Arc};
 
 use opentelemetry::{
-    metrics::{
-        AsyncInstrument, MetricsError, Result, SyncCounter, SyncGauge, SyncHistogram,
-        SyncUpDownCounter,
-    },
+    metrics::{AsyncInstrument, SyncCounter, SyncGauge, SyncHistogram, SyncUpDownCounter},
     Key, KeyValue,
 };
 
@@ -13,8 +10,6 @@ use crate::{
     metrics::{aggregation::Aggregation, internal::Measure},
 };
 
-pub(crate) const EMPTY_MEASURE_MSG: &str = "no aggregators for observable instrument";
-
 /// The identifier of a group of instruments that all perform the same function.
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub enum InstrumentKind {
@@ -289,89 +284,14 @@ impl<T: Copy + 'static> SyncHistogram<T> for ResolvedMeasures<T> {
     }
 }
 
-/// A comparable unique identifier of an observable.
-#[derive(Clone, Debug)]
-pub(crate) struct ObservableId<T> {
-    pub(crate) inner: IdInner,
-    _marker: marker::PhantomData<T>,
-}
-
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub(crate) struct IdInner {
-    /// The human-readable identifier of the instrument.
-    pub(crate) name: Cow<'static, str>,
-    /// describes the purpose of the instrument.
-    pub(crate) description: Cow<'static, str>,
-    /// The functional group of the instrument.
-    kind: InstrumentKind,
-    /// The unit of measurement recorded by the instrument.
-    pub(crate) unit: Cow<'static, str>,
-    /// The instrumentation that created the instrument.
-    scope: Scope,
-}
-
-impl<T> Hash for ObservableId<T> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.inner.hash(state)
-    }
-}
-
-impl<T> PartialEq for ObservableId<T> {
-    fn eq(&self, other: &Self) -> bool {
-        self.inner == other.inner
-    }
-}
-
-impl<T> Eq for ObservableId<T> {}
-
 #[derive(Clone)]
 pub(crate) struct Observable<T> {
-    pub(crate) id: ObservableId<T>,
     measures: Vec<Arc<dyn Measure<T>>>,
 }
 
 impl<T> Observable<T> {
-    pub(crate) fn new(
-        scope: Scope,
-        kind: InstrumentKind,
-        name: Cow<'static, str>,
-        description: Cow<'static, str>,
-        unit: Cow<'static, str>,
-        measures: Vec<Arc<dyn Measure<T>>>,
-    ) -> Self {
-        Self {
-            id: ObservableId {
-                inner: IdInner {
-                    name,
-                    description,
-                    kind,
-                    unit,
-                    scope,
-                },
-                _marker: marker::PhantomData,
-            },
-            measures,
-        }
-    }
-
-    /// Returns `Err` if the observable should not be registered, and `Ok` if it
-    /// should.
-    ///
-    /// An error is returned if this observable is effectively a no-op because it does not have
-    /// any aggregators. Also, an error is returned if scope defines a Meter other
-    /// than the observable it was created by.
-    pub(crate) fn registerable(&self, scope: &Scope) -> Result<()> {
-        if self.measures.is_empty() {
-            return Err(MetricsError::Other(EMPTY_MEASURE_MSG.into()));
-        }
-        if &self.id.inner.scope != scope {
-            return Err(MetricsError::Other(format!(
-                "invalid registration: observable {} from Meter {:?}, registered with Meter {}",
-                self.id.inner.name, self.id.inner.scope, scope.name,
-            )));
-        }
-
-        Ok(())
+    pub(crate) fn new(measures: Vec<Arc<dyn Measure<T>>>) -> Self {
+        Self { measures }
     }
 }